import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url);
import{__export}from"./chunk-JXWJOIH4.js";var build_exports={};__export(build_exports,{AddImmutable:()=>AddImmutable,AddImmutableDeferred:()=>AddImmutableDeferred,AddOptional:()=>AddOptional,AddOptionalDeferred:()=>AddOptionalDeferred,AddReadonly:()=>AddReadonly,AddReadonlyDeferred:()=>AddReadonlyDeferred,Any:()=>Any,Array:()=>_Array_,ArrayOptions:()=>ArrayOptions,BigInt:()=>BigInt2,BigIntPattern:()=>BigIntPattern,Boolean:()=>Boolean2,Broaden:()=>Broaden,Call:()=>Call2,CallConstruct:()=>CallConstruct,CanComposite:()=>CanComposite,Capitalize:()=>Capitalize,CapitalizeAction:()=>CapitalizeAction,CapitalizeDeferred:()=>CapitalizeDeferred,CapitalizeInstantiate:()=>CapitalizeInstantiate,Codec:()=>Codec,CollapseToObject:()=>CollapseToObject,Compare:()=>Compare,CompareResultDisjoint:()=>CompareResultDisjoint,CompareResultEqual:()=>CompareResultEqual,CompareResultLeftInside:()=>CompareResultLeftInside,CompareResultRightInside:()=>CompareResultRightInside,Composite:()=>Composite,Conditional:()=>Conditional,ConditionalAction:()=>ConditionalAction,ConditionalDeferred:()=>ConditionalDeferred,ConditionalInstantiate:()=>ConditionalInstantiate,Constructor:()=>Constructor,ConstructorOptions:()=>ConstructorOptions,ConstructorParameters:()=>ConstructorParameters,ConstructorParametersAction:()=>ConstructorParametersAction,ConstructorParametersDeferred:()=>ConstructorParametersDeferred,ConstructorParametersInstantiate:()=>ConstructorParametersInstantiate,ConvertToIntegerKey:()=>ConvertToIntegerKey,Cyclic:()=>Cyclic,CyclicCandidates:()=>CyclicCandidates,CyclicCheck:()=>CyclicCheck,CyclicDependencies:()=>CyclicDependencies,CyclicExtends:()=>CyclicExtends,CyclicOptions:()=>CyclicOptions,CyclicTarget:()=>CyclicTarget,Decode:()=>Decode,DecodeBuilder:()=>DecodeBuilder,Deferred:()=>Deferred,Dependent:()=>Dependent,DependentOptions:()=>DependentOptions,Distribute:()=>Distribute,Encode:()=>Encode,EncodeBuilder:()=>EncodeBuilder,Enum:()=>Enum,Evaluate:()=>Evaluate2,EvaluateAction:()=>EvaluateAction,EvaluateDeferred:()=>EvaluateDeferred,EvaluateDependent:()=>EvaluateDependent,EvaluateEnum:()=>EvaluateEnum,EvaluateInstantiate:()=>EvaluateInstantiate,EvaluateIntersect:()=>EvaluateIntersect,EvaluateTemplateLiteral:()=>EvaluateTemplateLiteral,EvaluateType:()=>EvaluateType,EvaluateUnion:()=>EvaluateUnion,EvaluateUnionFast:()=>EvaluateUnionFast,Exclude:()=>Exclude,ExcludeAction:()=>ExcludeAction,ExcludeDeferred:()=>ExcludeDeferred,ExcludeInstantiate:()=>ExcludeInstantiate,Extends:()=>Extends,ExtendsResult:()=>result_exports,Extract:()=>Extract,ExtractAction:()=>ExtractAction,ExtractDeferred:()=>ExtractDeferred,ExtractInstantiate:()=>ExtractInstantiate,Flatten:()=>Flatten,Function:()=>_Function_,FunctionOptions:()=>FunctionOptions,Generic:()=>Generic,Identifier:()=>Identifier,Immutable:()=>Immutable,Index:()=>Index,IndexAction:()=>IndexAction,IndexDeferred:()=>IndexDeferred,IndexInstantiate:()=>IndexInstantiate,Infer:()=>Infer,InstanceType:()=>InstanceType,InstanceTypeAction:()=>InstanceTypeAction,InstanceTypeDeferred:()=>InstanceTypeDeferred,InstanceTypeInstantiate:()=>InstanceTypeInstantiate,Instantiate:()=>Instantiate,InstantiateCyclic:()=>InstantiateCyclic,Integer:()=>Integer,IntegerKey:()=>IntegerKey,IntegerPattern:()=>IntegerPattern,Interface:()=>Interface,InterfaceAction:()=>InterfaceAction,InterfaceDeferred:()=>InterfaceDeferred,InterfaceInstantiate:()=>InterfaceInstantiate,Intersect:()=>Intersect,IntersectOptions:()=>IntersectOptions,InvalidLiteralValue:()=>InvalidLiteralValue,IsAny:()=>IsAny,IsArray:()=>IsArray3,IsBigInt:()=>IsBigInt3,IsBoolean:()=>IsBoolean4,IsCall:()=>IsCall,IsCodec:()=>IsCodec,IsConstructor:()=>IsConstructor3,IsCyclic:()=>IsCyclic,IsDeferred:()=>IsDeferred,IsDependent:()=>IsDependent,IsEnum:()=>IsEnum,IsEnumValue:()=>IsEnumValue,IsFunction:()=>IsFunction3,IsGeneric:()=>IsGeneric,IsIdentifier:()=>IsIdentifier2,IsImmutable:()=>IsImmutable,IsInfer:()=>IsInfer,IsInteger:()=>IsInteger3,IsInterfaceDeferred:()=>IsInterfaceDeferred,IsIntersect:()=>IsIntersect,IsKind:()=>IsKind,IsLiteral:()=>IsLiteral,IsLiteralBigInt:()=>IsLiteralBigInt,IsLiteralBoolean:()=>IsLiteralBoolean,IsLiteralNumber:()=>IsLiteralNumber,IsLiteralString:()=>IsLiteralString,IsLiteralValue:()=>IsLiteralValue,IsNever:()=>IsNever,IsNull:()=>IsNull3,IsNumber:()=>IsNumber4,IsObject:()=>IsObject3,IsOptional:()=>IsOptional,IsParameter:()=>IsParameter,IsReadonly:()=>IsReadonly,IsRecord:()=>IsRecord,IsRef:()=>IsRef,IsRefine:()=>IsRefine,IsRefinement:()=>IsRefinement,IsRest:()=>IsRest,IsSchema:()=>IsSchema,IsString:()=>IsString4,IsSymbol:()=>IsSymbol3,IsTemplateLiteral:()=>IsTemplateLiteral,IsTemplateLiteralDeferred:()=>IsTemplateLiteralDeferred,IsTemplateLiteralFinite:()=>IsTemplateLiteralFinite,IsTemplateLiteralPattern:()=>IsTemplateLiteralPattern,IsThis:()=>IsThis,IsTuple:()=>IsTuple,IsTypeScriptEnumLike:()=>IsTypeScriptEnumLike,IsUndefined:()=>IsUndefined3,IsUnion:()=>IsUnion,IsUnknown:()=>IsUnknown,IsUnsafe:()=>IsUnsafe,IsVoid:()=>IsVoid,KeyOf:()=>KeyOf2,KeyOfAction:()=>KeyOfAction,KeyOfDeferred:()=>KeyOfDeferred,KeyOfInstantiate:()=>KeyOfInstantiate,KeysToIndexer:()=>KeysToIndexer,Literal:()=>Literal,LiteralTypeName:()=>LiteralTypeName,Lowercase:()=>Lowercase,LowercaseAction:()=>LowercaseAction,LowercaseDeferred:()=>LowercaseDeferred,LowercaseInstantiate:()=>LowercaseInstantiate,Mapped:()=>Mapped,MappedAction:()=>MappedAction,MappedDeferred:()=>MappedDeferred,MappedInstantiate:()=>MappedInstantiate,Module:()=>Module2,ModuleDeferred:()=>ModuleDeferred,ModuleInstantiate:()=>ModuleInstantiate,Narrow:()=>Narrow,Never:()=>Never,NeverPattern:()=>NeverPattern,NonNullable:()=>NonNullable,NonNullableAction:()=>NonNullableAction,NonNullableDeferred:()=>NonNullableDeferred,NonNullableInstantiate:()=>NonNullableInstantiate,Null:()=>Null,Number:()=>Number2,NumberKey:()=>NumberKey,NumberPattern:()=>NumberPattern,Object:()=>_Object_,ObjectOptions:()=>ObjectOptions,Omit:()=>Omit,OmitAction:()=>OmitAction,OmitDeferred:()=>OmitDeferred,OmitInstantiate:()=>OmitInstantiate,Optional:()=>Optional,Parameter:()=>Parameter,Parameters:()=>Parameters,ParametersAction:()=>ParametersAction,ParametersDeferred:()=>ParametersDeferred,ParametersInstantiate:()=>ParametersInstantiate,ParsePatternIntoTypes:()=>ParsePatternIntoTypes,ParseTemplateIntoTypes:()=>ParseTemplateIntoTypes,Partial:()=>Partial,PartialAction:()=>PartialAction,PartialDeferred:()=>PartialDeferred,PartialInstantiate:()=>PartialInstantiate,Pick:()=>Pick,PickAction:()=>PickAction,PickDeferred:()=>PickDeferred,PickInstantiate:()=>PickInstantiate,Priority:()=>Priority,PropertyKeys:()=>PropertyKeys,PropertyValues:()=>PropertyValues,Readonly:()=>Readonly,ReadonlyObject:()=>ReadonlyObject,ReadonlyObjectAction:()=>ReadonlyObjectAction,ReadonlyObjectDeferred:()=>ReadonlyObjectDeferred,ReadonlyObjectInstantiate:()=>ReadonlyObjectInstantiate,ReadonlyType:()=>ReadonlyType,Record:()=>Record,RecordAction:()=>RecordAction,RecordDeferred:()=>RecordDeferred,RecordFromPattern:()=>RecordFromPattern,RecordInstantiate:()=>RecordInstantiate,RecordKey:()=>RecordKey,RecordOptions:()=>RecordOptions,RecordPattern:()=>RecordPattern,RecordPatternToType:()=>RecordPatternToType,RecordValue:()=>RecordValue,Ref:()=>Ref,RefInstantiate:()=>RefInstantiate,Refine:()=>Refine,RefineAdd:()=>RefineAdd,RemoveImmutable:()=>RemoveImmutable,RemoveImmutableDeferred:()=>RemoveImmutableDeferred,RemoveOptional:()=>RemoveOptional,RemoveOptionalDeferred:()=>RemoveOptionalDeferred,RemoveReadonly:()=>RemoveReadonly,RemoveReadonlyDeferred:()=>RemoveReadonlyDeferred,Required:()=>Required,RequiredAction:()=>RequiredAction,RequiredArray:()=>RequiredArray,RequiredDeferred:()=>RequiredDeferred,RequiredInstantiate:()=>RequiredInstantiate,Rest:()=>Rest,ReturnType:()=>ReturnType,ReturnTypeAction:()=>ReturnTypeAction,ReturnTypeDeferred:()=>ReturnTypeDeferred,ReturnTypeInstantiate:()=>ReturnTypeInstantiate,Script:()=>Script2,String:()=>String2,StringKey:()=>StringKey,StringPattern:()=>StringPattern,Symbol:()=>Symbol,TemplateLiteral:()=>TemplateLiteral2,TemplateLiteralCreate:()=>TemplateLiteralCreate,TemplateLiteralDecode:()=>TemplateLiteralDecode,TemplateLiteralDecodeUnsafe:()=>TemplateLiteralDecodeUnsafe,TemplateLiteralDeferred:()=>TemplateLiteralDeferred,TemplateLiteralEncode:()=>TemplateLiteralEncode,TemplateLiteralFromString:()=>TemplateLiteralFromString,TemplateLiteralFromTypes:()=>TemplateLiteralFromTypes,This:()=>This,Tuple:()=>Tuple,TupleOptions:()=>TupleOptions,Type:()=>typebox_exports,TypeScriptEnumToEnumValues:()=>TypeScriptEnumToEnumValues,Uncapitalize:()=>Uncapitalize,UncapitalizeAction:()=>UncapitalizeAction,UncapitalizeDeferred:()=>UncapitalizeDeferred,UncapitalizeInstantiate:()=>UncapitalizeInstantiate,Undefined:()=>Undefined,Union:()=>Union,UnionOptions:()=>UnionOptions,Unknown:()=>Unknown,Unsafe:()=>Unsafe,Uppercase:()=>Uppercase,UppercaseAction:()=>UppercaseAction,UppercaseDeferred:()=>UppercaseDeferred,UppercaseInstantiate:()=>UppercaseInstantiate,Void:()=>Void,With:()=>With2,WithAction:()=>WithAction,WithDeferred:()=>WithDeferred,WithInstantiate:()=>WithInstantiate,_Array_:()=>_Array_,_Function_:()=>_Function_,_Object_:()=>_Object_,default:()=>build_default});var memory_exports={};__export(memory_exports,{Assign:()=>Assign,Clone:()=>Clone,Create:()=>Create,Discard:()=>Discard,Metrics:()=>Metrics,Update:()=>Update});var Metrics={assign:0,create:0,clone:0,discard:0,update:0};var settings_exports={};__export(settings_exports,{Get:()=>Get,Reset:()=>Reset,Set:()=>Set2});var emit_exports={};__export(emit_exports,{And:()=>And,ArrayLiteral:()=>ArrayLiteral,ArrowFunction:()=>ArrowFunction,Call:()=>Call,ConstDeclaration:()=>ConstDeclaration,Constant:()=>Constant,Counted:()=>Counted2,Entries:()=>Entries2,Every:()=>Every2,HasPropertyKey:()=>HasPropertyKey2,If:()=>If,IsArray:()=>IsArray2,IsBigInt:()=>IsBigInt2,IsBoolean:()=>IsBoolean2,IsConstructor:()=>IsConstructor2,IsDeepEqual:()=>IsDeepEqual2,IsEqual:()=>IsEqual2,IsFunction:()=>IsFunction2,IsGreaterEqualThan:()=>IsGreaterEqualThan2,IsGreaterThan:()=>IsGreaterThan2,IsInteger:()=>IsInteger2,IsLessEqualThan:()=>IsLessEqualThan2,IsLessThan:()=>IsLessThan2,IsMaxLength:()=>IsMaxLength3,IsMinLength:()=>IsMinLength3,IsNull:()=>IsNull2,IsNumber:()=>IsNumber2,IsObject:()=>IsObject2,IsObjectNotArray:()=>IsObjectNotArray2,IsString:()=>IsString2,IsSymbol:()=>IsSymbol2,IsUndefined:()=>IsUndefined2,Keys:()=>Keys2,Member:()=>Member,MultipleOf:()=>MultipleOf,New:()=>New,Not:()=>Not,Or:()=>Or,ReduceAnd:()=>ReduceAnd,ReduceOr:()=>ReduceOr,Return:()=>Return,Some:()=>Some2,SomeAll:()=>SomeAll2,Statements:()=>Statements,Ternary:()=>Ternary});var guard_exports={};__export(guard_exports,{Counted:()=>Counted,Entries:()=>Entries,EntriesRegExp:()=>EntriesRegExp,Every:()=>Every,EveryAll:()=>EveryAll,GraphemeCount:()=>GraphemeCount2,HasPropertyKey:()=>HasPropertyKey,IsArray:()=>IsArray,IsBigInt:()=>IsBigInt,IsBoolean:()=>IsBoolean,IsClassInstance:()=>IsClassInstance,IsConstructor:()=>IsConstructor,IsDeepEqual:()=>IsDeepEqual,IsEqual:()=>IsEqual,IsFunction:()=>IsFunction,IsGreaterEqualThan:()=>IsGreaterEqualThan,IsGreaterThan:()=>IsGreaterThan,IsInteger:()=>IsInteger,IsLessEqualThan:()=>IsLessEqualThan,IsLessThan:()=>IsLessThan,IsMaxLength:()=>IsMaxLength2,IsMinLength:()=>IsMinLength2,IsMultipleOf:()=>IsMultipleOf,IsNull:()=>IsNull,IsNumber:()=>IsNumber,IsObject:()=>IsObject,IsObjectNotArray:()=>IsObjectNotArray,IsString:()=>IsString,IsSymbol:()=>IsSymbol,IsUndefined:()=>IsUndefined,IsUnsafePropertyKey:()=>IsUnsafePropertyKey,IsValueLike:()=>IsValueLike,Keys:()=>Keys,ShiftLeft:()=>ShiftLeft,Some:()=>Some,SomeAll:()=>SomeAll,Symbols:()=>Symbols,Values:()=>Values});function IsBetween(value,min,max){return value>=min&&value<=max}function IsZeroWidthJoiner(value){return value===8205}function IsHighSurrogate(value){return IsBetween(value,55296,56319)}function IsRegionalIndicator(value){return IsBetween(value,127462,127487)}function IsVariationSelector(value){return IsBetween(value,65024,65039)}function IsCombiningMark(value){return IsBetween(value,768,879)||IsBetween(value,6832,6911)||IsBetween(value,7616,7679)||IsBetween(value,65056,65071)}function CodePointLength(value){return value>65535?2:1}function ConsumeModifiers(value,index){for(;index<value.length;){let point=value.codePointAt(index);if(IsCombiningMark(point)||IsVariationSelector(point))index+=CodePointLength(point);else break}return index}function NextGraphemeClusterIndex(value,clusterStart){let startCP=value.codePointAt(clusterStart),clusterEnd=clusterStart+CodePointLength(startCP);for(clusterEnd=ConsumeModifiers(value,clusterEnd);clusterEnd<value.length-1&&IsZeroWidthJoiner(value.codePointAt(clusterEnd));){let nextCP=value.codePointAt(clusterEnd+1);clusterEnd+=1+CodePointLength(nextCP),clusterEnd=ConsumeModifiers(value,clusterEnd)}return IsRegionalIndicator(startCP)&&clusterEnd<value.length&&IsRegionalIndicator(value.codePointAt(clusterEnd))&&(clusterEnd+=CodePointLength(value.codePointAt(clusterEnd))),clusterEnd}function IsGraphemeCodePoint(value){return value>=768&&(IsHighSurrogate(value)||IsCombiningMark(value)||IsVariationSelector(value)||IsZeroWidthJoiner(value))}function GraphemeCount(value){let count=0,index=0;for(;index<value.length;)index=NextGraphemeClusterIndex(value,index),count++;return count}function IsMinLengthSegmented(value,minLength){let count=0,index=0;for(;index<value.length;)if(index=NextGraphemeClusterIndex(value,index),++count>=minLength)return!0;return!1}function IsMaxLengthSegmented(value,maxLength){let count=0,index=0;for(;index<value.length;)if(index=NextGraphemeClusterIndex(value,index),++count>maxLength)return!1;return!0}function IsMinLength(value,minLength){if(minLength===0)return!0;if(value.length<minLength)return!1;let index=0;for(;;){if(IsGraphemeCodePoint(value.charCodeAt(index)))return IsMinLengthSegmented(value,minLength);if(++index>=minLength)return!0}}function IsMaxLength(value,maxLength){if(value.length<=maxLength)return!0;let index=0;for(;;){if(IsGraphemeCodePoint(value.charCodeAt(index)))return IsMaxLengthSegmented(value,maxLength);if(++index>maxLength)return!1}}function IsArray(value){return Array.isArray(value)}function IsBigInt(value){return IsEqual(typeof value,"bigint")}function IsBoolean(value){return IsEqual(typeof value,"boolean")}function IsConstructor(value){if(IsUndefined(value)||!IsFunction(value))return!1;let result=Function.prototype.toString.call(value);return!!(/^class\s/.test(result)||/\[native code\]/.test(result))}function IsFunction(value){return IsEqual(typeof value,"function")}function IsInteger(value){return Number.isInteger(value)}function IsNull(value){return IsEqual(value,null)}function IsNumber(value){return Number.isFinite(value)}function IsObjectNotArray(value){return IsObject(value)&&!IsArray(value)}function IsObject(value){return IsEqual(typeof value,"object")&&!IsNull(value)}function IsString(value){return IsEqual(typeof value,"string")}function IsSymbol(value){return IsEqual(typeof value,"symbol")}function IsUndefined(value){return IsEqual(value,void 0)}function IsEqual(left,right){return left===right}function IsGreaterThan(left,right){return left>right}function IsLessThan(left,right){return left<right}function IsLessEqualThan(left,right){return left<=right}function IsGreaterEqualThan(left,right){return left>=right}function IsMultipleOf(dividend,divisor){if(IsBigInt(dividend)||IsBigInt(divisor))return BigInt(dividend)%BigInt(divisor)===0n;let tolerance=1e-10;if(!IsNumber(dividend)||IsInteger(dividend)&&1/divisor%1===0)return!0;let mod=dividend%divisor;return Math.min(Math.abs(mod),Math.abs(mod-divisor),Math.abs(mod+divisor))<tolerance}function IsClassInstance(value){if(!IsObject(value))return!1;let proto=globalThis.Object.getPrototypeOf(value);return IsNull(proto)?!1:IsEqual(typeof proto.constructor,"function")&&!(IsEqual(proto.constructor,globalThis.Object)||IsEqual(proto.constructor.name,"Object"))}function IsValueLike(value){return IsBigInt(value)||IsBoolean(value)||IsNull(value)||IsNumber(value)||IsString(value)||IsUndefined(value)}function GraphemeCount2(value){return GraphemeCount(value)}function IsMaxLength2(value,length){return IsMaxLength(value,length)}function IsMinLength2(value,length){return IsMinLength(value,length)}function Every(value,offset,callback){return value.every((item,index)=>index<offset||callback(item,index))}function EveryAll(value,offset,callback){let result=!0;return value.forEach((item,index)=>{index>=offset&&!callback(item,index)&&(result=!1)}),result}function Some(value,callback){return value.some((value2,index)=>callback(value2,index))}function SomeAll(value,callback){let result=!1;return value.forEach((item,index)=>{callback(item,index)&&(result=!0)}),result}function Counted(value,callback){return value.reduce((result,value2,index)=>callback(value2,index)?++result:result,0)}function ShiftLeft(array,true_,false_){return IsEqual(array.length,0)?false_():true_(array[0],array.slice(1))}function IsUnsafePropertyKey(key){return IsEqual(key,"__proto__")||IsEqual(key,"constructor")||IsEqual(key,"prototype")}function HasPropertyKey(value,key){return IsUnsafePropertyKey(key)?Object.prototype.hasOwnProperty.call(value,key):key in value}function EntriesRegExp(value){return Keys(value).map(key=>[new RegExp(`^${key}$`),value[key]])}function Entries(value){return Object.entries(value)}function Keys(value){return Object.getOwnPropertyNames(value)}function Symbols(value){return Object.getOwnPropertySymbols(value)}function Values(value){return Object.values(value)}function DeepEqualObject(left,right){if(!IsObject(right))return!1;let keys=Keys(left);return IsEqual(keys.length,Keys(right).length)&&keys.every(key=>IsDeepEqual(left[key],right[key]))}function DeepEqualArray(left,right){return IsArray(right)&&IsEqual(left.length,right.length)&&left.every((_,index)=>IsDeepEqual(left[index],right[index]))}function IsDeepEqual(left,right){return IsArray(left)?DeepEqualArray(left,right):IsObject(left)?DeepEqualObject(left,right):IsEqual(left,right)}var identifierRegExp=/^[\p{ID_Start}_$][\p{ID_Continue}_$\u200C\u200D]*$/u;function IsIdentifier(value){return identifierRegExp.test(value)}function And(left,right){return`(${left} && ${right})`}function Or(left,right){return`(${left} || ${right})`}function Not(expr){return`!(${expr})`}function IsArray2(value){return`Array.isArray(${value})`}function IsBigInt2(value){return`typeof ${value} === "bigint"`}function IsBoolean2(value){return`typeof ${value} === "boolean"`}function IsInteger2(value){return`Number.isInteger(${value})`}function IsNull2(value){return`${value} === null`}function IsNumber2(value){return`Number.isFinite(${value})`}function IsObjectNotArray2(value){return And(IsObject2(value),Not(IsArray2(value)))}function IsObject2(value){return`typeof ${value} === "object" && ${value} !== null`}function IsString2(value){return`typeof ${value} === "string"`}function IsSymbol2(value){return`typeof ${value} === "symbol"`}function IsUndefined2(value){return`${value} === undefined`}function IsFunction2(value){return`typeof ${value} === "function"`}function IsConstructor2(value){return`Guard.IsConstructor(${value})`}function IsEqual2(left,right){return`${left} === ${right}`}function IsGreaterThan2(left,right){return`${left} > ${right}`}function IsLessThan2(left,right){return`${left} < ${right}`}function IsLessEqualThan2(left,right){return`${left} <= ${right}`}function IsGreaterEqualThan2(left,right){return`${left} >= ${right}`}function IsMinLength3(value,length){return`Guard.IsMinLength(${value}, ${length})`}function IsMaxLength3(value,length){return`Guard.IsMaxLength(${value}, ${length})`}function Every2(value,offset,params,expression){return IsEqual(offset,"0")?`${value}.every((${params[0]}, ${params[1]}) => (${expression}))`:`${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`}function Some2(value,params,expression){return`${value}.some((${params[0]}, ${params[1]}) => ${expression})`}function SomeAll2(value,params,expression){return`((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`}function Counted2(value,params,expression){return`${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`}function Entries2(value){return`Object.entries(${value})`}function Keys2(value){return`Object.getOwnPropertyNames(${value})`}function HasPropertyKey2(value,key){return IsEqual(key,'"__proto__"')||IsEqual(key,'"constructor"')?`Object.prototype.hasOwnProperty.call(${value}, ${key})`:`${key} in ${value}`}function IsDeepEqual2(left,right){return`Guard.IsDeepEqual(${left}, ${right})`}function ArrayLiteral(elements){return`[${elements.join(", ")}]`}function ArrowFunction(parameters,body){return`((${parameters.join(", ")}) => ${body})`}function Call(value,arguments_){return`${value}(${arguments_.join(", ")})`}function New(value,arguments_){return`new ${value}(${arguments_.join(", ")})`}function Member(left,right){return`${left}${IsIdentifier(right)?`.${right}`:`[${Constant(right)}]`}`}function Constant(value){if(!IsValueLike(value))throw Error("Unsupported Constant");return IsString(value)?JSON.stringify(value):`${value}`}function Ternary(condition,true_,false_){return`(${condition} ? ${true_} : ${false_})`}function Statements(statements){return`{ ${statements.join("; ")}; }`}function ConstDeclaration(identifier,expression){return`const ${identifier} = ${expression}`}function If(condition,then){return`if(${condition}) { ${then} }`}function Return(expression){return`return ${expression}`}function ReduceAnd(operands){return IsEqual(operands.length,0)?"true":operands.reduce((left,right)=>And(left,right))}function ReduceOr(operands){return IsEqual(operands.length,0)?"false":operands.reduce((left,right)=>Or(left,right))}function MultipleOf(dividend,divisor){return`Guard.IsMultipleOf(${dividend}, ${divisor})`}var globals_exports={};__export(globals_exports,{IsBigInt64Array:()=>IsBigInt64Array,IsBigUint64Array:()=>IsBigUint64Array,IsBoolean:()=>IsBoolean3,IsDate:()=>IsDate,IsFloat32Array:()=>IsFloat32Array,IsFloat64Array:()=>IsFloat64Array,IsInt16Array:()=>IsInt16Array,IsInt32Array:()=>IsInt32Array,IsInt8Array:()=>IsInt8Array,IsMap:()=>IsMap,IsNumber:()=>IsNumber3,IsRegExp:()=>IsRegExp,IsSet:()=>IsSet,IsString:()=>IsString3,IsTypeArray:()=>IsTypeArray,IsUint16Array:()=>IsUint16Array,IsUint32Array:()=>IsUint32Array,IsUint8Array:()=>IsUint8Array,IsUint8ClampedArray:()=>IsUint8ClampedArray});function IsBoolean3(value){return value instanceof Boolean}function IsNumber3(value){return value instanceof Number}function IsString3(value){return value instanceof String}function IsTypeArray(value){return globalThis.ArrayBuffer.isView(value)}function IsInt8Array(value){return value instanceof globalThis.Int8Array}function IsUint8Array(value){return value instanceof globalThis.Uint8Array}function IsUint8ClampedArray(value){return value instanceof globalThis.Uint8ClampedArray}function IsInt16Array(value){return value instanceof globalThis.Int16Array}function IsUint16Array(value){return value instanceof globalThis.Uint16Array}function IsInt32Array(value){return value instanceof globalThis.Int32Array}function IsUint32Array(value){return value instanceof globalThis.Uint32Array}function IsFloat32Array(value){return value instanceof globalThis.Float32Array}function IsFloat64Array(value){return value instanceof globalThis.Float64Array}function IsBigInt64Array(value){return value instanceof globalThis.BigInt64Array}function IsBigUint64Array(value){return value instanceof globalThis.BigUint64Array}function IsRegExp(value){return value instanceof globalThis.RegExp}function IsDate(value){return value instanceof globalThis.Date}function IsSet(value){return value instanceof globalThis.Set}function IsMap(value){return value instanceof globalThis.Map}var guard_default=guard_exports;var settings={immutableTypes:!1,maxErrors:8,maxInstantiationCount:128,useAcceleration:!0,exactOptionalPropertyTypes:!1,enumerableKind:!1,correctiveParse:!1,unionPrioritySort:!0};function Reset(){settings.immutableTypes=!1,settings.maxErrors=8,settings.maxInstantiationCount=128,settings.useAcceleration=!0,settings.exactOptionalPropertyTypes=!1,settings.enumerableKind=!1,settings.correctiveParse=!1,settings.unionPrioritySort=!0}function Set2(options){for(let key of guard_exports.Keys(options)){let value=options[key];value!==void 0&&Object.defineProperty(settings,key,{value})}}function Get(){return settings}function Freeze(value){return settings_exports.Get().immutableTypes?Object.freeze(value):value}function Assign(left,right){return Metrics.assign+=1,Freeze({...left,...right})}function IsSchemaObject(value){return guard_exports.HasPropertyKey(value,"~kind")||guard_exports.HasPropertyKey(value,"~unsafe")}function FromSchemaObject(value){let result={};for(let key of guard_exports.Keys(value)){if(guard_exports.IsUnsafePropertyKey(key))continue;let descriptor=Object.getOwnPropertyDescriptor(value,key);descriptor.value=FromValue(descriptor.value),guard_exports.IsEqual(descriptor.enumerable,!0)?result[key]=descriptor.value:Object.defineProperty(result,key,descriptor)}return result}function FromPlainObject(value){let result={};for(let key of guard_exports.Keys(value))guard_exports.IsUnsafePropertyKey(key)||(result[key]=FromValue(value[key]));for(let key of guard_exports.Symbols(value))result[key]=FromValue(value[key]);return result}function FromObject(value){return guard_exports.IsClassInstance(value)?value:IsSchemaObject(value)?FromSchemaObject(value):FromPlainObject(value)}function FromArray(value){return value.map(element=>FromValue(element))}function FromTypedArray(value){return value.slice()}function FromRegExp(value){return new RegExp(value.source,value.flags)}function FromMap(value){return new Map(FromValue([...value.entries()]))}function FromSet(value){return new Set(FromValue([...value.values()]))}function FromValue(value){return globals_exports.IsTypeArray(value)?FromTypedArray(value):globals_exports.IsRegExp(value)?FromRegExp(value):globals_exports.IsMap(value)?FromMap(value):globals_exports.IsSet(value)?FromSet(value):guard_exports.IsArray(value)?FromArray(value):guard_exports.IsObject(value)?FromObject(value):value}function Clone(value){return Metrics.clone+=1,FromValue(value)}function MergeHidden(left,right){for(let key of Object.keys(right))Object.defineProperty(left,key,{configurable:!0,writable:!0,enumerable:!1,value:right[key]});return left}function Merge(left,right){return{...left,...right}}function Create(hidden,enumerable,options={}){Metrics.create+=1;let withOptions=Merge(enumerable,options),withHidden=settings_exports.Get().enumerableKind?Merge(withOptions,hidden):MergeHidden(withOptions,hidden);return Freeze(withHidden)}function Discard(value,propertyKeys){Metrics.discard+=1;let result={};for(let key of guard_exports.Keys(value)){if(propertyKeys.includes(key))continue;let descriptor=Object.getOwnPropertyDescriptor(value,key);descriptor.value=Clone(descriptor.value),Object.defineProperty(result,key,descriptor)}return Freeze(result)}function Update(current,hidden,enumerable){Metrics.update+=1;let settings2=settings_exports.Get(),result=Clone(current);for(let key of Object.keys(hidden))Object.defineProperty(result,key,{configurable:!0,writable:!0,enumerable:settings2.enumerableKind,value:hidden[key]});for(let key of Object.keys(enumerable))Object.defineProperty(result,key,{configurable:!0,enumerable:!0,writable:!0,value:enumerable[key]});return Freeze(result)}function IsKind(value,kind){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.IsEqual(value["~kind"],kind)}function IsSchema(value){return guard_exports.IsObject(value)}function Deferred(action,parameters,options){return memory_exports.Create({"~kind":"Deferred"},{type:"deferred",action,parameters,options},{})}function IsDeferred(value){return IsKind(value,"Deferred")}function AddReadonlyOperation(type){return memory_exports.Update(type,{"~readonly":!0},{})}function AddReadonlyAction(type,options){return memory_exports.Update(AddReadonlyOperation(type),{},options)}function AddReadonlyInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return AddReadonlyAction(instantiatedType,options)}function AddOptionalOperation(type){return memory_exports.Update(type,{"~optional":!0},{})}function AddOptionalAction(type,options){return memory_exports.Update(AddOptionalOperation(type),{},options)}function AddOptionalInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return AddOptionalAction(instantiatedType,options)}function _Array_(items,options){return memory_exports.Create({"~kind":"Array"},{type:"array",items},options)}function IsArray3(value){return IsKind(value,"Array")}function ArrayOptions(type){return memory_exports.Discard(type,["~kind","type","items"])}function Constructor(parameters,instanceType,options={}){return memory_exports.Create({"~kind":"Constructor"},{type:"constructor",parameters,instanceType},options)}function IsConstructor3(value){return IsKind(value,"Constructor")}function ConstructorOptions(type){return memory_exports.Discard(type,["~kind","type","parameters","instanceType"])}function _Function_(parameters,returnType,options={}){return memory_exports.Create({"~kind":"Function"},{type:"function",parameters,returnType},options)}function IsFunction3(value){return IsKind(value,"Function")}function FunctionOptions(type){return memory_exports.Discard(type,["~kind","type","parameters","returnType"])}function Ref(ref,options){return memory_exports.Create({"~kind":"Ref"},{$ref:ref},options)}function IsRef(value){return IsKind(value,"Ref")}function Generic(parameters,expression){return memory_exports.Create({"~kind":"Generic"},{type:"generic",parameters,expression})}function IsGeneric(value){return IsKind(value,"Generic")}function Any(options){return memory_exports.Create({"~kind":"Any"},{},options)}function IsAny(value){return IsKind(value,"Any")}var NeverPattern="(?!)";function Never(options){return memory_exports.Create({"~kind":"Never"},{not:{}},options)}function IsNever(value){return IsKind(value,"Never")}function AddOptionalDeferred(type,options={}){return Deferred("AddOptional",[type],options)}function AddOptional(type,options={}){return AddOptionalAction(type,options)}function Optional(type){return AddOptional(type)}function IsOptional(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"~optional")}function RequiredArray(properties){return guard_exports.Keys(properties).filter(key=>!IsOptional(properties[key]))}function PropertyKeys(properties){return guard_exports.Keys(properties)}function PropertyValues(properties){return guard_exports.Values(properties)}function _Object_(properties,options={}){let requiredKeys=RequiredArray(properties),required=requiredKeys.length>0?{required:requiredKeys}:{};return memory_exports.Create({"~kind":"Object"},{type:"object",...required,properties},options)}function IsObject3(value){return IsKind(value,"Object")}function ObjectOptions(type){return memory_exports.Discard(type,["~kind","type","properties","required"])}function Unknown(options){return memory_exports.Create({"~kind":"Unknown"},{},options)}function IsUnknown(value){return IsKind(value,"Unknown")}function Cyclic($defs,$ref,options){let defs=guard_exports.Keys($defs).reduce((result,key)=>({...result,[key]:memory_exports.Update($defs[key],{},{$id:key})}),{});return memory_exports.Create({"~kind":"Cyclic"},{$defs:defs,$ref},options)}function IsCyclic(value){return IsKind(value,"Cyclic")}function CyclicOptions(type){return memory_exports.Discard(type,["~kind","$defs","$ref"])}function Unsafe(schema){return memory_exports.Update(schema,{"~unsafe":null},{})}function IsUnsafe(value){return guard_exports.IsObjectNotArray(value)&&guard_exports.HasPropertyKey(value,"~unsafe")&&guard_exports.IsNull(value["~unsafe"])}var arguments_exports={};__export(arguments_exports,{Match:()=>Match});function Match(args,match){return match[args.length]?.(...args)??(()=>{throw Error("Invalid Arguments")})()}function Infer(...args){let[name,extends_]=arguments_exports.Match(args,{2:(name2,extends_2)=>[name2,extends_2,extends_2],1:name2=>[name2,Unknown(),Unknown()]});return memory_exports.Create({"~kind":"Infer"},{type:"infer",name,extends:extends_},{})}function IsInfer(value){return IsKind(value,"Infer")}function Dependent(if_,then_,else_,options={}){return memory_exports.Create({"~kind":"Dependent"},{if:if_,then:then_,else:else_},options)}function IsDependent(value){return IsKind(value,"Dependent")}function DependentOptions(type){return memory_exports.Discard(type,["~kind","if","then","else"])}function IsTypeScriptEnumLike(value){return guard_exports.IsObjectNotArray(value)}function TypeScriptEnumToEnumValues(type){return guard_exports.Keys(type).filter(key=>isNaN(key)).reduce((result,key)=>[...result,type[key]],[])}function IsEnumValue(value){return guard_exports.IsString(value)||guard_exports.IsNumber(value)}function Enum(value,options){let values=IsTypeScriptEnumLike(value)?TypeScriptEnumToEnumValues(value):value;return memory_exports.Create({"~kind":"Enum"},{enum:values},options)}function IsEnum(value){return IsKind(value,"Enum")}function Intersect(types,options={}){return memory_exports.Create({"~kind":"Intersect"},{allOf:types},options)}function IsIntersect(value){return IsKind(value,"Intersect")}function IntersectOptions(type){return memory_exports.Discard(type,["~kind","allOf"])}var environment_exports={};__export(environment_exports,{CanEvaluate:()=>CanEvaluate,Evaluate:()=>Evaluate});var supported;function TryEvaluate(){try{return Evaluate("null")(),!0}catch{return!1}}function CanEvaluate(){return guard_exports.IsUndefined(supported)&&(supported=TryEvaluate()),supported&&settings_exports.Get().useAcceleration}function Evaluate(...args){return new globalThis.Function(...args)}var hash_exports={};__export(hash_exports,{Hash:()=>Hash,HashCode:()=>HashCode});function Unreachable(){throw new Error("Unreachable")}function InstanceKeys(value){let propertyKeys=new Set,current=value;for(;current&&current!==Object.prototype;){for(let key of Reflect.ownKeys(current))key!=="constructor"&&typeof key!="symbol"&&propertyKeys.add(key);current=Object.getPrototypeOf(current)}return[...propertyKeys]}function IsIEEE754(value){return typeof value=="number"}var ByteMarker;(function(ByteMarker2){ByteMarker2[ByteMarker2.Array=0]="Array",ByteMarker2[ByteMarker2.BigInt=1]="BigInt",ByteMarker2[ByteMarker2.Boolean=2]="Boolean",ByteMarker2[ByteMarker2.Date=3]="Date",ByteMarker2[ByteMarker2.Constructor=4]="Constructor",ByteMarker2[ByteMarker2.Function=5]="Function",ByteMarker2[ByteMarker2.Null=6]="Null",ByteMarker2[ByteMarker2.Number=7]="Number",ByteMarker2[ByteMarker2.Object=8]="Object",ByteMarker2[ByteMarker2.RegExp=9]="RegExp",ByteMarker2[ByteMarker2.String=10]="String",ByteMarker2[ByteMarker2.Symbol=11]="Symbol",ByteMarker2[ByteMarker2.TypeArray=12]="TypeArray",ByteMarker2[ByteMarker2.Undefined=13]="Undefined"})(ByteMarker||(ByteMarker={}));var Accumulator=BigInt("14695981039346656037"),[Prime,Size]=[BigInt("1099511628211"),BigInt("18446744073709551616")],Bytes=Array.from({length:256}).map((_,i)=>BigInt(i)),F64=new Float64Array(1),F64In=new DataView(F64.buffer),F64Out=new Uint8Array(F64.buffer);function FNV1A64_OP(byte){Accumulator=Accumulator^Bytes[byte],Accumulator=Accumulator*Prime%Size}function FromArray2(value){FNV1A64_OP(ByteMarker.Array);for(let item of value)FromValue2(item)}function FromBigInt(value){FNV1A64_OP(ByteMarker.BigInt),F64In.setBigInt64(0,value);for(let byte of F64Out)FNV1A64_OP(byte)}function FromBoolean(value){FNV1A64_OP(ByteMarker.Boolean),FNV1A64_OP(value?1:0)}function FromConstructor(value){FNV1A64_OP(ByteMarker.Constructor),FromValue2(value.toString())}function FromDate(value){FNV1A64_OP(ByteMarker.Date),FromValue2(value.getTime())}function FromFunction(value){FNV1A64_OP(ByteMarker.Function),FromValue2(value.toString())}function FromNull(_value){FNV1A64_OP(ByteMarker.Null)}function FromNumber(value){FNV1A64_OP(ByteMarker.Number),F64In.setFloat64(0,value,!0);for(let byte of F64Out)FNV1A64_OP(byte)}function FromObject2(value){FNV1A64_OP(ByteMarker.Object);for(let key of InstanceKeys(value).sort())FromValue2(key),FromValue2(value[key])}function FromRegExp2(value){FNV1A64_OP(ByteMarker.RegExp),FromString(value.toString())}var encoder=new TextEncoder;function FromString(value){FNV1A64_OP(ByteMarker.String);for(let byte of encoder.encode(value))FNV1A64_OP(byte)}function FromSymbol(value){FNV1A64_OP(ByteMarker.Symbol),FromValue2(value.toString())}function FromTypeArray(value){FNV1A64_OP(ByteMarker.TypeArray);let buffer=new Uint8Array(value.buffer);for(let i=0;i<buffer.length;i++)FNV1A64_OP(buffer[i])}function FromUndefined(_value){return FNV1A64_OP(ByteMarker.Undefined)}function FromValue2(value){return globals_exports.IsTypeArray(value)?FromTypeArray(value):globals_exports.IsDate(value)?FromDate(value):globals_exports.IsRegExp(value)?FromRegExp2(value):globals_exports.IsBoolean(value)?FromBoolean(value.valueOf()):globals_exports.IsString(value)?FromString(value.valueOf()):globals_exports.IsNumber(value)?FromNumber(value.valueOf()):IsIEEE754(value)?FromNumber(value):guard_exports.IsArray(value)?FromArray2(value):guard_exports.IsBoolean(value)?FromBoolean(value):guard_exports.IsBigInt(value)?FromBigInt(value):guard_exports.IsConstructor(value)?FromConstructor(value):guard_exports.IsNull(value)?FromNull(value):guard_exports.IsObject(value)?FromObject2(value):guard_exports.IsString(value)?FromString(value):guard_exports.IsSymbol(value)?FromSymbol(value):guard_exports.IsUndefined(value)?FromUndefined(value):guard_exports.IsFunction(value)?FromFunction(value):Unreachable()}function HashCode(value){return Accumulator=BigInt("14695981039346656037"),FromValue2(value),Accumulator}function Hash(value){return HashCode(value).toString(16).padStart(16,"0")}function en_US(error){switch(error.keyword){case"additionalProperties":return"must not have additional properties";case"anyOf":return"must match a schema in anyOf";case"boolean":return"schema is false";case"const":return"must be equal to constant";case"contains":return"must contain at least 1 valid item";case"dependencies":return`must have properties ${error.params.dependencies.join(", ")} when property ${error.params.property} is present`;case"dependentRequired":return`must have properties ${error.params.dependencies.join(", ")} when property ${error.params.property} is present`;case"enum":return"must be equal to one of the allowed values";case"exclusiveMaximum":return`must be ${error.params.comparison} ${error.params.limit}`;case"exclusiveMinimum":return`must be ${error.params.comparison} ${error.params.limit}`;case"format":return`must match format "${error.params.format}"`;case"if":return`must match "${error.params.failingKeyword}" schema`;case"maxItems":return`must not have more than ${error.params.limit} items`;case"maxLength":return`must not have more than ${error.params.limit} characters`;case"maxProperties":return`must not have more than ${error.params.limit} properties`;case"maximum":return`must be ${error.params.comparison} ${error.params.limit}`;case"minItems":return`must not have fewer than ${error.params.limit} items`;case"minLength":return`must not have fewer than ${error.params.limit} characters`;case"minProperties":return`must not have fewer than ${error.params.limit} properties`;case"minimum":return`must be ${error.params.comparison} ${error.params.limit}`;case"multipleOf":return`must be multiple of ${error.params.multipleOf}`;case"not":return"must not be valid";case"oneOf":return"must match exactly one schema in oneOf";case"pattern":return`must match pattern "${error.params.pattern}"`;case"propertyNames":return`property names ${error.params.propertyNames.join(", ")} are invalid`;case"required":return`must have required properties ${error.params.requiredProperties.join(", ")}`;case"type":return typeof error.params.type=="string"?`must be ${error.params.type}`:`must be either ${error.params.type.join(" or ")}`;case"unevaluatedItems":return"must not have unevaluated items";case"unevaluatedProperties":return"must not have unevaluated properties";case"uniqueItems":return"must not have duplicate items";case"~refine":return error.params.message;default:return"an unknown validation error occurred"}}var locale=en_US;function Get2(){return locale}var EncodeBuilder=class{constructor(type,decode){this.type=type,this.decode=decode}Encode(callback){let type=this.type,decode=IsCodec(type)?value=>this.decode(type["~codec"].decode(value)):this.decode,encode=IsCodec(type)?value=>type["~codec"].encode(callback(value)):callback,codec={decode,encode};return memory_exports.Update(this.type,{"~codec":codec},{})}},DecodeBuilder=class{constructor(type){this.type=type}Decode(callback){return new EncodeBuilder(this.type,callback)}};function Codec(type){return new DecodeBuilder(type)}function Decode(type,callback){return Codec(type).Decode(callback).Encode(()=>{throw Error("Encode not implemented")})}function Encode(type,callback){return Codec(type).Decode(()=>{throw Error("Decode not implemented")}).Encode(callback)}function IsCodec(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"~codec")&&guard_exports.IsObject(value["~codec"])&&guard_exports.HasPropertyKey(value["~codec"],"encode")&&guard_exports.HasPropertyKey(value["~codec"],"decode")}function Immutable(type){return AddImmutable(type)}function IsImmutable(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"~immutable")}function AddReadonlyDeferred(type,options={}){return Deferred("AddReadonly",[type],options)}function AddReadonly(type,options={}){return AddReadonlyAction(type,options)}function Readonly(type){return AddReadonly(type)}function IsReadonly(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"~readonly")}function RefineAdd(type,refinement){let refinements=IsRefine(type)?[...type["~refine"],refinement]:[refinement];return memory_exports.Update(type,{"~refine":refinements},{})}function Refine(...args){let[type,check,error]=arguments_exports.Match(args,{3:(type2,check2,error2)=>[type2,check2,error2],2:(type2,check2)=>[type2,check2,()=>"Refine Error"]});return RefineAdd(type,{check,error})}function IsRefinement(value){return guard_exports.IsObjectNotArray(value)&&guard_exports.HasPropertyKey(value,"check")&&guard_exports.HasPropertyKey(value,"error")&&guard_exports.IsFunction(value.check)&&guard_exports.IsFunction(value.error)}function IsRefine(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"~refine")&&guard_exports.IsArray(value["~refine"])&&guard_exports.Every(value["~refine"],0,value2=>IsRefinement(value2))}var BigIntPattern="-?(?:0|[1-9][0-9]*)n";function BigInt2(options){return memory_exports.Create({"~kind":"BigInt"},{type:"bigint"},options)}function IsBigInt3(value){return IsKind(value,"BigInt")}function Boolean2(options){return memory_exports.Create({"~kind":"Boolean"},{type:"boolean"},options)}function IsBoolean4(value){return IsKind(value,"Boolean")}function Identifier(name){return memory_exports.Create({"~kind":"Identifier"},{name})}function IsIdentifier2(value){return IsKind(value,"Identifier")}var IntegerPattern="-?(?:0|[1-9][0-9]*)";function Integer(options){return memory_exports.Create({"~kind":"Integer"},{type:"integer"},options)}function IsInteger3(value){return IsKind(value,"Integer")}var InvalidLiteralValue=class extends Error{constructor(value){super("Invalid Literal value"),Object.defineProperty(this,"cause",{value:{value},writable:!1,configurable:!1,enumerable:!1})}};function LiteralTypeName(value){return guard_exports.IsBigInt(value)?"bigint":guard_exports.IsBoolean(value)?"boolean":guard_exports.IsNumber(value)?"number":guard_exports.IsString(value)?"string":(()=>{throw new InvalidLiteralValue(value)})()}function Literal(value,options){return memory_exports.Create({"~kind":"Literal"},{type:LiteralTypeName(value),const:value},options)}function IsLiteralValue(value){return guard_exports.IsBigInt(value)||guard_exports.IsBoolean(value)||guard_exports.IsNumber(value)||guard_exports.IsString(value)}function IsLiteralBigInt(value){return IsLiteral(value)&&guard_exports.IsBigInt(value.const)}function IsLiteralBoolean(value){return IsLiteral(value)&&guard_exports.IsBoolean(value.const)}function IsLiteralNumber(value){return IsLiteral(value)&&guard_exports.IsNumber(value.const)}function IsLiteralString(value){return IsLiteral(value)&&guard_exports.IsString(value.const)}function IsLiteral(value){return IsKind(value,"Literal")}function Null(options){return memory_exports.Create({"~kind":"Null"},{type:"null"},options)}function IsNull3(value){return IsKind(value,"Null")}var NumberPattern="-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";function Number2(options){return memory_exports.Create({"~kind":"Number"},{type:"number"},options)}function IsNumber4(value){return IsKind(value,"Number")}function Symbol(options){return memory_exports.Create({"~kind":"Symbol"},{type:"symbol"},options)}function IsSymbol3(value){return IsKind(value,"Symbol")}function Parameter(...args){let[name,extends_,equals]=arguments_exports.Match(args,{3:(name2,extends_2,equals2)=>[name2,extends_2,equals2],2:(name2,extends_2)=>[name2,extends_2,extends_2],1:name2=>[name2,Unknown(),Unknown()]});return memory_exports.Create({"~kind":"Parameter"},{name,extends:extends_,equals},{})}function IsParameter(value){return IsKind(value,"Parameter")}var StringPattern=".*";function String2(options){return memory_exports.Create({"~kind":"String"},{type:"string"},options)}function IsString4(value){return IsKind(value,"String")}function Union(anyOf,options={}){return memory_exports.Create({"~kind":"Union"},{anyOf},options)}function IsUnion(value){return IsKind(value,"Union")}function UnionOptions(type){return memory_exports.Discard(type,["~kind","anyOf"])}function ParsePatternIntoTypes(pattern){let parsed=Pattern(pattern);return guard_exports.IsEqual(parsed.length,2)?parsed[0]:[]}function FromLiteral(_value){return!0}function FromTypesReduce(types){return guard_exports.ShiftLeft(types,(left,right)=>FromType(left)?FromTypesReduce(right):!1,()=>!0)}function FromTypes(types){return guard_exports.IsEqual(types.length,0)?!1:FromTypesReduce(types)}function FromType(type){return IsUnion(type)?FromTypes(type.anyOf):IsLiteral(type)?FromLiteral(type.const):!1}function IsTemplateLiteralFinite(types){return FromTypes(types)}function TemplateLiteralCreate(pattern){return memory_exports.Create({"~kind":"TemplateLiteral"},{type:"string",pattern},{})}function FromLiteralPush(variants,value,result=[]){return guard_exports.ShiftLeft(variants,(left,right)=>FromLiteralPush(right,value,[...result,`${left}${value}`]),()=>result)}function FromLiteral2(variants,value){return guard_exports.IsEqual(variants.length,0)?[`${value}`]:FromLiteralPush(variants,value)}function FromUnion(variants,types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>FromUnion(variants,right,[...result,...FromType2(variants,left)]),()=>result)}function FromType2(variants,type){return IsUnion(type)?FromUnion(variants,type.anyOf):IsLiteral(type)?FromLiteral2(variants,type.const):Unreachable()}function DecodeFromSpan(variants,types){return guard_exports.ShiftLeft(types,(left,right)=>DecodeFromSpan(FromType2(variants,left),right),()=>variants)}function VariantsToLiterals(variants){return variants.map(variant=>Literal(variant))}function DecodeTypesAsUnion(types){let variants=DecodeFromSpan([],types),literals=VariantsToLiterals(variants);return Union(literals)}function DecodeTypes(types){return guard_exports.IsEqual(types.length,0)?Unreachable():guard_exports.IsEqual(types.length,1)&&IsLiteral(types[0])?types[0]:DecodeTypesAsUnion(types)}function TemplateLiteralDecodeUnsafe(pattern){let types=ParsePatternIntoTypes(pattern);return guard_exports.IsEqual(types.length,0)?String2():IsTemplateLiteralFinite(types)?DecodeTypes(types):TemplateLiteralCreate(pattern)}function TemplateLiteralDecode(pattern){let decoded=TemplateLiteralDecodeUnsafe(pattern);return IsTemplateLiteral(decoded)?String2():decoded}function CreateRecord(key,value){let type="object",patternProperties={[key]:value};return memory_exports.Create({"~kind":"Record"},{type,patternProperties})}function FromAnyKey(value){return CreateRecord(StringKey,value)}function FromBooleanKey(value){return _Object_({true:value,false:value})}function Tuple(types,options={}){let[items,minItems,additionalItems]=[types,types.length,!1];return memory_exports.Create({"~kind":"Tuple"},{type:"array",additionalItems,items,minItems},options)}function IsTuple(value){return IsKind(value,"Tuple")}function TupleOptions(type){return memory_exports.Discard(type,["~kind","type","items","minItems","additionalItems"])}function RemoveReadonlyOperation(type){return memory_exports.Discard(type,["~readonly"])}function RemoveReadonlyAction(type,options){return memory_exports.Update(RemoveReadonlyOperation(type),{},options)}function RemoveReadonlyInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return RemoveReadonlyAction(instantiatedType,options)}function RemoveReadonlyDeferred(type,options={}){return Deferred("RemoveReadonly",[type],options)}function RemoveReadonly(type,options={}){return RemoveReadonlyAction(type,options)}function RemoveOptionalOperation(type){return memory_exports.Discard(type,["~optional"])}function RemoveOptionalAction(type,options){return memory_exports.Update(RemoveOptionalOperation(type),{},options)}function RemoveOptionalInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return RemoveOptionalAction(instantiatedType,options)}function RemoveOptionalDeferred(type,options={}){return Deferred("RemoveOptional",[type],options)}function RemoveOptional(type,options={}){return RemoveOptionalAction(type,options)}function TupleElementsToProperties(types){return types.reduceRight((result2,right,index)=>({[index]:right,...result2}),{})}function TupleToObject(type){let properties=TupleElementsToProperties(type.items);return _Object_(properties)}function CanComposite(type){return IsObject3(type)||IsTuple(type)}function IsReadonlyProperty(left,right){return IsReadonly(left)?!!IsReadonly(right):!1}function IsOptionalProperty(left,right){return IsOptional(left)?!!IsOptional(right):!1}function CompositeProperty(left,right){let isReadonly=IsReadonlyProperty(left,right),isOptional=IsOptionalProperty(left,right),evaluated=EvaluateIntersect([left,right]),property=RemoveReadonly(RemoveOptional(evaluated));return isReadonly&&isOptional?AddReadonly(AddOptional(property)):isReadonly&&!isOptional?AddReadonly(property):!isReadonly&&isOptional?AddOptional(property):property}function CompositePropertyKey(left,right,key){return key in left?key in right?CompositeProperty(left[key],right[key]):left[key]:key in right?right[key]:Never()}function CompositeProperties(left,right){return[...new Set([...guard_exports.Keys(left),...guard_exports.Keys(right)])].reduce((result2,key)=>({...result2,[key]:CompositePropertyKey(left,right,key)}),{})}function GetProperties(type){return IsObject3(type)?type.properties:IsTuple(type)?TupleElementsToProperties(type.items):{}}function Composite(left,right){let leftProperties=GetProperties(left),rightProperties=GetProperties(right),properties=CompositeProperties(leftProperties,rightProperties);return _Object_(properties)}function NarrowCompareRule(left,right){let result=Compare(left,right);return guard_exports.IsEqual(result,CompareResultLeftInside)?left:guard_exports.IsEqual(result,CompareResultRightInside)||guard_exports.IsEqual(result,CompareResultEqual)?right:Never()}function NarrowCompositeRule(left,right){let canCompositeLeft=CanComposite(left),canCompositeRight=CanComposite(right);return canCompositeLeft&&canCompositeRight?Composite(left,right):canCompositeLeft&&!canCompositeRight?left:!canCompositeLeft&&canCompositeRight?right:NarrowCompareRule(left,right)}function Narrow(left,right){return IsNever(left)||IsAny(left)?left:IsUnknown(left)||IsNever(right)||IsAny(right)?right:IsUnknown(right)?left:NarrowCompositeRule(left,right)}function ShouldEvaluate(left,right){return IsUnion(left)||IsUnion(right)}function DistributeOperation(left,right){let evaluatedLeft=EvaluateType(left),evaluatedRight=EvaluateType(right);return ShouldEvaluate(evaluatedLeft,evaluatedRight)?EvaluateIntersect([evaluatedLeft,evaluatedRight]):Narrow(evaluatedLeft,evaluatedRight)}function DistributeType(type,types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>DistributeType(type,right,[...result,DistributeOperation(left,type)]),()=>guard_exports.IsEqual(result.length,0)?[type]:result)}function DistributeUnion(types,distribution,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>DistributeUnion(right,distribution,[...result,...Distribute([left],distribution)]),()=>result)}function Distribute(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>IsUnion(left)?Distribute(right,DistributeUnion(left.anyOf,result)):Distribute(right,DistributeType(left,result)),()=>result)}function ExcludeType(left,right){let check=Extends({},left,right);return result_exports.IsExtendsTrueLike(check)?[]:[left]}function ExcludeUnion(left,right,result=[]){return guard_exports.ShiftLeft(left,(head,tail)=>ExcludeUnion(tail,right,[...result,...ExcludeType(head,right)]),()=>result)}function ExcludeOperation(left,right){let evaluated=EvaluateType(left),canonical=IsUnion(evaluated)?evaluated.anyOf:[evaluated],remaining=ExcludeUnion(canonical,right);return EvaluateUnion(remaining)}function EvaluateDependent(if_,then_,else_){let intersected=EvaluateIntersect([if_,then_]),excluded=ExcludeOperation(else_,if_);return EvaluateUnion([intersected,excluded])}function EvaluateEnum(values,result=[]){return guard_exports.ShiftLeft(values,(left,right)=>EvaluateEnum(right,[...result,Literal(left)]),()=>EvaluateUnion(result))}function EvaluateIntersect(types){let distribution=Distribute(types),broadend=Broaden(distribution);return EvaluateUnion(broadend)}function EvaluateTemplateLiteral(pattern){let evaluated=TemplateLiteralDecode(pattern);return EvaluateType(evaluated)}function EvaluateUnion(types){let broadend=Broaden(types);return EvaluateUnionFast(broadend)}function EvaluateType(type){return IsDependent(type)?EvaluateDependent(type.if,type.then,type.else):IsEnum(type)?EvaluateEnum(type.enum):IsIntersect(type)?EvaluateIntersect(type.allOf):IsTemplateLiteral(type)?EvaluateTemplateLiteral(type.pattern):IsUnion(type)?EvaluateUnion(type.anyOf):type}function EvaluateUnionFast(types){return guard_exports.IsEqual(types.length,1)?types[0]:guard_exports.IsEqual(types.length,0)?Never():Union(types)}function FromEnumKey(values,value){let unionKey=EvaluateEnum(values);return FromKey(unionKey,value)}function FromIntegerKey(_key,value){return CreateRecord(IntegerKey,value)}function FromIntersectKey(types,value){let evaluatedKey=EvaluateIntersect(types);return FromKey(evaluatedKey,value)}function FromLiteralKey(key,value){return guard_exports.IsString(key)||guard_exports.IsNumber(key)?_Object_({[key]:value}):guard_exports.IsEqual(key,!1)?_Object_({false:value}):guard_exports.IsEqual(key,!0)?_Object_({true:value}):_Object_({})}function FromNumberKey(_key,value){return CreateRecord(NumberKey,value)}function FromStringKey(key,value){return guard_exports.HasPropertyKey(key,"pattern")&&(guard_exports.IsString(key.pattern)||key.pattern instanceof RegExp)?CreateRecord(key.pattern.toString(),value):CreateRecord(StringKey,value)}function FromTemplateKey(pattern,value){let types=ParsePatternIntoTypes(pattern);return IsTemplateLiteralFinite(types)?FromKey(EvaluateTemplateLiteral(pattern),value):CreateRecord(pattern,value)}function FlattenType(type){return IsUnion(type)?Flatten(type.anyOf):[type]}function Flatten(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>Flatten(right,[...result,...FlattenType(left)]),()=>result)}function StringOrNumberCheck(types){return types.some(type=>IsString4(type)||IsNumber4(type)||IsInteger3(type))}function TryBuildRecord(types,value){return guard_exports.IsEqual(StringOrNumberCheck(types),!0)?CreateRecord(StringKey,value):void 0}function CreateProperties(types,value){return types.reduce((result,left)=>IsLiteral(left)&&(guard_exports.IsString(left.const)||guard_exports.IsNumber(left.const))?{...result,[left.const]:value}:result,{})}function CreateObject(types,value){let properties=CreateProperties(types,value);return _Object_(properties)}function FromUnionKey(types,value){let flattened=Flatten(types),record=TryBuildRecord(flattened,value);return IsSchema(record)?record:CreateObject(flattened,value)}function FromKey(key,value){return IsAny(key)?FromAnyKey(value):IsBoolean4(key)?FromBooleanKey(value):IsEnum(key)?FromEnumKey(key.enum,value):IsInteger3(key)?FromIntegerKey(key,value):IsIntersect(key)?FromIntersectKey(key.allOf,value):IsLiteral(key)?FromLiteralKey(key.const,value):IsNumber4(key)?FromNumberKey(key,value):IsUnion(key)?FromUnionKey(key.anyOf,value):IsString4(key)?FromStringKey(key,value):IsTemplateLiteral(key)?FromTemplateKey(key.pattern,value):_Object_({})}function RecordAction(key,value,options){return CanInstantiate([key])?memory_exports.Update(FromKey(key,value),{},options):RecordDeferred(key,value,options)}function RecordInstantiate(context,state,key,value,options){let instantiatedKey=InstantiateType(context,state,key),instantiatedValue=InstantiateType(context,state,value);return RecordAction(instantiatedKey,instantiatedValue,options)}var IntegerKey=`^${IntegerPattern}$`,NumberKey=`^${NumberPattern}$`,StringKey=`^${StringPattern}$`;function RecordDeferred(key,value,options={}){return Deferred("Record",[key,value],options)}function Record(key,value,options={}){return RecordAction(key,value,options)}function RecordFromPattern(pattern,value){return CreateRecord(pattern,value)}function RecordPatternToType(pattern){return guard_exports.IsEqual(pattern,StringKey)?String2():guard_exports.IsEqual(pattern,IntegerKey)?Integer():guard_exports.IsEqual(pattern,NumberKey)?Number2():TemplateLiteralDecodeUnsafe(pattern)}function RecordPattern(type){return guard_exports.Keys(type.patternProperties)[0]}function RecordKey(type){let pattern=RecordPattern(type);return RecordPatternToType(pattern)}function RecordValue(type){return type.patternProperties[RecordPattern(type)]}function IsRecord(value){return IsKind(value,"Record")}function RecordOptions(type){return memory_exports.Discard(type,["~kind","type","patternProperties"])}function Rest(type){return memory_exports.Create({"~kind":"Rest"},{type:"rest",items:type},{})}function IsRest(value){return IsKind(value,"Rest")}function This(options){return memory_exports.Create({"~kind":"This"},{$ref:"#"},options)}function IsThis(value){return IsKind(value,"This")}function Undefined(options){return memory_exports.Create({"~kind":"Undefined"},{type:"undefined"},options)}function IsUndefined3(value){return IsKind(value,"Undefined")}function Void(options){return memory_exports.Create({"~kind":"Void"},{type:"void"},options)}function IsVoid(value){return IsKind(value,"Void")}function IntrinsicOrCall(ref,parameters){return guard_exports.IsEqual(ref,"Array")?_Array_(parameters[0]):guard_exports.IsEqual(ref,"Capitalize")?CapitalizeDeferred(parameters[0]):guard_exports.IsEqual(ref,"ConstructorParameters")?ConstructorParametersDeferred(parameters[0]):guard_exports.IsEqual(ref,"Evaluate")?EvaluateDeferred(parameters[0]):guard_exports.IsEqual(ref,"Exclude")?ExcludeDeferred(parameters[0],parameters[1]):guard_exports.IsEqual(ref,"Extract")?ExtractDeferred(parameters[0],parameters[1]):guard_exports.IsEqual(ref,"Index")?IndexDeferred(parameters[0],parameters[1]):guard_exports.IsEqual(ref,"InstanceType")?InstanceTypeDeferred(parameters[0]):guard_exports.IsEqual(ref,"Lowercase")?LowercaseDeferred(parameters[0]):guard_exports.IsEqual(ref,"NonNullable")?NonNullableDeferred(parameters[0]):guard_exports.IsEqual(ref,"Omit")?OmitDeferred(parameters[0],parameters[1]):guard_exports.IsEqual(ref,"Parameters")?ParametersDeferred(parameters[0]):guard_exports.IsEqual(ref,"Partial")?PartialDeferred(parameters[0]):guard_exports.IsEqual(ref,"Pick")?PickDeferred(parameters[0],parameters[1]):guard_exports.IsEqual(ref,"Readonly")?ReadonlyObjectDeferred(parameters[0]):guard_exports.IsEqual(ref,"KeyOf")?KeyOfDeferred(parameters[0]):guard_exports.IsEqual(ref,"Record")?RecordDeferred(parameters[0],parameters[1]):guard_exports.IsEqual(ref,"Required")?RequiredDeferred(parameters[0]):guard_exports.IsEqual(ref,"ReturnType")?ReturnTypeDeferred(parameters[0]):guard_exports.IsEqual(ref,"Uncapitalize")?UncapitalizeDeferred(parameters[0]):guard_exports.IsEqual(ref,"Uppercase")?UppercaseDeferred(parameters[0]):CallConstruct(Ref(ref),parameters)}function Unreachable2(){throw Error("Unreachable")}function DelimitedDecode(input,result=[]){return guard_exports.ShiftLeft(input,(left,right)=>DelimitedDecode(right,[...result,left[1]]),()=>result)}function Delimited(input){return guard_exports.IsEqual(input.length,3)?[input[0],...DelimitedDecode(input[1])]:[]}function GenericParameterExtendsEqualsMapping(input){return Parameter(input[0],input[2],input[4])}function GenericParameterExtendsMapping(input){return Parameter(input[0],input[2],input[2])}function GenericParameterEqualsMapping(input){return Parameter(input[0],Unknown(),input[2])}function GenericParameterIdentifierMapping(input){return Parameter(input,Unknown(),Unknown())}function GenericParameterListMapping(input){return Delimited(input)}function GenericParametersMapping(input){return input[1]}function GenericCallArgumentListMapping(input){return Delimited(input)}function GenericCallArgumentsMapping(input){return input[1]}function GenericCallMapping(input){return IntrinsicOrCall(input[0],input[1])}function OptionalSemiColonMapping(input){return null}function KeywordStringMapping(input){return String2()}function KeywordNumberMapping(input){return Number2()}function KeywordBooleanMapping(input){return Boolean2()}function KeywordUndefinedMapping(input){return Undefined()}function KeywordNullMapping(input){return Null()}function KeywordIntegerMapping(input){return Integer()}function KeywordBigIntMapping(input){return BigInt2()}function KeywordUnknownMapping(input){return Unknown()}function KeywordAnyMapping(input){return Any()}function KeywordObjectMapping(input){return _Object_({})}function KeywordNeverMapping(input){return Never()}function KeywordSymbolMapping(input){return Symbol()}function KeywordVoidMapping(input){return Void()}function KeywordThisMapping(input){return This()}function LiteralBigIntMapping(input){return Literal(BigInt(input))}function LiteralBooleanMapping(input){return Literal(guard_exports.IsEqual(input,"true"))}function LiteralNumberMapping(input){return Literal(parseFloat(input))}function LiteralStringMapping(input){return Literal(input)}function TemplateInterpolateMapping(input){return input[1]}function TemplateSpanMapping(input){return Literal(input)}function TemplateBodyMapping(input){return guard_exports.IsEqual(input.length,3)?[input[0],input[1],...input[2]]:[input[0]]}function TemplateLiteralTypesMapping(input){return input[1]}function TemplateLiteralMapping(input){return TemplateLiteralDeferred(input)}function DependentMapping(input){return guard_exports.IsEqual(input.length,6)?Dependent(input[1],input[3],input[5]):Dependent(input[1],input[3],Unknown())}function KeyOfMapping(input){return input.length>0}function IndexArrayMapping(input){return input.reduce((result,current)=>guard_exports.IsEqual(current.length,3)?[...result,[current[1]]]:[...result,[]],[])}function ExtendsMapping(input){return guard_exports.IsEqual(input.length,6)?[input[1],input[3],input[5]]:[]}function BaseMapping(input){return guard_exports.IsArray(input)&&guard_exports.IsEqual(input.length,3)?input[1]:input}function WithMapping(input){return guard_exports.IsEqual(input.length,2)?input[1]:[]}function FactorIndexArray(Type2,indexArray){return indexArray.reduce((result,left)=>{let _left=left;return guard_exports.IsEqual(_left.length,1)?IndexDeferred(result,_left[0]):guard_exports.IsEqual(_left.length,0)?_Array_(result):Unreachable2()},Type2)}function FactorExtends(type,extend){return guard_exports.IsEqual(extend.length,3)?ConditionalDeferred(type,extend[0],extend[1],extend[2]):type}function FactorWith(type,withClause){return guard_exports.IsArray(withClause)&&guard_exports.IsEqual(withClause.length,0)?type:WithDeferred(type,withClause)}function FactorMapping(input){let[keyOf,type,indexArray,extend,withClause]=input;return FactorWith(FactorExtends(keyOf?KeyOfDeferred(FactorIndexArray(type,indexArray)):FactorIndexArray(type,indexArray),extend),withClause)}function ExprBinaryMapping(left,rest){return guard_exports.IsEqual(rest.length,3)?(()=>{let[operator,right,next]=rest,Schema=ExprBinaryMapping(right,next);if(guard_exports.IsEqual(operator,"&"))return IsIntersect(Schema)?Intersect([left,...Schema.allOf]):Intersect([left,Schema]);if(guard_exports.IsEqual(operator,"|"))return IsUnion(Schema)?Union([left,...Schema.anyOf]):Union([left,Schema]);Unreachable2()})():left}function ExprTermMapping(input){let[left,rest]=input;return ExprBinaryMapping(left,rest)}function ExprMapping(input){let[left,rest]=input;return ExprBinaryMapping(left,rest)}function ExprReadonlyMapping(input){return AddImmutableDeferred(input[1])}function ExprPipeMapping(input){return input[1]}function GenericTypeMapping(input){return Generic(input[0],input[2])}function InferTypeMapping(input){return guard_exports.IsEqual(input.length,4)?Infer(input[1],input[3]):guard_exports.IsEqual(input.length,2)?Infer(input[1],Unknown()):Unreachable2()}function PropertyKeyNumberMapping(input){return`${input}`}function PropertyKeyIndexMapping(input){return IsInteger3(input[3])?IntegerKey:IsNumber4(input[3])?NumberKey:IsSymbol3(input[3])?StringKey:IsString4(input[3])?StringKey:Unreachable2()}function ReadonlyMapping(input){return input.length>0}function OptionalMapping(input){return input.length>0}function PropertyMapping(input){let[isReadonly,key,isOptional,_colon,type]=input;return{[key]:isReadonly&&isOptional?AddReadonlyDeferred(AddOptionalDeferred(type)):isReadonly&&!isOptional?AddReadonlyDeferred(type):!isReadonly&&isOptional?AddOptionalDeferred(type):type}}function PropertyListMapping(input){return Delimited(input)}function PropertiesReduce(propertyList){return propertyList.reduce((result,left)=>guard_exports.HasPropertyKey(left,IntegerKey)||guard_exports.HasPropertyKey(left,NumberKey)||guard_exports.HasPropertyKey(left,StringKey)?[result[0],memory_exports.Assign(result[1],left)]:[memory_exports.Assign(result[0],left),result[1]],[{},{}])}function PropertiesMapping(input){return PropertiesReduce(input[1])}function _Object_Mapping(input){let[properties,patternProperties]=input,options=guard_exports.IsEqual(guard_exports.Keys(patternProperties).length,0)?{}:{patternProperties};return _Object_(properties,options)}function ElementNamedMapping(input){return guard_exports.IsEqual(input.length,5)?AddReadonlyDeferred(AddOptionalDeferred(input[4])):guard_exports.IsEqual(input.length,3)?input[2]:guard_exports.IsEqual(input.length,4)?guard_exports.IsEqual(input[2],"readonly")?AddReadonlyDeferred(input[3]):AddOptionalDeferred(input[3]):Unreachable2()}function ElementBaseMapping(input){if(!guard_exports.IsArray(input)||!guard_exports.IsEqual(input.length,3))return input;let[isReadonly,type,isOptional]=input;return isReadonly&&isOptional?AddReadonlyDeferred(AddOptionalDeferred(type)):isReadonly&&!isOptional?AddReadonlyDeferred(type):!isReadonly&&isOptional?AddOptionalDeferred(type):type}function ElementMapping(input){return guard_exports.IsEqual(input.length,2)?Rest(input[1]):guard_exports.IsEqual(input.length,1)?input[0]:Unreachable2()}function ElementListMapping(input){return Delimited(input)}function _Tuple_Mapping(input){return Tuple(input[1])}function ParameterReadonlyOptionalMapping(input){return AddReadonlyDeferred(AddOptionalDeferred(input[4]))}function ParameterReadonlyMapping(input){return AddReadonlyDeferred(input[3])}function ParameterOptionalMapping(input){return AddOptionalDeferred(input[3])}function ParameterTypeMapping(input){return input[2]}function ParameterMapping(input){return guard_exports.IsEqual(input.length,2)?Rest(input[1]):guard_exports.IsEqual(input.length,1)?input[0]:Unreachable2()}function ParameterListMapping(input){return Delimited(input)}function _Function_Mapping(input){return _Function_(input[1],input[4])}function _Constructor_Mapping(input){return Constructor(input[2],input[5])}function ApplyReadonly(state,type){return guard_exports.IsEqual(state,"remove")?RemoveReadonlyDeferred(type):guard_exports.IsEqual(state,"add")?AddReadonlyDeferred(type):type}function MappedReadonlyMapping(input){return guard_exports.IsEqual(input.length,2)&&guard_exports.IsEqual(input[0],"-")?"remove":guard_exports.IsEqual(input.length,2)&&guard_exports.IsEqual(input[0],"+")||guard_exports.IsEqual(input.length,1)?"add":"none"}function ApplyOptional(state,type){return guard_exports.IsEqual(state,"remove")?RemoveOptionalDeferred(type):guard_exports.IsEqual(state,"add")?AddOptionalDeferred(type):type}function MappedOptionalMapping(input){return guard_exports.IsEqual(input.length,2)&&guard_exports.IsEqual(input[0],"-")?"remove":guard_exports.IsEqual(input.length,2)&&guard_exports.IsEqual(input[0],"+")||guard_exports.IsEqual(input.length,1)?"add":"none"}function MappedAsMapping(input){return guard_exports.IsEqual(input.length,2)?[input[1]]:[]}function _Mapped_Mapping(input){return guard_exports.IsArray(input[6])&&guard_exports.IsEqual(input[6].length,1)?MappedDeferred(Identifier(input[3]),input[5],input[6][0],ApplyReadonly(input[1],ApplyOptional(input[8],input[10]))):MappedDeferred(Identifier(input[3]),input[5],Ref(input[3]),ApplyReadonly(input[1],ApplyOptional(input[8],input[10])))}function ReferenceMapping(input){return Ref(input)}function WithBigIntMapping(input){return BigInt(input)}function WithNumberMapping(input){return parseFloat(input)}function WithBooleanMapping(input){return guard_exports.IsEqual(input,"true")}function WithNullMapping(input){return null}function WithPropertyMapping(input){return{[input[0]]:input[2]}}function WithPropertyListMapping(input){return Delimited(input)}function WithObjectMappingReduce(propertyList){return propertyList.reduce((result,left)=>memory_exports.Assign(result,left),{})}function WithObjectMapping(input){return WithObjectMappingReduce(input[1])}function WithElementListMapping(input){return Delimited(input)}function WithArrayMapping(input){return input[1]}function PatternBigIntMapping(input){return BigInt2()}function PatternStringMapping(input){return String2()}function PatternNumberMapping(input){return Number2()}function PatternIntegerMapping(input){return Integer()}function PatternNeverMapping(input){return Never()}function PatternTextMapping(input){return Literal(input)}function PatternGroupMapping(input){return Union(input[1])}function PatternUnionMapping(input){return input.length===3?[...input[0],...input[2]]:input.length===1?[...input[0]]:[]}function PatternTermMapping(input){return[input[0],...input[1]]}function PatternMapping(input){return input[1]}function InterfaceDeclarationHeritageListMapping(input){return Delimited(input)}function InterfaceDeclarationHeritageMapping(input){return guard_exports.IsEqual(input.length,2)?input[1]:[]}function InterfaceDeclarationGenericMapping(input){let parameters=input[2],heritage=input[3],[properties,patternProperties]=input[4],options=guard_exports.IsEqual(guard_exports.Keys(patternProperties).length,0)?{}:{patternProperties};return{[input[1]]:Generic(parameters,InterfaceDeferred(heritage,properties,options))}}function InterfaceDeclarationMapping(input){let heritage=input[2],[properties,patternProperties]=input[3],options=guard_exports.IsEqual(guard_exports.Keys(patternProperties).length,0)?{}:{patternProperties};return{[input[1]]:InterfaceDeferred(heritage,properties,options)}}function TypeAliasDeclarationGenericMapping(input){return{[input[1]]:Generic(input[2],input[4])}}function TypeAliasDeclarationMapping(input){return{[input[1]]:input[3]}}function ExportKeywordMapping(input){return null}function ModuleDeclarationListMapping(input){return Delimited(input)}function ModuleDeclarationMapping(input){return input[1]}function ModuleMapping(input){let[moduleDeclaration,moduleDeclarationList]=[input[0],input[1]];return ModuleDeferred(memory_exports.Assign(moduleDeclaration,PropertiesReduce(moduleDeclarationList)[0]))}function IsMatch(value){return IsEqual(value.length,2)}function Match2(input,ok,fail){return IsMatch(input)?ok(input[0],input[1]):fail()}function TakeVariant(variant,input){return IsEqual(input.indexOf(variant),0)?[variant,input.slice(variant.length)]:[]}function Take(variants,input){for(let i=0;i<variants.length;i++){let result=TakeVariant(variants[i],input);if(IsMatch(result))return result}return[]}function Range(start,end){return Array.from({length:end-start+1},(_,i)=>String.fromCharCode(start+i))}var Alpha=[...Range(97,122),...Range(65,90)],Zero="0",NonZero=Range(49,57),Digit=[Zero,...NonZero],WhiteSpace=" ",NewLine=`
`;var UnderScore="_",Dot=".",DollarSign="$",Hyphen="-";var LineComment="//",OpenComment="/*",CloseComment="*/";function DiscardMultilineComment(input){let index=input.indexOf(CloseComment);return IsEqual(index,-1)?"":input.slice(index+2)}function DiscardLineComment(input){let index=input.indexOf(NewLine);return IsEqual(index,-1)?"":input.slice(index)}function TrimStartUntilNewline(input){return input.replace(/^[ \t\r\f\v]+/,"")}function TrimWhitespace(input){let trimmed=TrimStartUntilNewline(input);return trimmed.startsWith(OpenComment)?TrimWhitespace(DiscardMultilineComment(trimmed.slice(2))):trimmed.startsWith(LineComment)?TrimWhitespace(DiscardLineComment(trimmed.slice(2))):trimmed}function Trim(input){let trimmed=input.trimStart();return trimmed.startsWith(OpenComment)?Trim(DiscardMultilineComment(trimmed.slice(2))):trimmed.startsWith(LineComment)?Trim(DiscardLineComment(trimmed.slice(2))):trimmed}function Optional2(value,input){return Match2(Take([value],input),(Optional4,Rest2)=>[Optional4,Rest2],()=>["",input])}function IsDiscard(discard,input){return discard.includes(input)}function Many(allowed,discard,input,result=""){return Match2(Take(allowed,input),(Char,Rest2)=>IsDiscard(discard,Char)?Many(allowed,discard,Rest2,result):Many(allowed,discard,Rest2,`${result}${Char}`),()=>[result,input])}function TakeNonZero(input){return Take(NonZero,input)}var AllowedDigits=[...Digit,UnderScore];function TakeDigits(input){return Many(AllowedDigits,[UnderScore],input)}function TakeUnsignedInteger(input){return Match2(Take([Zero],input),(Zero2,ZeroRest)=>[Zero2,ZeroRest],()=>Match2(TakeNonZero(input),(NonZero2,NonZeroRest)=>Match2(TakeDigits(NonZeroRest),(Digits,DigitsRest)=>[`${NonZero2}${Digits}`,DigitsRest],()=>[]),()=>[]))}function UnsignedInteger(input){return TakeUnsignedInteger(Trim(input))}function TakeSign(input){return Optional2(Hyphen,input)}function TakeSignedInteger(input){return Match2(TakeSign(input),(Sign,SignRest)=>Match2(UnsignedInteger(SignRest),(UnsignedInteger2,UnsignedIntegerRest)=>[`${Sign}${UnsignedInteger2}`,UnsignedIntegerRest],()=>[]),()=>[])}function Integer2(input){return TakeSignedInteger(Trim(input))}function TakeBigInt(input){return Match2(Integer2(input),(Integer3,IntegerRest)=>Match2(Take(["n"],IntegerRest),(_N,NRest)=>[`${Integer3}`,NRest],()=>[]),()=>[])}function BigInt3(input){return TakeBigInt(input)}function TakeConst(const_,input){return Take([const_],input)}function Const(const_,input){return IsEqual(const_,"")?["",input]:const_.startsWith(NewLine)?TakeConst(const_,TrimWhitespace(input)):const_.startsWith(WhiteSpace)?TakeConst(const_,input):TakeConst(const_,Trim(input))}var Initial=[...Alpha,UnderScore,DollarSign];function TakeInitial(input){return Take(Initial,input)}var Remaining=[...Initial,...Digit];function TakeRemaining(input,result=""){return Match2(Take(Remaining,input),(Remaining2,RemainingRest)=>TakeRemaining(RemainingRest,`${result}${Remaining2}`),()=>[result,input])}function TakeIdent(input){return Match2(TakeInitial(input),(Initial2,InitialRest)=>Match2(TakeRemaining(InitialRest),(Remaining2,RemainingRest)=>[`${Initial2}${Remaining2}`,RemainingRest],()=>[]),()=>[])}function Ident(input){return TakeIdent(Trim(input))}var AllowedDigits2=[...Digit,UnderScore];function IsLeadingDot(input){return IsMatch(Take([Dot],input))}function TakeFractional(input){return Match2(Many(AllowedDigits2,[UnderScore],input),(Digits,DigitsRest)=>IsEqual(Digits,"")?[]:[Digits,DigitsRest],()=>[])}function LeadingDot(input){return Match2(Take([Dot],input),(Dot2,DotRest)=>Match2(TakeFractional(DotRest),(Fractional,FractionalRest)=>[`0${Dot2}${Fractional}`,FractionalRest],()=>[]),()=>[])}function LeadingInteger(input){return Match2(UnsignedInteger(input),(Integer3,IntegerRest)=>Match2(Take([Dot],IntegerRest),(Dot2,DotRest)=>Match2(TakeFractional(DotRest),(Fractional,FractionalRest)=>[`${Integer3}${Dot2}${Fractional}`,FractionalRest],()=>[`${Integer3}`,DotRest]),()=>[`${Integer3}`,IntegerRest]),()=>[])}function TakeUnsignedNumber(input){return IsLeadingDot(input)?LeadingDot(input):LeadingInteger(input)}function UnsignedNumber(input){return TakeUnsignedNumber(Trim(input))}function TakeSign2(input){return Optional2(Hyphen,input)}function TakeSignedNumber(input){return Match2(TakeSign2(input),(Sign,SignRest)=>Match2(UnsignedNumber(SignRest),(UnsignedInteger2,UnsignedIntegerRest)=>[`${Sign}${UnsignedInteger2}`,UnsignedIntegerRest],()=>[]),()=>[])}function Number3(input){return TakeSignedNumber(Trim(input))}function TakeOne(input){return IsEqual(input,"")?[]:[input.slice(0,1),input.slice(1)]}function IsInputMatchSentinal(end,input){return ShiftLeft(end,(left,right)=>input.startsWith(left)?!0:IsInputMatchSentinal(right,input),()=>!1)}function Until(end,input,result=""){return Match2(TakeOne(input),(One,Rest2)=>IsInputMatchSentinal(end,input)?[result,input]:Until(end,Rest2,`${result}${One}`),()=>[])}function MultiLine(start,end,input){return Match2(Take([start],input),(_,Rest2)=>Match2(Until([end],Rest2),(Until2,UntilRest)=>Match2(Take([end],UntilRest),(_2,Rest3)=>[`${Until2}`,Rest3],()=>[]),()=>[]),()=>[])}function SingleLine(start,end,input){return Match2(Take([start],input),(_,Rest2)=>Match2(Until([NewLine,end],Rest2),(Until2,UntilRest)=>Match2(Take([end],UntilRest),(_2,EndRest)=>[`${Until2}`,EndRest],()=>[]),()=>[]),()=>[])}function Span(start,end,multiLine,input){return multiLine?MultiLine(start,end,Trim(input)):SingleLine(start,end,Trim(input))}function TakeInitial2(quotes,input){return Take(quotes,input)}function TakeSpan(quote,input){return Span(quote,quote,!1,input)}function TakeString(quotes,input){return Match2(TakeInitial2(quotes,input),(Initial2,InitialRest)=>TakeSpan(Initial2,`${Initial2}${InitialRest}`),()=>[])}function String3(quotes,input){return TakeString(quotes,Trim(input))}function Until_1(end,input){return Match2(Until(end,input),(Until2,UntilRest)=>IsEqual(Until2,"")?[]:[Until2,UntilRest],()=>[])}var If2=(result,left,right=()=>[])=>result.length===2?left(result):right(),GenericParameterExtendsEquals=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("extends",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>If2(Const("=",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[GenericParameterExtendsEqualsMapping(_0),input2]),GenericParameterExtends=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("extends",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[GenericParameterExtendsMapping(_0),input2]),GenericParameterEquals=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("=",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[GenericParameterEqualsMapping(_0),input2]),GenericParameterIdentifier=input=>If2(Ident(input),([_0,input2])=>[GenericParameterIdentifierMapping(_0),input2]),GenericParameter=input=>If2(If2(GenericParameterExtendsEquals(input),([_0,input2])=>[_0,input2],()=>If2(GenericParameterExtends(input),([_0,input2])=>[_0,input2],()=>If2(GenericParameterEquals(input),([_0,input2])=>[_0,input2],()=>If2(GenericParameterIdentifier(input),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[_0,input2]),GenericParameterList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(GenericParameter(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>GenericParameterList_0(input2,[...result,_0]),()=>[result,input]),GenericParameterList=input=>If2(If2(If2(GenericParameter(input),([_0,input2])=>If2(GenericParameterList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[GenericParameterListMapping(_0),input2]),GenericParameters=input=>If2(If2(Const("<",input),([_0,input2])=>If2(GenericParameterList(input2),([_1,input3])=>If2(Const(">",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[GenericParametersMapping(_0),input2]),GenericCallArgumentList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>GenericCallArgumentList_0(input2,[...result,_0]),()=>[result,input]),GenericCallArgumentList=input=>If2(If2(If2(Type(input),([_0,input2])=>If2(GenericCallArgumentList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[GenericCallArgumentListMapping(_0),input2]),GenericCallArguments=input=>If2(If2(Const("<",input),([_0,input2])=>If2(GenericCallArgumentList(input2),([_1,input3])=>If2(Const(">",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[GenericCallArgumentsMapping(_0),input2]),GenericCall=input=>If2(If2(Ident(input),([_0,input2])=>If2(GenericCallArguments(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[GenericCallMapping(_0),input2]),OptionalSemiColon=input=>If2(If2(If2(Const(";",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[OptionalSemiColonMapping(_0),input2]),KeywordString=input=>If2(Const("string",input),([_0,input2])=>[KeywordStringMapping(_0),input2]),KeywordNumber=input=>If2(Const("number",input),([_0,input2])=>[KeywordNumberMapping(_0),input2]),KeywordBoolean=input=>If2(Const("boolean",input),([_0,input2])=>[KeywordBooleanMapping(_0),input2]),KeywordUndefined=input=>If2(Const("undefined",input),([_0,input2])=>[KeywordUndefinedMapping(_0),input2]),KeywordNull=input=>If2(Const("null",input),([_0,input2])=>[KeywordNullMapping(_0),input2]),KeywordInteger=input=>If2(Const("integer",input),([_0,input2])=>[KeywordIntegerMapping(_0),input2]),KeywordBigInt=input=>If2(Const("bigint",input),([_0,input2])=>[KeywordBigIntMapping(_0),input2]),KeywordUnknown=input=>If2(Const("unknown",input),([_0,input2])=>[KeywordUnknownMapping(_0),input2]),KeywordAny=input=>If2(Const("any",input),([_0,input2])=>[KeywordAnyMapping(_0),input2]),KeywordObject=input=>If2(Const("object",input),([_0,input2])=>[KeywordObjectMapping(_0),input2]),KeywordNever=input=>If2(Const("never",input),([_0,input2])=>[KeywordNeverMapping(_0),input2]),KeywordSymbol=input=>If2(Const("symbol",input),([_0,input2])=>[KeywordSymbolMapping(_0),input2]),KeywordVoid=input=>If2(Const("void",input),([_0,input2])=>[KeywordVoidMapping(_0),input2]),KeywordThis=input=>If2(Const("this",input),([_0,input2])=>[KeywordThisMapping(_0),input2]),TemplateInterpolate=input=>If2(If2(Const("${",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Const("}",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[TemplateInterpolateMapping(_0),input2]),TemplateSpan=input=>If2(Until(["${","`"],input),([_0,input2])=>[TemplateSpanMapping(_0),input2]),TemplateBody=input=>If2(If2(If2(TemplateSpan(input),([_0,input2])=>If2(TemplateInterpolate(input2),([_1,input3])=>If2(TemplateBody(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2(If2(TemplateSpan(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(TemplateSpan(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[TemplateBodyMapping(_0),input2]),TemplateLiteralTypes=input=>If2(If2(Const("`",input),([_0,input2])=>If2(TemplateBody(input2),([_1,input3])=>If2(Const("`",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[TemplateLiteralTypesMapping(_0),input2]),TemplateLiteral=input=>If2(TemplateLiteralTypes(input),([_0,input2])=>[TemplateLiteralMapping(_0),input2]),Dependent2=input=>If2(If2(If2(Const("if",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Const("then",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>If2(Const("else",input5),([_4,input6])=>If2(Type(input6),([_5,input7])=>[[_0,_1,_2,_3,_4,_5],input7])))))),([_0,input2])=>[_0,input2],()=>If2(If2(Const("if",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Const("then",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[DependentMapping(_0),input2]),LiteralBigInt=input=>If2(BigInt3(input),([_0,input2])=>[LiteralBigIntMapping(_0),input2]),LiteralBoolean=input=>If2(If2(Const("true",input),([_0,input2])=>[_0,input2],()=>If2(Const("false",input),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[LiteralBooleanMapping(_0),input2]),LiteralNumber=input=>If2(Number3(input),([_0,input2])=>[LiteralNumberMapping(_0),input2]),LiteralString=input=>If2(String3(["'",'"'],input),([_0,input2])=>[LiteralStringMapping(_0),input2]),KeyOf=input=>If2(If2(If2(Const("keyof",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[KeyOfMapping(_0),input2]),IndexArray_0=(input,result=[])=>If2(If2(If2(Const("[",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Const("]",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2(If2(Const("[",input),([_0,input2])=>If2(Const("]",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>IndexArray_0(input2,[...result,_0]),()=>[result,input]),IndexArray=input=>If2(IndexArray_0(input),([_0,input2])=>[IndexArrayMapping(_0),input2]),Extends2=input=>If2(If2(If2(Const("extends",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Const("?",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>If2(Const(":",input5),([_4,input6])=>If2(Type(input6),([_5,input7])=>[[_0,_1,_2,_3,_4,_5],input7])))))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ExtendsMapping(_0),input2]),Base=input=>If2(If2(If2(Const("(",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Const(")",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2(KeywordString(input),([_0,input2])=>[_0,input2],()=>If2(KeywordNumber(input),([_0,input2])=>[_0,input2],()=>If2(KeywordBoolean(input),([_0,input2])=>[_0,input2],()=>If2(KeywordUndefined(input),([_0,input2])=>[_0,input2],()=>If2(KeywordNull(input),([_0,input2])=>[_0,input2],()=>If2(KeywordInteger(input),([_0,input2])=>[_0,input2],()=>If2(KeywordBigInt(input),([_0,input2])=>[_0,input2],()=>If2(KeywordUnknown(input),([_0,input2])=>[_0,input2],()=>If2(KeywordAny(input),([_0,input2])=>[_0,input2],()=>If2(KeywordObject(input),([_0,input2])=>[_0,input2],()=>If2(KeywordNever(input),([_0,input2])=>[_0,input2],()=>If2(KeywordSymbol(input),([_0,input2])=>[_0,input2],()=>If2(KeywordVoid(input),([_0,input2])=>[_0,input2],()=>If2(KeywordThis(input),([_0,input2])=>[_0,input2],()=>If2(LiteralBigInt(input),([_0,input2])=>[_0,input2],()=>If2(LiteralBoolean(input),([_0,input2])=>[_0,input2],()=>If2(LiteralNumber(input),([_0,input2])=>[_0,input2],()=>If2(LiteralString(input),([_0,input2])=>[_0,input2],()=>If2(TemplateLiteral(input),([_0,input2])=>[_0,input2],()=>If2(Dependent2(input),([_0,input2])=>[_0,input2],()=>If2(_Object_2(input),([_0,input2])=>[_0,input2],()=>If2(_Tuple_(input),([_0,input2])=>[_0,input2],()=>If2(_Constructor_(input),([_0,input2])=>[_0,input2],()=>If2(_Function_2(input),([_0,input2])=>[_0,input2],()=>If2(_Mapped_(input),([_0,input2])=>[_0,input2],()=>If2(GenericCall(input),([_0,input2])=>[_0,input2],()=>If2(Reference(input),([_0,input2])=>[_0,input2],()=>[])))))))))))))))))))))))))))),([_0,input2])=>[BaseMapping(_0),input2]),With=input=>If2(If2(If2(Const("with",input),([_0,input2])=>If2(WithObject(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithMapping(_0),input2]),Factor=input=>If2(If2(KeyOf(input),([_0,input2])=>If2(Base(input2),([_1,input3])=>If2(IndexArray(input3),([_2,input4])=>If2(Extends2(input4),([_3,input5])=>If2(With(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[FactorMapping(_0),input2]),ExprTermTail=input=>If2(If2(If2(Const("&",input),([_0,input2])=>If2(Factor(input2),([_1,input3])=>If2(ExprTermTail(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[_0,input2]),ExprTerm=input=>If2(If2(Factor(input),([_0,input2])=>If2(ExprTermTail(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ExprTermMapping(_0),input2]),ExprTail=input=>If2(If2(If2(Const("|",input),([_0,input2])=>If2(ExprTerm(input2),([_1,input3])=>If2(ExprTail(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[_0,input2]),Expr=input=>If2(If2(ExprTerm(input),([_0,input2])=>If2(ExprTail(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ExprMapping(_0),input2]),ExprReadonly=input=>If2(If2(Const("readonly",input),([_0,input2])=>If2(Expr(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ExprReadonlyMapping(_0),input2]),ExprPipe=input=>If2(If2(Const("|",input),([_0,input2])=>If2(Expr(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ExprPipeMapping(_0),input2]),GenericType=input=>If2(If2(GenericParameters(input),([_0,input2])=>If2(Const("=",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[GenericTypeMapping(_0),input2]),InferType=input=>If2(If2(If2(Const("infer",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(Const("extends",input3),([_2,input4])=>If2(Expr(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[_0,input2],()=>If2(If2(Const("infer",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[InferTypeMapping(_0),input2]),Type=input=>If2(If2(InferType(input),([_0,input2])=>[_0,input2],()=>If2(ExprPipe(input),([_0,input2])=>[_0,input2],()=>If2(ExprReadonly(input),([_0,input2])=>[_0,input2],()=>If2(Expr(input),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[_0,input2]),PropertyKeyNumber=input=>If2(Number3(input),([_0,input2])=>[PropertyKeyNumberMapping(_0),input2]),PropertyKeyIdent=input=>If2(Ident(input),([_0,input2])=>[_0,input2]),PropertyKeyQuoted=input=>If2(String3(["'",'"'],input),([_0,input2])=>[_0,input2]),PropertyKeyIndex=input=>If2(If2(Const("[",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(If2(KeywordInteger(input4),([_02,input5])=>[_02,input5],()=>If2(KeywordNumber(input4),([_02,input5])=>[_02,input5],()=>If2(KeywordString(input4),([_02,input5])=>[_02,input5],()=>If2(KeywordSymbol(input4),([_02,input5])=>[_02,input5],()=>[])))),([_3,input5])=>If2(Const("]",input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[PropertyKeyIndexMapping(_0),input2]),PropertyKey=input=>If2(If2(PropertyKeyNumber(input),([_0,input2])=>[_0,input2],()=>If2(PropertyKeyIdent(input),([_0,input2])=>[_0,input2],()=>If2(PropertyKeyQuoted(input),([_0,input2])=>[_0,input2],()=>If2(PropertyKeyIndex(input),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[_0,input2]),Readonly2=input=>If2(If2(If2(Const("readonly",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ReadonlyMapping(_0),input2]),Optional3=input=>If2(If2(If2(Const("?",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[OptionalMapping(_0),input2]),Property=input=>If2(If2(Readonly2(input),([_0,input2])=>If2(PropertyKey(input2),([_1,input3])=>If2(Optional3(input3),([_2,input4])=>If2(Const(":",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[PropertyMapping(_0),input2]),PropertyDelimiter=input=>If2(If2(If2(Const(",",input),([_0,input2])=>If2(Const(`
`,input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const(";",input),([_0,input2])=>If2(Const(`
`,input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const(",",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(Const(";",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(Const(`
`,input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[]))))),([_0,input2])=>[_0,input2]),PropertyList_0=(input,result=[])=>If2(If2(PropertyDelimiter(input),([_0,input2])=>If2(Property(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>PropertyList_0(input2,[...result,_0]),()=>[result,input]),PropertyList=input=>If2(If2(If2(Property(input),([_0,input2])=>If2(PropertyList_0(input2),([_1,input3])=>If2(If2(PropertyDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[PropertyListMapping(_0),input2]),Properties=input=>If2(If2(Const("{",input),([_0,input2])=>If2(PropertyList(input2),([_1,input3])=>If2(Const("}",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[PropertiesMapping(_0),input2]),_Object_2=input=>If2(Properties(input),([_0,input2])=>[_Object_Mapping(_0),input2]),ElementNamed=input=>If2(If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Const("readonly",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[_0,input2],()=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Const("readonly",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[_0,input2],()=>If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[_0,input2],()=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[ElementNamedMapping(_0),input2]),ElementBase=input=>If2(If2(ElementNamed(input),([_0,input2])=>[_0,input2],()=>If2(If2(Readonly2(input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Optional3(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ElementBaseMapping(_0),input2]),Element=input=>If2(If2(If2(Const("...",input),([_0,input2])=>If2(ElementBase(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(ElementBase(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ElementMapping(_0),input2]),ElementList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Element(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ElementList_0(input2,[...result,_0]),()=>[result,input]),ElementList=input=>If2(If2(If2(Element(input),([_0,input2])=>If2(ElementList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ElementListMapping(_0),input2]),_Tuple_=input=>If2(If2(Const("[",input),([_0,input2])=>If2(ElementList(input2),([_1,input3])=>If2(Const("]",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_Tuple_Mapping(_0),input2]),ParameterReadonlyOptional=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Const("readonly",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[ParameterReadonlyOptionalMapping(_0),input2]),ParameterReadonly=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Const("readonly",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[ParameterReadonlyMapping(_0),input2]),ParameterOptional=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[ParameterOptionalMapping(_0),input2]),ParameterType=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[ParameterTypeMapping(_0),input2]),ParameterBase=input=>If2(If2(ParameterReadonlyOptional(input),([_0,input2])=>[_0,input2],()=>If2(ParameterReadonly(input),([_0,input2])=>[_0,input2],()=>If2(ParameterOptional(input),([_0,input2])=>[_0,input2],()=>If2(ParameterType(input),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[_0,input2]),Parameter2=input=>If2(If2(If2(Const("...",input),([_0,input2])=>If2(ParameterBase(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(ParameterBase(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ParameterMapping(_0),input2]),ParameterList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Parameter2(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ParameterList_0(input2,[...result,_0]),()=>[result,input]),ParameterList=input=>If2(If2(If2(Parameter2(input),([_0,input2])=>If2(ParameterList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ParameterListMapping(_0),input2]),_Function_2=input=>If2(If2(Const("(",input),([_0,input2])=>If2(ParameterList(input2),([_1,input3])=>If2(Const(")",input3),([_2,input4])=>If2(Const("=>",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[_Function_Mapping(_0),input2]),_Constructor_=input=>If2(If2(Const("new",input),([_0,input2])=>If2(Const("(",input2),([_1,input3])=>If2(ParameterList(input3),([_2,input4])=>If2(Const(")",input4),([_3,input5])=>If2(Const("=>",input5),([_4,input6])=>If2(Type(input6),([_5,input7])=>[[_0,_1,_2,_3,_4,_5],input7])))))),([_0,input2])=>[_Constructor_Mapping(_0),input2]),MappedReadonly=input=>If2(If2(If2(Const("+",input),([_0,input2])=>If2(Const("readonly",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("-",input),([_0,input2])=>If2(Const("readonly",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("readonly",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[MappedReadonlyMapping(_0),input2]),MappedOptional=input=>If2(If2(If2(Const("+",input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("-",input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("?",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[MappedOptionalMapping(_0),input2]),MappedAs=input=>If2(If2(If2(Const("as",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[MappedAsMapping(_0),input2]),_Mapped_=input=>If2(If2(Const("{",input),([_0,input2])=>If2(MappedReadonly(input2),([_1,input3])=>If2(Const("[",input3),([_2,input4])=>If2(Ident(input4),([_3,input5])=>If2(Const("in",input5),([_4,input6])=>If2(Type(input6),([_5,input7])=>If2(MappedAs(input7),([_6,input8])=>If2(Const("]",input8),([_7,input9])=>If2(MappedOptional(input9),([_8,input10])=>If2(Const(":",input10),([_9,input11])=>If2(Type(input11),([_10,input12])=>If2(OptionalSemiColon(input12),([_11,input13])=>If2(Const("}",input13),([_12,input14])=>[[_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12],input14]))))))))))))),([_0,input2])=>[_Mapped_Mapping(_0),input2]),Reference=input=>If2(Ident(input),([_0,input2])=>[ReferenceMapping(_0),input2]),WithBigInt=input=>If2(BigInt3(input),([_0,input2])=>[WithBigIntMapping(_0),input2]),WithNumber=input=>If2(Number3(input),([_0,input2])=>[WithNumberMapping(_0),input2]),WithBoolean=input=>If2(If2(Const("true",input),([_0,input2])=>[_0,input2],()=>If2(Const("false",input),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithBooleanMapping(_0),input2]),WithString=input=>If2(String3(['"',"'"],input),([_0,input2])=>[_0,input2]),WithNull=input=>If2(Const("null",input),([_0,input2])=>[WithNullMapping(_0),input2]),WithUndefined=input=>If2(Const("undefined",input),([_0,input2])=>[void 0,input2]),WithProperty=input=>If2(If2(PropertyKey(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(WithValue(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[WithPropertyMapping(_0),input2]),WithPropertyList_0=(input,result=[])=>If2(If2(PropertyDelimiter(input),([_0,input2])=>If2(WithProperty(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>WithPropertyList_0(input2,[...result,_0]),()=>[result,input]),WithPropertyList=input=>If2(If2(If2(WithProperty(input),([_0,input2])=>If2(WithPropertyList_0(input2),([_1,input3])=>If2(If2(PropertyDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithPropertyListMapping(_0),input2]),WithObject=input=>If2(If2(Const("{",input),([_0,input2])=>If2(WithPropertyList(input2),([_1,input3])=>If2(Const("}",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[WithObjectMapping(_0),input2]),WithElementList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(WithValue(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>WithElementList_0(input2,[...result,_0]),()=>[result,input]),WithElementList=input=>If2(If2(If2(WithValue(input),([_0,input2])=>If2(WithElementList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithElementListMapping(_0),input2]),WithArray=input=>If2(If2(Const("[",input),([_0,input2])=>If2(WithElementList(input2),([_1,input3])=>If2(Const("]",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[WithArrayMapping(_0),input2]),WithValue=input=>If2(If2(WithBigInt(input),([_0,input2])=>[_0,input2],()=>If2(WithNumber(input),([_0,input2])=>[_0,input2],()=>If2(WithBoolean(input),([_0,input2])=>[_0,input2],()=>If2(WithString(input),([_0,input2])=>[_0,input2],()=>If2(WithNull(input),([_0,input2])=>[_0,input2],()=>If2(WithUndefined(input),([_0,input2])=>[_0,input2],()=>If2(WithObject(input),([_0,input2])=>[_0,input2],()=>If2(WithArray(input),([_0,input2])=>[_0,input2],()=>[])))))))),([_0,input2])=>[_0,input2]),PatternBigInt=input=>If2(Const("-?(?:0|[1-9][0-9]*)n",input),([_0,input2])=>[PatternBigIntMapping(_0),input2]),PatternString=input=>If2(Const(".*",input),([_0,input2])=>[PatternStringMapping(_0),input2]),PatternNumber=input=>If2(Const("-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?",input),([_0,input2])=>[PatternNumberMapping(_0),input2]),PatternInteger=input=>If2(Const("-?(?:0|[1-9][0-9]*)",input),([_0,input2])=>[PatternIntegerMapping(_0),input2]),PatternNever=input=>If2(Const("(?!)",input),([_0,input2])=>[PatternNeverMapping(_0),input2]),PatternText=input=>If2(Until_1(["-?(?:0|[1-9][0-9]*)n",".*","-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?","-?(?:0|[1-9][0-9]*)","(?!)","(",")","$","|"],input),([_0,input2])=>[PatternTextMapping(_0),input2]),PatternBase=input=>If2(If2(PatternBigInt(input),([_0,input2])=>[_0,input2],()=>If2(PatternString(input),([_0,input2])=>[_0,input2],()=>If2(PatternNumber(input),([_0,input2])=>[_0,input2],()=>If2(PatternInteger(input),([_0,input2])=>[_0,input2],()=>If2(PatternNever(input),([_0,input2])=>[_0,input2],()=>If2(PatternGroup(input),([_0,input2])=>[_0,input2],()=>If2(PatternText(input),([_0,input2])=>[_0,input2],()=>[]))))))),([_0,input2])=>[_0,input2]),PatternGroup=input=>If2(If2(Const("(",input),([_0,input2])=>If2(PatternBody(input2),([_1,input3])=>If2(Const(")",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[PatternGroupMapping(_0),input2]),PatternUnion=input=>If2(If2(If2(PatternTerm(input),([_0,input2])=>If2(Const("|",input2),([_1,input3])=>If2(PatternUnion(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2(If2(PatternTerm(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[PatternUnionMapping(_0),input2]),PatternTerm=input=>If2(If2(PatternBase(input),([_0,input2])=>If2(PatternBody(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[PatternTermMapping(_0),input2]),PatternBody=input=>If2(If2(PatternUnion(input),([_0,input2])=>[_0,input2],()=>If2(PatternTerm(input),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[_0,input2]),Pattern=input=>If2(If2(Const("^",input),([_0,input2])=>If2(PatternBody(input2),([_1,input3])=>If2(Const("$",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[PatternMapping(_0),input2]),InterfaceDeclarationHeritageList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>InterfaceDeclarationHeritageList_0(input2,[...result,_0]),()=>[result,input]),InterfaceDeclarationHeritageList=input=>If2(If2(If2(Type(input),([_0,input2])=>If2(InterfaceDeclarationHeritageList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[InterfaceDeclarationHeritageListMapping(_0),input2]),InterfaceDeclarationHeritage=input=>If2(If2(If2(Const("extends",input),([_0,input2])=>If2(InterfaceDeclarationHeritageList(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[InterfaceDeclarationHeritageMapping(_0),input2]),InterfaceDeclarationGeneric=input=>If2(If2(Const("interface",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(GenericParameters(input3),([_2,input4])=>If2(InterfaceDeclarationHeritage(input4),([_3,input5])=>If2(Properties(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[InterfaceDeclarationGenericMapping(_0),input2]),InterfaceDeclaration=input=>If2(If2(Const("interface",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(InterfaceDeclarationHeritage(input3),([_2,input4])=>If2(Properties(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[InterfaceDeclarationMapping(_0),input2]),TypeAliasDeclarationGeneric=input=>If2(If2(Const("type",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(GenericParameters(input3),([_2,input4])=>If2(Const("=",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[TypeAliasDeclarationGenericMapping(_0),input2]),TypeAliasDeclaration=input=>If2(If2(Const("type",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(Const("=",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[TypeAliasDeclarationMapping(_0),input2]),ExportKeyword=input=>If2(If2(If2(Const("export",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ExportKeywordMapping(_0),input2]),ModuleDeclarationDelimiter=input=>If2(If2(If2(Const(";",input),([_0,input2])=>If2(Const(`
`,input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const(";",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(Const(`
`,input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[_0,input2]),ModuleDeclarationList_0=(input,result=[])=>If2(If2(ModuleDeclarationDelimiter(input),([_0,input2])=>If2(ModuleDeclaration(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ModuleDeclarationList_0(input2,[...result,_0]),()=>[result,input]),ModuleDeclarationList=input=>If2(If2(If2(ModuleDeclaration(input),([_0,input2])=>If2(ModuleDeclarationList_0(input2),([_1,input3])=>If2(If2(ModuleDeclarationDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ModuleDeclarationListMapping(_0),input2]),ModuleDeclaration=input=>If2(If2(ExportKeyword(input),([_0,input2])=>If2(If2(InterfaceDeclarationGeneric(input2),([_02,input3])=>[_02,input3],()=>If2(InterfaceDeclaration(input2),([_02,input3])=>[_02,input3],()=>If2(TypeAliasDeclarationGeneric(input2),([_02,input3])=>[_02,input3],()=>If2(TypeAliasDeclaration(input2),([_02,input3])=>[_02,input3],()=>[])))),([_1,input3])=>If2(OptionalSemiColon(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[ModuleDeclarationMapping(_0),input2]),Module=input=>If2(If2(ModuleDeclaration(input),([_0,input2])=>If2(ModuleDeclarationList(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ModuleMapping(_0),input2]),Script=input=>If2(If2(Module(input),([_0,input2])=>[_0,input2],()=>If2(GenericType(input),([_0,input2])=>[_0,input2],()=>If2(Type(input),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[_0,input2]);function ParseTemplateIntoTypes(template){let parsed=TemplateLiteralTypes(`\`${template}\``);return guard_exports.IsEqual(parsed.length,2)?parsed[0]:Unreachable()}function JoinString(input){return input.join("|")}function UnwrapTemplateLiteralPattern(pattern){return pattern.slice(1,pattern.length-1)}function EncodeLiteral(value,right,pattern){return EncodeTypes(right,`${pattern}${value}`)}function EncodeBigInt(right,pattern){return EncodeTypes(right,`${pattern}${BigIntPattern}`)}function EncodeInteger(right,pattern){return EncodeTypes(right,`${pattern}${IntegerPattern}`)}function EncodeNumber(right,pattern){return EncodeTypes(right,`${pattern}${NumberPattern}`)}function EncodeBoolean(right,pattern){return EncodeType(Union([Literal("false"),Literal("true")]),right,pattern)}function EncodeString(right,pattern){return EncodeTypes(right,`${pattern}${StringPattern}`)}function EncodeTemplateLiteral(templatePattern,right,pattern){return EncodeTypes(right,`${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`)}function EncodeTemplateLiteralDeferred(types,right,pattern){let templateLiteral=TemplateLiteralAction(types,{});return EncodeType(templateLiteral,right,pattern)}function EncodeEnum(values,right,pattern){let evaluated=EvaluateEnum(values);return EncodeType(evaluated,right,pattern)}function EncodeUnion(types,right,pattern,result=[]){return guard_exports.ShiftLeft(types,(head,tail)=>EncodeUnion(tail,right,pattern,[...result,EncodeType(head,[],"")]),()=>EncodeTypes(right,`${pattern}(${JoinString(result)})`))}function EncodeType(type,right,pattern){return IsEnum(type)?EncodeEnum(type.enum,right,pattern):IsInteger3(type)?EncodeInteger(right,pattern):IsLiteral(type)?EncodeLiteral(type.const,right,pattern):IsBigInt3(type)?EncodeBigInt(right,pattern):IsBoolean4(type)?EncodeBoolean(right,pattern):IsNumber4(type)?EncodeNumber(right,pattern):IsString4(type)?EncodeString(right,pattern):IsTemplateLiteral(type)?EncodeTemplateLiteral(type.pattern,right,pattern):IsTemplateLiteralDeferred(type)?EncodeTemplateLiteralDeferred(type.parameters[0],right,pattern):IsUnion(type)?EncodeUnion(type.anyOf,right,pattern):NeverPattern}function EncodeTypes(types,pattern){return guard_exports.ShiftLeft(types,(left,right)=>EncodeType(left,right,pattern),()=>pattern)}function EncodePattern(types){return`^${EncodeTypes(types,"")}$`}function TemplateLiteralEncode(types){let pattern=EncodePattern(types);return TemplateLiteralCreate(pattern)}function TemplateLiteralAction(types,options){return CanInstantiate(types)?memory_exports.Update(TemplateLiteralEncode(types),{},options):TemplateLiteralDeferred(types,options)}function TemplateLiteralInstantiate(context,state,types,options){let instantiatedTypes=InstantiateTypes(context,state,types);return TemplateLiteralAction(instantiatedTypes,options)}function TemplateLiteralDeferred(types,options={}){return Deferred("TemplateLiteral",[types],options)}function IsTemplateLiteralDeferred(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"action")&&guard_exports.IsEqual(value.action,"TemplateLiteral")}function TemplateLiteralFromTypes(types){return TemplateLiteralAction(types,{})}function TemplateLiteralFromString(template){let types=ParseTemplateIntoTypes(template);return TemplateLiteralFromTypes(types)}function TemplateLiteral2(input,options={}){let type=guard_exports.IsString(input)?TemplateLiteralFromString(input):TemplateLiteralFromTypes(input);return memory_exports.Update(type,{},options)}function IsTemplateLiteral(value){return IsKind(value,"TemplateLiteral")}var result_exports={};__export(result_exports,{ExtendsFalse:()=>ExtendsFalse,ExtendsTrue:()=>ExtendsTrue,ExtendsUnion:()=>ExtendsUnion,IsExtendsFalse:()=>IsExtendsFalse,IsExtendsTrue:()=>IsExtendsTrue,IsExtendsTrueLike:()=>IsExtendsTrueLike,IsExtendsUnion:()=>IsExtendsUnion,Match:()=>Match3});function ExtendsUnion(inferred){return memory_exports.Create({"~kind":"ExtendsUnion"},{inferred})}function IsExtendsUnion(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"inferred")&&guard_exports.IsEqual(value["~kind"],"ExtendsUnion")&&guard_exports.IsObject(value.inferred)}function ExtendsTrue(inferred){return memory_exports.Create({"~kind":"ExtendsTrue"},{inferred})}function IsExtendsTrue(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"inferred")&&guard_exports.IsEqual(value["~kind"],"ExtendsTrue")&&guard_exports.IsObject(value.inferred)}function ExtendsFalse(){return memory_exports.Create({"~kind":"ExtendsFalse"},{})}function IsExtendsFalse(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.IsEqual(value["~kind"],"ExtendsFalse")}function IsExtendsTrueLike(value){return IsExtendsUnion(value)||IsExtendsTrue(value)}function Match3(result,true_,false_){return IsExtendsTrueLike(result)?true_(result.inferred):false_()}function ExtendsRightInfer(inferred,name,left,right){return Match3(ExtendsLeft(inferred,left,right),checkInferred=>ExtendsTrue(memory_exports.Assign(memory_exports.Assign(inferred,checkInferred),{[name]:left})),()=>ExtendsFalse())}function ExtendsRightAny(inferred,_left){return ExtendsTrue(inferred)}function ExtendsRightDependent(inferred,left,if_,then_,else_){return Match3(ExtendsLeft(inferred,left,if_),inferred2=>Match3(ExtendsLeft(inferred2,left,then_),inferred3=>ExtendsTrue(inferred3),()=>ExtendsFalse()),()=>Match3(ExtendsLeft(inferred,left,else_),inferred2=>ExtendsTrue(inferred2),()=>ExtendsFalse()))}function ExtendsRightEnum(inferred,left,right){let evaluated=EvaluateEnum(right);return ExtendsLeft(inferred,left,evaluated)}function ExtendsRightIntersect(inferred,left,right){return guard_exports.ShiftLeft(right,(head,tail)=>Match3(ExtendsLeft(inferred,left,head),inferred2=>ExtendsRightIntersect(inferred2,left,tail),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsRightTemplateLiteral(inferred,left,right){let evaluated=EvaluateTemplateLiteral(right);return ExtendsLeft(inferred,left,evaluated)}function ExtendsRightUnion(inferred,left,right){return guard_exports.ShiftLeft(right,(head,tail)=>Match3(ExtendsLeft(inferred,left,head),inferred2=>ExtendsTrue(inferred2),()=>ExtendsRightUnion(inferred,left,tail)),()=>ExtendsFalse())}function ExtendsRight(inferred,left,right){return IsAny(right)?ExtendsRightAny(inferred,left):IsDependent(right)?ExtendsRightDependent(inferred,left,right.if,right.then,right.else):IsEnum(right)?ExtendsRightEnum(inferred,left,right.enum):IsInfer(right)?ExtendsRightInfer(inferred,right.name,left,right.extends):IsIntersect(right)?ExtendsRightIntersect(inferred,left,right.allOf):IsTemplateLiteral(right)?ExtendsRightTemplateLiteral(inferred,left,right.pattern):IsUnion(right)?ExtendsRightUnion(inferred,left,right.anyOf):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsAny(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsUnion(inferred)}function ExtendsImmutable(left,right){let isImmutableLeft=IsImmutable(left),isImmutableRight=IsImmutable(right);return isImmutableLeft&&isImmutableRight||!isImmutableLeft&&isImmutableRight?!0:!(isImmutableLeft&&!isImmutableRight)}function ExtendsArray(inferred,arrayLeft,left,right){return IsArray3(right)?ExtendsImmutable(arrayLeft,right)?ExtendsLeft(inferred,left,right.items):ExtendsFalse():ExtendsRight(inferred,arrayLeft,right)}function ExtendsBigInt(inferred,left,right){return IsBigInt3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsBoolean(inferred,left,right){return IsBoolean4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ParameterCompare(inferred,left,leftRest,right,rightRest){let checkLeft=IsInfer(right)?left:right,checkRight=IsInfer(right)?right:left,isLeftOptional=IsOptional(left),isRightOptional=IsOptional(right);return!isLeftOptional&&isRightOptional?ExtendsFalse():Match3(ExtendsLeft(inferred,checkLeft,checkRight),inferred2=>ExtendsParameters(inferred2,leftRest,rightRest),()=>ExtendsFalse())}function ParameterRight(inferred,left,leftRest,rightRest){return guard_exports.ShiftLeft(rightRest,(head,tail)=>ParameterCompare(inferred,left,leftRest,head,tail),()=>IsOptional(left)?ExtendsTrue(inferred):ExtendsFalse())}function ParametersLeft(inferred,left,rightRest){return guard_exports.ShiftLeft(left,(head,tail)=>ParameterRight(inferred,head,tail,rightRest),()=>ExtendsTrue(inferred))}function ExtendsParameters(inferred,left,right){return ParametersLeft(inferred,left,right)}function ExtendsReturnType(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):ExtendsLeft(inferred,left,right)}function ExtendsConstructor(inferred,parameters,returnType,right){return IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):IsConstructor3(right)?Match3(ExtendsParameters(inferred,parameters,right.parameters),inferred2=>ExtendsReturnType(inferred2,returnType,right.instanceType),()=>ExtendsFalse()):ExtendsFalse()}function ExtendsDependent(inferred,if_,then_,else_,right){return Match3(ExtendsLeft(inferred,if_,right),()=>ExtendsLeft(inferred,then_,right),()=>ExtendsLeft(inferred,else_,right))}function ExtendsEnum(inferred,left,right){let evaluated=EvaluateEnum(left);return ExtendsLeft(inferred,evaluated,right)}function ExtendsFunction(inferred,parameters,returnType,right){return IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):IsFunction3(right)?Match3(ExtendsParameters(inferred,parameters,right.parameters),inferred2=>ExtendsReturnType(inferred2,returnType,right.returnType),()=>ExtendsFalse()):ExtendsFalse()}function ExtendsInteger(inferred,left,right){return IsInteger3(right)?ExtendsTrue(inferred):IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsIntersect(inferred,left,right){let evaluated=EvaluateIntersect(left);return ExtendsLeft(inferred,evaluated,right)}function ExtendsLiteralValue(inferred,left,right){return left===right?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsLiteralBigInt(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsBigInt3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralBoolean(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsBoolean4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralNumber(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralString(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsString4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteral(inferred,left,right){return guard_exports.IsBigInt(left.const)?ExtendsLiteralBigInt(inferred,left.const,right):guard_exports.IsBoolean(left.const)?ExtendsLiteralBoolean(inferred,left.const,right):guard_exports.IsNumber(left.const)?ExtendsLiteralNumber(inferred,left.const,right):guard_exports.IsString(left.const)?ExtendsLiteralString(inferred,left.const,right):Unreachable()}function ExtendsNever(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):ExtendsTrue(inferred)}function ExtendsNull(inferred,left,right){return IsNull3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsNumber(inferred,left,right){return IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsPropertyOptional(inferred,left,right){return IsOptional(left)?IsOptional(right)?ExtendsTrue(inferred):ExtendsFalse():ExtendsTrue(inferred)}function ExtendsProperty(inferred,left,right){return IsInfer(right)&&IsNever(right.extends)?ExtendsFalse():Match3(ExtendsLeft(inferred,left,right),inferred2=>ExtendsPropertyOptional(inferred2,left,right),()=>ExtendsFalse())}function ExtractInferredProperties(keys,properties){return keys.reduce((result,key)=>key in properties?IsExtendsTrueLike(properties[key])?{...result,...properties[key].inferred}:Unreachable():Unreachable(),{})}function ExtendsPropertiesComparer(inferred,left,right){let properties={};for(let rightKey of guard_exports.Keys(right))properties[rightKey]=rightKey in left?ExtendsProperty({},left[rightKey],right[rightKey]):IsOptional(right[rightKey])?IsInfer(right[rightKey])?ExtendsTrue(memory_exports.Assign(inferred,{[right[rightKey].name]:right[rightKey].extends})):ExtendsTrue(inferred):ExtendsFalse();let checked=guard_exports.Values(properties).every(result=>IsExtendsTrueLike(result)),extracted=checked?ExtractInferredProperties(guard_exports.Keys(properties),properties):{};return checked?ExtendsTrue(extracted):ExtendsFalse()}function ExtendsProperties(inferred,left,right){let compared=ExtendsPropertiesComparer(inferred,left,right);return IsExtendsTrueLike(compared)?ExtendsTrue(memory_exports.Assign(inferred,compared.inferred)):ExtendsFalse()}function ExtendsObjectToObject(inferred,left,right){return ExtendsProperties(inferred,left,right)}function RecordMergeInferred(left,right){return guard_exports.Keys(right).reduce((result,key)=>({...result,[key]:guard_exports.HasPropertyKey(left,key)?IsUnion(result[key])?Union([...result[key].anyOf,right[key]]):Union([left[key],right[key]]):right[key]}),left)}function ExtendsRecordComparer(properties,keys,type,result){return guard_exports.ShiftLeft(keys,(left,right)=>Match3(ExtendsLeft({},properties[left],type),inferred=>ExtendsRecordComparer(properties,right,type,RecordMergeInferred(result,inferred)),()=>ExtendsFalse()),()=>ExtendsTrue(result))}function ExtendsObjectToRecord(inferred,properties,_pattern,value){let keys=guard_exports.Keys(properties);return ExtendsRecordComparer(properties,keys,value,inferred)}function ExtendsObject(inferred,left,right){return IsRecord(right)?ExtendsObjectToRecord(inferred,left,RecordPattern(right),RecordValue(right)):IsObject3(right)?ExtendsObjectToObject(inferred,left,right.properties):ExtendsRight(inferred,_Object_(left),right)}function FromObject3(inferred,properties){return guard_exports.IsEqual(guard_exports.Keys(properties).length,0)?ExtendsTrue(inferred):ExtendsFalse()}function FromRecord(inferred,_leftKey,leftValue,_rightKey,rightValue){return ExtendsLeft(inferred,leftValue,rightValue)}function ExtendsRecord(inferred,leftPattern,leftValue,right){return IsRecord(right)?FromRecord(inferred,RecordPatternToType(leftPattern),leftValue,RecordPatternToType(RecordPattern(right)),RecordValue(right)):IsObject3(right)?FromObject3(inferred,right.properties):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsString(inferred,left,right){return IsString4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsSymbol(inferred,left,right){return IsSymbol3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsTemplateLiteral(inferred,left,right){let evaluated=EvaluateTemplateLiteral(left);return ExtendsLeft(inferred,evaluated,right)}function Inferrable(name,type){return memory_exports.Create({"~kind":"Inferrable"},{name,type},{})}function IsInferable(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"name")&&guard_exports.HasPropertyKey(value,"type")&&guard_exports.IsEqual(value["~kind"],"Inferrable")&&guard_exports.IsString(value.name)&&guard_exports.IsObject(value.type)}function TryRestInferable(type){return IsRest(type)?IsInfer(type.items)?IsArray3(type.items.extends)?Inferrable(type.items.name,type.items.extends.items):IsUnknown(type.items.extends)?Inferrable(type.items.name,type.items.extends):void 0:Unreachable():void 0}function TryInferable(type){return IsInfer(type)?Inferrable(type.name,type.extends):void 0}function TryInferResults(rest,right,result=[]){return guard_exports.ShiftLeft(rest,(head,tail)=>Match3(ExtendsLeft({},head,right),()=>TryInferResults(tail,right,[...result,head]),()=>{}),()=>result)}function InferTupleResult(inferred,name,left,right){let results=TryInferResults(left,right);return guard_exports.IsArray(results)?ExtendsTrue(memory_exports.Assign(inferred,{[name]:Tuple(results)})):ExtendsFalse()}function InferUnionResult(inferred,name,left,right){let results=TryInferResults(left,right);return guard_exports.IsArray(results)?ExtendsTrue(memory_exports.Assign(inferred,{[name]:Union(results)})):ExtendsFalse()}function Reverse(types){return[...types].reverse()}function ApplyReverse(types,reversed){return reversed?Reverse(types):types}function Reversed(types){let first=types.length>0?types[0]:void 0,inferrable=IsSchema(first)?TryRestInferable(first):void 0;return IsSchema(inferrable)}function ElementsCompare(inferred,reversed,left,leftRest,right,rightRest){return Match3(ExtendsLeft(inferred,left,right),checkInferred=>Elements(checkInferred,reversed,leftRest,rightRest),()=>ExtendsFalse())}function ElementsLeft(inferred,reversed,leftRest,right,rightRest){let inferable=TryRestInferable(right);return IsInferable(inferable)?InferTupleResult(inferred,inferable.name,ApplyReverse(leftRest,reversed),inferable.type):guard_exports.ShiftLeft(leftRest,(head,tail)=>ElementsCompare(inferred,reversed,head,tail,right,rightRest),()=>ExtendsFalse())}function ElementsRight(inferred,reversed,leftRest,rightRest){return guard_exports.ShiftLeft(rightRest,(head,tail)=>ElementsLeft(inferred,reversed,leftRest,head,tail),()=>guard_exports.IsEqual(leftRest.length,0)?ExtendsTrue(inferred):ExtendsFalse())}function Elements(inferred,reversed,leftRest,rightRest){return ElementsRight(inferred,reversed,leftRest,rightRest)}function ExtendsTupleToTuple(inferred,left,right){let instantiatedRight=InstantiateElements(inferred,State([],[]),right),reversed=Reversed(instantiatedRight);return Elements(inferred,reversed,ApplyReverse(left,reversed),ApplyReverse(instantiatedRight,reversed))}function ExtendsTupleToArray(inferred,left,right){let inferrable=TryInferable(right);return IsInferable(inferrable)?InferUnionResult(inferred,inferrable.name,left,inferrable.type):guard_exports.ShiftLeft(left,(head,tail)=>Match3(ExtendsLeft(inferred,head,right),inferred2=>ExtendsTupleToArray(inferred2,tail,right),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsTuple(inferred,left,right){let instantiatedLeft=InstantiateElements(inferred,State([],[]),left);return IsTuple(right)?ExtendsTupleToTuple(inferred,instantiatedLeft,right.items):IsArray3(right)?ExtendsTupleToArray(inferred,instantiatedLeft,right.items):ExtendsRight(inferred,Tuple(instantiatedLeft),right)}function ExtendsUndefined(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):IsUndefined3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsUnionSome(inferred,type,unionTypes){return guard_exports.ShiftLeft(unionTypes,(head,tail)=>Match3(ExtendsLeft(inferred,type,head),inferred2=>ExtendsTrue(inferred2),()=>ExtendsUnionSome(inferred,type,tail)),()=>ExtendsFalse())}function ExtendsUnionLeft(inferred,left,right){return guard_exports.ShiftLeft(left,(head,tail)=>Match3(ExtendsUnionSome(inferred,head,right),inferred2=>ExtendsUnionLeft(inferred2,tail,right),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsUnion2(inferred,left,right){let inferrable=TryInferable(right);return IsInferable(inferrable)?InferUnionResult(inferred,inferrable.name,left,inferrable.type):IsUnion(right)?ExtendsUnionLeft(inferred,left,right.anyOf):ExtendsUnionLeft(inferred,left,[right])}function ExtendsUnknown(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsVoid(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsLeft(inferred,left,right){return IsAny(left)?ExtendsAny(inferred,left,right):IsArray3(left)?ExtendsArray(inferred,left,left.items,right):IsBigInt3(left)?ExtendsBigInt(inferred,left,right):IsBoolean4(left)?ExtendsBoolean(inferred,left,right):IsConstructor3(left)?ExtendsConstructor(inferred,left.parameters,left.instanceType,right):IsDependent(left)?ExtendsDependent(inferred,left.if,left.then,left.else,right):IsEnum(left)?ExtendsEnum(inferred,left.enum,right):IsFunction3(left)?ExtendsFunction(inferred,left.parameters,left.returnType,right):IsInteger3(left)?ExtendsInteger(inferred,left,right):IsIntersect(left)?ExtendsIntersect(inferred,left.allOf,right):IsLiteral(left)?ExtendsLiteral(inferred,left,right):IsNever(left)?ExtendsNever(inferred,left,right):IsNull3(left)?ExtendsNull(inferred,left,right):IsNumber4(left)?ExtendsNumber(inferred,left,right):IsObject3(left)?ExtendsObject(inferred,left.properties,right):IsRecord(left)?ExtendsRecord(inferred,RecordPattern(left),RecordValue(left),right):IsString4(left)?ExtendsString(inferred,left,right):IsSymbol3(left)?ExtendsSymbol(inferred,left,right):IsTemplateLiteral(left)?ExtendsTemplateLiteral(inferred,left.pattern,right):IsTuple(left)?ExtendsTuple(inferred,left.items,right):IsUndefined3(left)?ExtendsUndefined(inferred,left,right):IsUnion(left)?ExtendsUnion2(inferred,left.anyOf,right):IsUnknown(left)?ExtendsUnknown(inferred,left,right):IsVoid(left)?ExtendsVoid(inferred,left,right):ExtendsFalse()}function InterfaceOperation(heritage,properties){return EvaluateIntersect([...heritage,_Object_(properties)])}function InterfaceAction(heritage,properties,options){return CanInstantiate(heritage)?memory_exports.Update(InterfaceOperation(heritage,properties),{},options):InterfaceDeferred(heritage,properties,options)}function InterfaceInstantiate(context,state,heritage,properties,options){let instantiatedHeritage=InstantiateTypes(context,state,heritage),instantiatedProperties=InstantiateProperties(context,state,properties);return InterfaceAction(instantiatedHeritage,instantiatedProperties,options)}function InterfaceDeferred(heritage,properties,options={}){return Deferred("Interface",[heritage,properties],options)}function IsInterfaceDeferred(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"action")&&guard_exports.IsEqual(value.action,"Interface")}function Interface(heritage,properties,options={}){return InterfaceAction(heritage,properties,options)}function FromRef(stack,context,ref){return stack.includes(ref)?!0:FromType3([...stack,ref],context,context[ref])}function FromProperties(stack,context,properties){let types=PropertyValues(properties);return FromTypes2(stack,context,types)}function FromTypes2(stack,context,types){return guard_exports.ShiftLeft(types,(left,right)=>FromType3(stack,context,left)?!0:FromTypes2(stack,context,right),()=>!1)}function FromType3(stack,context,type){return IsRef(type)?FromRef(stack,context,type.$ref):IsArray3(type)?FromType3(stack,context,type.items):IsConstructor3(type)?FromTypes2(stack,context,[...type.parameters,type.instanceType]):IsFunction3(type)?FromTypes2(stack,context,[...type.parameters,type.returnType]):IsInterfaceDeferred(type)?FromProperties(stack,context,type.parameters[1]):IsIntersect(type)?FromTypes2(stack,context,type.allOf):IsObject3(type)?FromProperties(stack,context,type.properties):IsUnion(type)?FromTypes2(stack,context,type.anyOf):IsTuple(type)?FromTypes2(stack,context,type.items):IsRecord(type)?FromType3(stack,context,RecordValue(type)):!1}function CyclicCheck(stack,context,type){return FromType3(stack,context,type)}function ResolveCandidateKeys(context,keys){return keys.reduce((result,left)=>CyclicCheck([left],context,context[left])?[...result,left]:result,[])}function CyclicCandidates(context){let keys=PropertyKeys(context);return ResolveCandidateKeys(context,keys)}function FromRef2(context,ref,result){return result.includes(ref)?result:ref in context?FromType4(context,context[ref],[...result,ref]):Unreachable()}function FromProperties2(context,properties,result){let types=PropertyValues(properties);return FromTypes3(context,types,result)}function FromTypes3(context,types,result){return types.reduce((result2,left)=>FromType4(context,left,result2),result)}function FromType4(context,type,result){return IsRef(type)?FromRef2(context,type.$ref,result):IsArray3(type)?FromType4(context,type.items,result):IsConstructor3(type)?FromTypes3(context,[...type.parameters,type.instanceType],result):IsFunction3(type)?FromTypes3(context,[...type.parameters,type.returnType],result):IsInterfaceDeferred(type)?FromProperties2(context,type.parameters[1],result):IsIntersect(type)?FromTypes3(context,type.allOf,result):IsObject3(type)?FromProperties2(context,type.properties,result):IsUnion(type)?FromTypes3(context,type.anyOf,result):IsTuple(type)?FromTypes3(context,type.items,result):IsRecord(type)?FromType4(context,RecordValue(type),result):result}function CyclicDependencies(context,key,type){return FromType4(context,type,[key])}function FromRef3(_ref){return Any()}function FromProperties3(properties){return guard_exports.Keys(properties).reduce((result,key)=>({...result,[key]:FromType5(properties[key])}),{})}function FromTypes4(types){return types.reduce((result,left)=>[...result,FromType5(left)],[])}function FromType5(type){return IsRef(type)?FromRef3(type.$ref):IsArray3(type)?_Array_(FromType5(type.items),ArrayOptions(type)):IsConstructor3(type)?Constructor(FromTypes4(type.parameters),FromType5(type.instanceType)):IsFunction3(type)?_Function_(FromTypes4(type.parameters),FromType5(type.returnType)):IsIntersect(type)?Intersect(FromTypes4(type.allOf)):IsObject3(type)?_Object_(FromProperties3(type.properties)):IsRecord(type)?Record(RecordKey(type),FromType5(RecordValue(type))):IsUnion(type)?Union(FromTypes4(type.anyOf)):IsTuple(type)?Tuple(FromTypes4(type.items)):type}function CyclicAnyFromParameters(defs,ref){return ref in defs?FromType5(defs[ref]):Unknown()}function CyclicExtends(type){return CyclicAnyFromParameters(type.$defs,type.$ref)}function CyclicInterface(context,heritage,properties){let instantiatedHeritage=InstantiateTypes(context,State([],[]),heritage),instantiatedProperties=InstantiateProperties({},State([],[]),properties);return EvaluateIntersect([...instantiatedHeritage,_Object_(instantiatedProperties)])}function CyclicDefinitions(context,dependencies){return guard_exports.Keys(context).filter(key=>dependencies.includes(key)).reduce((result,key)=>{let type=context[key],instantiatedType=IsInterfaceDeferred(type)?CyclicInterface(context,type.parameters[0],type.parameters[1]):type;return{...result,[key]:instantiatedType}},{})}function InstantiateCyclic(context,ref,type){let dependencies=CyclicDependencies(context,ref,type),definitions=CyclicDefinitions(context,dependencies);return Cyclic(definitions,ref)}function Resolve(defs,ref){return ref in defs?IsRef(defs[ref])?Resolve(defs,defs[ref].$ref):defs[ref]:Never()}function CyclicTarget(defs,ref){return Resolve(defs,ref)}function Canonical(type){return IsCyclic(type)?CyclicExtends(type):IsUnsafe(type)?Unknown():type}function Extends(inferred,left,right){let canonicalLeft=Canonical(left),canonicalRight=Canonical(right);return ExtendsLeft(inferred,canonicalLeft,canonicalRight)}var CompareResultEqual=0,CompareResultDisjoint=1,CompareResultLeftInside=2,CompareResultRightInside=3;function Compare(left,right){let extendsCheck=[Extends({},left,right),Extends({},right,left)];return result_exports.IsExtendsTrueLike(extendsCheck[0])&&result_exports.IsExtendsTrueLike(extendsCheck[1])?CompareResultEqual:result_exports.IsExtendsTrueLike(extendsCheck[0])&&result_exports.IsExtendsFalse(extendsCheck[1])?CompareResultLeftInside:result_exports.IsExtendsFalse(extendsCheck[0])&&result_exports.IsExtendsTrueLike(extendsCheck[1])?CompareResultRightInside:CompareResultDisjoint}function BroadenFilter(type,types,result=[],all=types){return guard_exports.ShiftLeft(types,(left,right)=>{let compare=Compare(type,left);return guard_exports.IsEqual(compare,CompareResultLeftInside)||guard_exports.IsEqual(compare,CompareResultEqual)?all:guard_exports.IsEqual(compare,CompareResultDisjoint)?BroadenFilter(type,right,[...result,left],all):BroadenFilter(type,right,result,all)},()=>[...result,type])}function BroadenType(type,types,result){let evaluated=EvaluateType(type);return IsAny(evaluated)?[evaluated]:IsUnknown(evaluated)?[evaluated]:IsNever(evaluated)?BroadenTypes(types,result):IsObject3(evaluated)?BroadenTypes(types,[...result,evaluated]):BroadenTypes(types,BroadenFilter(evaluated,result))}function BroadenTypes(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>BroadenType(left,right,result),()=>result)}function Broaden(types){let broadened=BroadenTypes(types);return Flatten(broadened)}function EvaluateAction(type,options){return memory_exports.Update(EvaluateType(type),{},options)}function EvaluateInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return EvaluateAction(instantiatedType,options)}function CollectDistributionNames(expression,result=[]){return IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Conditional")?IsRef(expression.parameters[0])?CollectDistributionNames(expression.parameters[2],CollectDistributionNames(expression.parameters[3],[...result,expression.parameters[0].$ref])):CollectDistributionNames(expression.parameters[2],CollectDistributionNames(expression.parameters[3],result)):IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Mapped")&&IsDeferred(expression.parameters[1])&&guard_exports.IsEqual(expression.parameters[1].action,"KeyOf")&&IsRef(expression.parameters[1].parameters[0])?[...result,expression.parameters[1].parameters[0].$ref]:result}function BuildDistributionArray(parameters,names){return parameters.reduce((result,left)=>[...result,names.includes(left.name)],[])}function ZipDistributionArray(arguments_,distributionArray,result=[]){return guard_exports.ShiftLeft(arguments_,(argumentLeft,argumentRight)=>guard_exports.ShiftLeft(distributionArray,(booleanLeft,booleanRight)=>ZipDistributionArray(argumentRight,booleanRight,[...result,[booleanLeft,argumentLeft]]),()=>result),()=>result)}function CanonicalArgument(type){return IsTemplateLiteral(type)?EvaluateTemplateLiteral(type.pattern):IsEnum(type)?EvaluateEnum(type.enum):type}function Expand(type){let canonicalArgument=CanonicalArgument(type);return IsUnion(canonicalArgument)?[...canonicalArgument.anyOf]:[canonicalArgument]}function Append(current,type){return current.reduce((result,left)=>[...result,[...left,type]],[])}function Cross(current,variants){return variants.reduce((result,left)=>[...result,...Append(current,left)],[])}function Distribute2(zipped){return zipped.reduce((result,left)=>guard_exports.IsEqual(left[0],!0)?Cross(result,Expand(left[1])):Cross(result,[left[1]]),[[]])}function DistributeArguments(parameters,arguments_,expression){let distributionNames=CollectDistributionNames(expression),distributionArray=BuildDistributionArray(parameters,distributionNames),zippedArguments=ZipDistributionArray(arguments_,distributionArray);return IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Conditional")||IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Mapped")?Distribute2(zippedArguments):[arguments_]}function FromNotResolvable(){return["(not-resolvable)",Never()]}function FromNotGeneric(){return["(not-generic)",Never()]}function FromGeneric(name,parameters,expression){return[name,Generic(parameters,expression)]}function FromRef4(context,ref,arguments_){return ref in context?FromType6(context,ref,context[ref],arguments_):FromNotResolvable()}function FromType6(context,name,target,arguments_){return IsGeneric(target)?FromGeneric(name,target.parameters,target.expression):IsRef(target)?FromRef4(context,target.$ref,arguments_):FromNotGeneric()}function ResolveTarget(context,target,arguments_){return FromType6(context,"(anonymous)",target,arguments_)}function AssertArgumentExtends(name,type,extends_){if(IsInfer(type)||IsCall(type)||result_exports.IsExtendsTrueLike(Extends({},type,extends_)))return;let cause={parameter:name,expect:extends_,actual:type};throw new Error(`Argument for parameter ${name} does not satisfy constraint`,{cause})}function BindArgument(context,state,name,extends_,type){let instantiatedArgument=InstantiateType(context,state,type);return AssertArgumentExtends(name,instantiatedArgument,extends_),memory_exports.Assign(context,{[name]:instantiatedArgument})}function BindArguments(context,state,parameterLeft,parameterRight,arguments_){let instantiatedExtends=InstantiateType(context,state,parameterLeft.extends),instantiatedEquals=InstantiateType(context,state,parameterLeft.equals);return guard_exports.ShiftLeft(arguments_,(left,right)=>BindParameters(BindArgument(context,state,parameterLeft.name,instantiatedExtends,left),state,parameterRight,right),()=>BindParameters(BindArgument(context,state,parameterLeft.name,instantiatedExtends,instantiatedEquals),state,parameterRight,[]))}function BindParameters(context,state,parameters,arguments_){return guard_exports.ShiftLeft(parameters,(left,right)=>BindArguments(context,state,left,right,arguments_),()=>context)}function ResolveArgumentsContext(context,state,parameters,arguments_){return BindParameters(context,state,parameters,arguments_)}var instantiationDepth=0,instantiationCount=0;function InstantiationAssert(){if(!guard_exports.IsLessThan(instantiationCount,settings_exports.Get().maxInstantiationCount))throw Error("Type instantiation is excessively deep and possibly infinite")}function InstantiationIncrement(){InstantiationAssert(),instantiationCount++,instantiationDepth++}function InstantiationDecrement(){instantiationDepth--,guard_exports.IsEqual(instantiationDepth,0)&&(instantiationCount=0)}function Peek(state){return guard_exports.IsGreaterThan(state.callstack.length,0)?state.callstack[state.callstack.length-1]:""}function IsTailCall(state,name){return guard_exports.IsEqual(Peek(state),name)}function CallDispatch(context,state,target,parameters,expression,arguments_){InstantiationIncrement();try{let argumentsContext=ResolveArgumentsContext(context,state,parameters,arguments_),returnType=InstantiateType(argumentsContext,State([...state.callstack,target.$ref],state.visited),expression);return InstantiateType(argumentsContext,State([],[]),returnType)}finally{InstantiationDecrement()}}function CallDistributed(context,state,target,parameters,expression,distributedArguments){return distributedArguments.reduce((result,arguments_)=>{let returnType=CallDispatch(context,state,target,parameters,expression,arguments_);return[...result,returnType]},[])}function CallImmediate(context,state,target,parameters,expression,arguments_){let distributedArguments=DistributeArguments(parameters,arguments_,expression),returnTypes=CallDistributed(context,state,target,parameters,expression,distributedArguments);return guard_exports.IsEqual(returnTypes.length,1)?returnTypes[0]:EvaluateUnion(returnTypes)}function CallInstantiate(context,state,target,arguments_){let instantiatedArguments=InstantiateTypes(context,state,arguments_),resolved=ResolveTarget(context,target,arguments_),name=resolved[0],type=resolved[1];return IsGeneric(type)?IsTailCall(state,name)?CallConstruct(Ref(name),instantiatedArguments):CallImmediate(context,state,Ref(name),type.parameters,type.expression,instantiatedArguments):CallConstruct(target,instantiatedArguments)}function CallConstruct(target,arguments_){return memory_exports.Create({"~kind":"Call"},{type:"call",target,arguments:arguments_},{})}function Call2(target,arguments_){return CallInstantiate({},State([],[]),target,arguments_)}function IsCall(value){return IsKind(value,"Call")}function RemoveImmutableOperation(type){return memory_exports.Discard(type,["~immutable"])}function RemoveImmutableAction(type,options){return memory_exports.Update(RemoveImmutableOperation(type),{},options)}function RemoveImmutableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return RemoveImmutableAction(instantiatedType,options)}function ApplyMapping(mapping,value){return mapping(value)}function FromLiteral3(mapping,value){return guard_exports.IsString(value)?Literal(ApplyMapping(mapping,value)):Literal(value)}function FromTemplateLiteral(mapping,pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType7(mapping,evaluated)}function FromUnion2(mapping,types){let result=types.map(type=>FromType7(mapping,type));return Union(result)}function FromType7(mapping,type){return IsLiteral(type)?FromLiteral3(mapping,type.const):IsTemplateLiteral(type)?FromTemplateLiteral(mapping,type.pattern):IsUnion(type)?FromUnion2(mapping,type.anyOf):type}function CapitalizeDeferred(type,options={}){return Deferred("Capitalize",[type],options)}function Capitalize(type,options={}){return CapitalizeAction(type,options)}function LowercaseDeferred(type,options={}){return Deferred("Lowercase",[type],options)}function Lowercase(type,options={}){return LowercaseAction(type,options)}function UncapitalizeDeferred(type,options={}){return Deferred("Uncapitalize",[type],options)}function Uncapitalize(type,options={}){return UncapitalizeAction(type,options)}function UppercaseDeferred(type,options={}){return Deferred("Uppercase",[type],options)}function Uppercase(type,options={}){return UppercaseAction(type,options)}var CapitalizeMapping=input=>input[0].toUpperCase()+input.slice(1),LowercaseMapping=input=>input.toLowerCase(),UncapitalizeMapping=input=>input[0].toLowerCase()+input.slice(1),UppercaseMapping=input=>input.toUpperCase();function CapitalizeAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(CapitalizeMapping,type),{},options):CapitalizeDeferred(type,options)}function LowercaseAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(LowercaseMapping,type),{},options):LowercaseDeferred(type,options)}function UncapitalizeAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(UncapitalizeMapping,type),{},options):UncapitalizeDeferred(type,options)}function UppercaseAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(UppercaseMapping,type),{},options):UppercaseDeferred(type,options)}function CapitalizeInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return CapitalizeAction(instantiatedType,options)}function LowercaseInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return LowercaseAction(instantiatedType,options)}function UncapitalizeInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return UncapitalizeAction(instantiatedType,options)}function UppercaseInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return UppercaseAction(instantiatedType,options)}function ConditionalDeferred(left,right,true_,false_,options={}){return Deferred("Conditional",[left,right,true_,false_],options)}function Conditional(left,right,true_,false_,options={}){return ConditionalAction({},State([],[]),left,right,true_,false_,options)}function ConditionalOperation(context,state,left,right,true_,false_){let extendsResult=Extends(context,left,right);return result_exports.IsExtendsUnion(extendsResult)?Union([InstantiateType(extendsResult.inferred,state,true_),InstantiateType(context,state,false_)]):result_exports.IsExtendsTrue(extendsResult)?InstantiateType(extendsResult.inferred,state,true_):InstantiateType(context,state,false_)}function ConditionalAction(context,state,left,right,true_,false_,options){return CanInstantiate([left,right])?memory_exports.Update(ConditionalOperation(context,state,left,right,true_,false_),{},options):ConditionalDeferred(left,right,true_,false_,options)}function ConditionalInstantiate(context,state,left,right,true_,false_,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ConditionalAction(context,state,instantiatedLeft,instantiatedRight,true_,false_,options)}function ConstructorParametersDeferred(type,options={}){return Deferred("ConstructorParameters",[type],options)}function ConstructorParameters(type,options={}){return ConstructorParametersAction(type,options)}function ConstructorParametersOperation(type){let parameters=IsConstructor3(type)?type.parameters:[],instantiatedParameters=InstantiateElements({},State([],[]),parameters);return Tuple(instantiatedParameters)}function ConstructorParametersAction(type,options){return CanInstantiate([type])?memory_exports.Update(ConstructorParametersOperation(type),{},options):ConstructorParametersDeferred(type,options)}function ConstructorParametersInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ConstructorParametersAction(instantiatedType,options)}function ExcludeDeferred(left,right,options={}){return Deferred("Exclude",[left,right],options)}function Exclude(left,right,options={}){return ExcludeAction(left,right,options)}function ExcludeAction(left,right,options){return CanInstantiate([left,right])?memory_exports.Update(ExcludeOperation(left,right),{},options):ExcludeDeferred(left,right,options)}function ExcludeInstantiate(context,state,left,right,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ExcludeAction(instantiatedLeft,instantiatedRight,options)}function ExtractDeferred(left,right,options={}){return Deferred("Extract",[left,right],options)}function Extract(left,right,options={}){return ExtractAction(left,right,options)}function ExtractType(left,right){let check=Extends({},left,right);return result_exports.IsExtendsTrueLike(check)?[left]:[]}function ExtractUnion(left,right,result=[]){return guard_exports.ShiftLeft(left,(head,tail)=>ExtractUnion(tail,right,[...result,...ExtractType(head,right)]),()=>result)}function ExtractOperation(left,right){let evaluated=EvaluateType(left),canonical=IsUnion(evaluated)?evaluated.anyOf:[evaluated],remaining=ExtractUnion(canonical,right);return EvaluateUnion(remaining)}function ExtractAction(left,right,options){return CanInstantiate([left,right])?memory_exports.Update(ExtractOperation(left,right),{},options):ExtractDeferred(left,right,options)}function ExtractInstantiate(context,state,left,right,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ExtractAction(instantiatedLeft,instantiatedRight,options)}function KeysToLiterals(keys){return keys.reduce((result,left)=>IsLiteralValue(left)?[...result,Literal(left)]:result,[])}function KeysToIndexer(keys){let literals=KeysToLiterals(keys);return Union(literals)}function IndexDeferred(type,indexer,options={}){return Deferred("Index",[type,indexer],options)}function Index(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return IndexAction(type,indexer,options)}function FromCyclic(defs,ref){let target=CyclicTarget(defs,ref);return FromType8(target)}function FromDependent(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType8(evaluated)}function CollapseIntersectProperties(left,right){let leftKeys=guard_exports.Keys(left).filter(key=>!guard_exports.HasPropertyKey(right,key)),rightKeys=guard_exports.Keys(right).filter(key=>!guard_exports.HasPropertyKey(left,key)),sharedKeys=guard_exports.Keys(left).filter(key=>guard_exports.HasPropertyKey(right,key)),leftProperties=leftKeys.reduce((result,key)=>({...result,[key]:left[key]}),{}),rightProperties=rightKeys.reduce((result,key)=>({...result,[key]:right[key]}),{}),sharedProperties=sharedKeys.reduce((result,key)=>({...result,[key]:EvaluateIntersect([left[key],right[key]])}),{}),unique=memory_exports.Assign(leftProperties,rightProperties);return memory_exports.Assign(unique,sharedProperties)}function FromIntersect(types){return types.reduce((result,left)=>CollapseIntersectProperties(result,FromType8(left)),{})}function FromTuple(types){let object=TupleToObject(Tuple(types));return FromType8(object)}function CollapseUnionProperties(left,right){return guard_exports.Keys(left).filter(key=>key in right).reduce((result2,key)=>({...result2,[key]:EvaluateUnion([left[key],right[key]])}),{})}function ReduceVariants(types,result){return guard_exports.ShiftLeft(types,(left,right)=>ReduceVariants(right,CollapseUnionProperties(result,FromType8(left))),()=>result)}function FromUnion3(types){return guard_exports.ShiftLeft(types,(left,right)=>ReduceVariants(right,FromType8(left)),()=>Unreachable())}function FromType8(type){return IsCyclic(type)?FromCyclic(type.$defs,type.$ref):IsDependent(type)?FromDependent(type.if,type.then,type.else):IsIntersect(type)?FromIntersect(type.allOf):IsUnion(type)?FromUnion3(type.anyOf):IsTuple(type)?FromTuple(type.items):IsObject3(type)?type.properties:{}}function CollapseToObject(type){let properties=FromType8(type);return _Object_(properties)}var integerKeyPattern=new RegExp("^(?:0|[1-9][0-9]*)$");function ConvertToIntegerKey(value){let normal=`${value}`;return integerKeyPattern.test(normal)?parseInt(normal):value}function NormalizeLiteral(value){return Literal(ConvertToIntegerKey(value))}function NormalizeIndexerTypes(types){return types.map(type=>NormalizeIndexer(type))}function NormalizeIndexer(type){return IsIntersect(type)?Intersect(NormalizeIndexerTypes(type.allOf)):IsUnion(type)?Union(NormalizeIndexerTypes(type.anyOf)):IsLiteral(type)?NormalizeLiteral(type.const):type}function FromArray3(type,indexer){let normalizedIndexer=NormalizeIndexer(indexer),check=Extends({},normalizedIndexer,Number2());return result_exports.IsExtendsTrueLike(check)?type:IsLiteral(indexer)&&guard_exports.IsEqual(indexer.const,"length")?Number2():Never()}function FromCyclic2(defs,ref){let target=CyclicTarget(defs,ref);return FromType9(target)}function FromDependent2(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType9(evaluated)}function FromEnum(values){let evaluated=EvaluateEnum(values);return FromType9(evaluated)}function FromIntersect2(types){let evaluated=EvaluateIntersect(types);return FromType9(evaluated)}function FromLiteral4(value){return[`${value}`]}function FromTemplateLiteral2(pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType9(evaluated)}function FromUnion4(types){return types.reduce((result,left)=>[...result,...FromType9(left)],[])}function FromType9(type){return IsCyclic(type)?FromCyclic2(type.$defs,type.$ref):IsDependent(type)?FromDependent2(type.if,type.then,type.else):IsEnum(type)?FromEnum(type.enum):IsIntersect(type)?FromIntersect2(type.allOf):IsLiteral(type)?FromLiteral4(type.const):IsTemplateLiteral(type)?FromTemplateLiteral2(type.pattern):IsUnion(type)?FromUnion4(type.anyOf):[]}function ToIndexableKeys(type){return FromType9(type)}function FromTypes5(properties,types){return types.map(type=>FromType10(properties,type))}function FromType10(properties,type){return IsArray3(type)?_Array_(FromType10(properties,type.items)):IsConstructor3(type)?Constructor(FromTypes5(properties,type.parameters),FromType10(properties,type.instanceType)):IsFunction3(type)?_Function_(FromTypes5(properties,type.parameters),FromType10(properties,type.returnType)):IsTuple(type)?Tuple(FromTypes5(properties,type.items)):IsUnion(type)?Union(FromTypes5(properties,type.anyOf)):IsIntersect(type)?Intersect(FromTypes5(properties,type.allOf)):IsThis(type)?_Object_(properties):type}function ExpandThis(properties,type){return FromType10(properties,type)}function IndexProperty(properties,key){let selectedType=key in properties?properties[key]:Never();return ExpandThis(properties,selectedType)}function IndexProperties(properties,keys){return keys.reduce((result,left)=>[...result,IndexProperty(properties,left)],[])}function FromIndexer(properties,indexer){let keys=ToIndexableKeys(indexer),variants=IndexProperties(properties,keys);return EvaluateUnion(variants)}var NumericKeyPattern=new RegExp(IntegerKey);function NumericKeys(keys){return keys.filter(key=>NumericKeyPattern.test(key))}function FromIndexerNumber(properties){let keys=PropertyKeys(properties),numericKeys=NumericKeys(keys),variants=IndexProperties(properties,numericKeys);return EvaluateUnion(variants)}function FromObject5(properties,indexer){return IsNumber4(indexer)?FromIndexerNumber(properties):FromIndexer(properties,indexer)}function ConvertLiteral(value){return Literal(ConvertToIntegerKey(value))}function ArrayIndexerTypes(types){return types.map(type=>FormatArrayIndexer(type))}function FormatArrayIndexer(type){return IsIntersect(type)?Intersect(ArrayIndexerTypes(type.allOf)):IsUnion(type)?Union(ArrayIndexerTypes(type.anyOf)):IsLiteral(type)?ConvertLiteral(type.const):type}function IndexElementsWithIndexer(types,indexer){return types.reduceRight((result,right,index)=>{let check=Extends({},Literal(index),indexer);return result_exports.IsExtendsTrueLike(check)?[right,...result]:result},[])}function FromTupleWithIndexer(types,indexer){let formattedArrayIndexer=FormatArrayIndexer(indexer),elements=IndexElementsWithIndexer(types,formattedArrayIndexer);return EvaluateUnionFast(elements)}function FromTupleWithoutIndexer(types){return EvaluateUnionFast(types)}function FromTuple2(types,indexer){return IsLiteral(indexer)&&guard_exports.IsEqual(indexer.const,"length")?Literal(types.length):IsNumber4(indexer)||IsInteger3(indexer)?FromTupleWithoutIndexer(types):FromTupleWithIndexer(types,indexer)}function FromType11(type,indexer){return IsArray3(type)?FromArray3(type.items,indexer):IsObject3(type)?FromObject5(type.properties,indexer):IsTuple(type)?FromTuple2(type.items,indexer):Never()}function NormalizeType(type){return IsCyclic(type)||IsDependent(type)||IsIntersect(type)||IsUnion(type)?CollapseToObject(type):type}function IndexAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType11(NormalizeType(type),indexer),{},options):IndexDeferred(type,indexer,options)}function IndexInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return IndexAction(instantiatedType,instantiatedIndexer,options)}function InstanceTypeDeferred(type,options={}){return Deferred("InstanceType",[type],options)}function InstanceType(type,options={}){return InstanceTypeAction(type,options)}function InstanceTypeOperation(type){return IsConstructor3(type)?type.instanceType:Never()}function InstanceTypeAction(type,options){return CanInstantiate([type])?memory_exports.Update(InstanceTypeOperation(type),{},options):InstanceTypeDeferred(type,options)}function InstanceTypeInstantiate(context,state,type,options={}){let instantiatedType=InstantiateType(context,state,type);return InstanceTypeAction(instantiatedType,options)}function KeyOfDeferred(type,options={}){return Deferred("KeyOf",[type],options)}function KeyOf2(type,options={}){return KeyOfAction(type,options)}function FromAny(){return Union([Number2(),String2(),Symbol()])}function FromArray4(_type){return Number2()}function FromPropertyKeys(keys){return keys.reduce((result2,left)=>IsLiteralValue(left)?[...result2,Literal(ConvertToIntegerKey(left))]:Unreachable(),[])}function FromObject6(properties){let propertyKeys=guard_exports.Keys(properties),variants=FromPropertyKeys(propertyKeys);return EvaluateUnionFast(variants)}function FromRecord2(type){return RecordKey(type)}function FromTuple3(types){let result=types.map((_,index)=>Literal(index));return EvaluateUnionFast(result)}function FromType12(type){return IsAny(type)?FromAny():IsArray3(type)?FromArray4(type.items):IsObject3(type)?FromObject6(type.properties):IsRecord(type)?FromRecord2(type):IsTuple(type)?FromTuple3(type.items):Never()}function NormalizeType2(type){return IsCyclic(type)||IsDependent(type)||IsIntersect(type)||IsUnion(type)?CollapseToObject(type):type}function KeyOfAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType12(NormalizeType2(type)),{},options):KeyOfDeferred(type,options)}function KeyOfInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return KeyOfAction(instantiatedType,options)}function MappedDeferred(identifier,type,as,property,options={}){return Deferred("Mapped",[identifier,type,as,property],options)}function Mapped(identifier,type,as,property,options={}){return MappedAction({},State([],[]),identifier,type,as,property,options)}function FromTemplateLiteral3(pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType13(evaluated)}function FromUnion5(types){return types.reduce((result,left)=>[...result,...FromType13(left)],[])}function FromEnum2(values){let evaluated=EvaluateEnum(values);return FromType13(evaluated)}function FromLiteral5(value){return guard_exports.IsNumber(value)?[Literal(`${value}`)]:[Literal(value)]}function FromType13(type){return IsEnum(type)?FromEnum2(type.enum):IsLiteral(type)?FromLiteral5(type.const):IsTemplateLiteral(type)?FromTemplateLiteral3(type.pattern):IsUnion(type)?FromUnion5(type.anyOf):[type]}function MappedVariants(type){return FromType13(type)}function CanonicalAs(instantiatedAs){return IsTemplateLiteral(instantiatedAs)?EvaluateTemplateLiteral(instantiatedAs.pattern):instantiatedAs}function MappedVariant(context,state,identifier,variant,as,property){let variantContext=memory_exports.Assign(context,{[identifier.name]:variant}),instantiatedAs=InstantiateType(variantContext,state,as),canonicalAs=CanonicalAs(instantiatedAs),instantiatedProperty=InstantiateType(variantContext,state,property);return IsLiteralNumber(canonicalAs)||IsLiteralString(canonicalAs)?{[canonicalAs.const]:instantiatedProperty}:{}}function MappedProperties(context,state,identifier,variants,as,property){return variants.reduce((result,left)=>[...result,MappedVariant(context,state,identifier,left,as,property)],[])}function MappedObjects(properties){return properties.reduce((result,left)=>[...result,_Object_(left)],[])}function MappedOperation(context,state,identifier,type,as,property){let variants=MappedVariants(type),mappedProperties=MappedProperties(context,state,identifier,variants,as,property),mappedObjects=MappedObjects(mappedProperties);return EvaluateIntersect(mappedObjects)}function MappedAction(context,state,identifier,type,as,property,options){return CanInstantiate([type])?memory_exports.Update(MappedOperation(context,state,identifier,type,as,property),{},options):MappedDeferred(identifier,type,as,property,options)}function MappedInstantiate(context,state,identifier,type,as,property,options){let instantiatedType=InstantiateType(context,state,type);return MappedAction(context,state,identifier,instantiatedType,as,property,options)}function InstantiateCyclics(context,declarations,cyclicKeys){let declarationContext=memory_exports.Assign(context,declarations);return guard_exports.Keys(declarations).filter(key=>cyclicKeys.includes(key)).reduce((result,key)=>({...result,[key]:InstantiateCyclic(declarationContext,key,declarations[key])}),{})}function InstantiateNonCyclics(context,declarations,cyclicKeys){let declarationContext=memory_exports.Assign(context,declarations);return guard_exports.Keys(declarations).filter(key=>!cyclicKeys.includes(key)).reduce((result,key)=>({...result,[key]:InstantiateType(declarationContext,State([],[]),declarations[key])}),{})}function InstantiateModule(context,declarations,options){let cyclicCandidates=CyclicCandidates(declarations),instantiatedCyclics=InstantiateCyclics(context,declarations,cyclicCandidates),instantiatedNonCyclics=InstantiateNonCyclics(context,declarations,cyclicCandidates),instantiatedModule={...instantiatedCyclics,...instantiatedNonCyclics};return memory_exports.Update(instantiatedModule,{},options)}function ModuleInstantiate(context,_state,declarations,options){return InstantiateModule(context,declarations,options)}function NonNullableDeferred(type,options={}){return Deferred("NonNullable",[type],options)}function NonNullable(type,options={}){return NonNullableAction(type,options)}function NonNullableOperation(type){let excluded=Union([Null(),Undefined()]);return ExcludeAction(type,excluded,{})}function NonNullableAction(type,options){return CanInstantiate([type])?memory_exports.Update(NonNullableOperation(type),{},options):NonNullableDeferred(type,options)}function NonNullableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return NonNullableAction(instantiatedType,options)}function OmitDeferred(type,indexer,options={}){return Deferred("Omit",[type,indexer],options)}function Omit(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return OmitAction(type,indexer,options)}function ToIndexable(type){let collapsed=CollapseToObject(type);return IsObject3(collapsed)?collapsed.properties:Unreachable()}function FromKeys(properties,keys){return guard_exports.Keys(properties).reduce((result2,key)=>keys.includes(key)?result2:{...result2,[key]:properties[key]},{})}function FromType14(type,indexer){let indexable=ToIndexable(type),indexableKeys=ToIndexableKeys(indexer),omitted=FromKeys(indexable,indexableKeys);return _Object_(omitted)}function OmitAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType14(type,indexer),{},options):OmitDeferred(type,indexer,options)}function OmitInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return OmitAction(instantiatedType,instantiatedIndexer,options)}function ParametersDeferred(type,options={}){return Deferred("Parameters",[type],options)}function Parameters(type,options={}){return ParametersAction(type,options)}function ParametersOperation(type){let parameters=IsFunction3(type)?type.parameters:[],instantiatedParameters=InstantiateElements({},State([],[]),parameters);return Tuple(instantiatedParameters)}function ParametersAction(type,options){return CanInstantiate([type])?memory_exports.Update(ParametersOperation(type),{},options):ParametersDeferred(type,options)}function ParametersInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ParametersAction(instantiatedType,options)}function PartialDeferred(type,options={}){return Deferred("Partial",[type],options)}function Partial(type,options={}){return PartialAction(type,options)}function FromCyclic3(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType15(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent3(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType15(evaluated)}function FromIntersect3(types){let evaluated=EvaluateIntersect(types);return FromType15(evaluated)}function FromUnion6(types){let result=types.map(type=>FromType15(type));return Union(result)}function FromObject7(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:AddOptional(properties[left])}),{});return _Object_(mapped)}function FromType15(type){return IsCyclic(type)?FromCyclic3(type.$defs,type.$ref):IsDependent(type)?FromDependent3(type.if,type.then,type.else):IsIntersect(type)?FromIntersect3(type.allOf):IsUnion(type)?FromUnion6(type.anyOf):IsObject3(type)?FromObject7(type.properties):_Object_({})}function PartialAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType15(type),{},options):PartialDeferred(type,options)}function PartialInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return PartialAction(instantiatedType,options)}function PickDeferred(type,indexer,options={}){return Deferred("Pick",[type,indexer],options)}function Pick(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return PickAction(type,indexer,options)}function FromKeys2(properties,keys){return guard_exports.Keys(properties).reduce((result2,key)=>keys.includes(key)?memory_exports.Assign(result2,{[key]:properties[key]}):result2,{})}function FromType16(type,indexer){let indexable=ToIndexable(type),keys=ToIndexableKeys(indexer),applied=FromKeys2(indexable,keys);return _Object_(applied)}function PickAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType16(type,indexer),{},options):PickDeferred(type,indexer,options)}function PickInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return PickAction(instantiatedType,instantiatedIndexer,options)}function ReadonlyObjectDeferred(type,options={}){return Deferred("ReadonlyObject",[type],options)}function ReadonlyObject(type,options={}){return ReadonlyObjectAction(type,options)}var ReadonlyType=ReadonlyObject;function FromArray5(type){return AddImmutable(_Array_(type))}function FromCyclic4(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType17(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent4(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType17(evaluated)}function FromIntersect4(types){let evaluated=EvaluateIntersect(types);return FromType17(evaluated)}function FromObject8(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:AddReadonly(properties[left])}),{});return _Object_(mapped)}function FromTuple4(types){return AddImmutable(Tuple(types))}function FromUnion7(types){let result=types.map(type=>FromType17(type));return Union(result)}function FromType17(type){return IsArray3(type)?FromArray5(type.items):IsCyclic(type)?FromCyclic4(type.$defs,type.$ref):IsDependent(type)?FromDependent4(type.if,type.then,type.else):IsIntersect(type)?FromIntersect4(type.allOf):IsObject3(type)?FromObject8(type.properties):IsTuple(type)?FromTuple4(type.items):IsUnion(type)?FromUnion7(type.anyOf):type}function ReadonlyObjectAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType17(type),{},options):ReadonlyObjectDeferred(type)}function ReadonlyObjectInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ReadonlyObjectAction(instantiatedType,options)}function RefInstantiate(context,state,type,ref){return state.visited.includes(ref)?type:ref in context?InstantiateType(context,State(state.callstack,[...state.visited,ref]),context[ref]):type}function FromCyclic5(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType18(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent5(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType18(evaluated)}function FromIntersect5(types){let evaluated=EvaluateIntersect(types);return FromType18(evaluated)}function FromUnion8(types){let result=types.map(type=>FromType18(type));return Union(result)}function FromObject9(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:RemoveOptional(properties[left])}),{});return _Object_(mapped)}function FromType18(type){return IsCyclic(type)?FromCyclic5(type.$defs,type.$ref):IsDependent(type)?FromDependent5(type.if,type.then,type.else):IsIntersect(type)?FromIntersect5(type.allOf):IsUnion(type)?FromUnion8(type.anyOf):IsObject3(type)?FromObject9(type.properties):_Object_({})}function RequiredDeferred(type,options={}){return Deferred("Required",[type],options)}function Required(type,options={}){return RequiredAction(type,options)}function RequiredAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType18(type),{},options):RequiredDeferred(type,options)}function RequiredInstantiate(context,state,type,options){let instaniatedType=InstantiateType(context,state,type);return RequiredAction(instaniatedType,options)}function ReturnTypeDeferred(type,options={}){return Deferred("ReturnType",[type],options)}function ReturnType(type,options={}){return ReturnTypeAction(type,options)}function ReturnTypeOperation(type){return IsFunction3(type)?type.returnType:Never()}function ReturnTypeAction(type,options){return CanInstantiate([type])?memory_exports.Update(ReturnTypeOperation(type),{},options):ReturnTypeDeferred(type,options)}function ReturnTypeInstantiate(context,state,type,options={}){let instantiatedType=InstantiateType(context,state,type);return ReturnTypeAction(instantiatedType,options)}function WithDeferred(type,options){return Deferred("With",[type,options],{})}function With2(type,options){return WithAction(type,options)}function WithAction(type,options){return CanInstantiate([type])?memory_exports.Update(type,{},options):WithDeferred(type,options)}function WithInstantiate(context,state,type,options){let instaniatedType=InstantiateType(context,state,type);return WithAction(instaniatedType,options)}function SpreadElement(type){return IsRest(type)?IsTuple(type.items)?RestSpread(type.items.items):IsInfer(type.items)?[type]:IsRef(type.items)?[type]:[Never()]:[type]}function RestSpread(types){return types.reduce((result2,left)=>[...result2,...SpreadElement(left)],[])}function State(callstack,visited){return{callstack,visited}}function CanInstantiate(types){return guard_exports.ShiftLeft(types,(left,right)=>IsRef(left)?!1:CanInstantiate(right),()=>!0)}function InstantiateProperties(context,state,properties){return guard_exports.Keys(properties).reduce((result,key)=>({...result,[key]:InstantiateType(context,state,properties[key])}),{})}function InstantiateElements(context,state,types){let elements=InstantiateTypes(context,state,types);return RestSpread(elements)}function InstantiateTypes(context,state,types){return types.map(type=>InstantiateType(context,state,type))}function WithModifiers(type,instantiatedType){let withOptional=IsOptional(type)?AddOptionalAction(instantiatedType,{}):instantiatedType,withReadonly=IsReadonly(type)?AddReadonlyAction(withOptional,{}):withOptional;return IsImmutable(type)?AddImmutableAction(withReadonly,{}):withReadonly}function InstantiateDeferred(context,state,action,parameters,options){return guard_exports.IsEqual(action,"AddImmutable")?AddImmutableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveImmutable")?RemoveImmutableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"AddReadonly")?AddReadonlyInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveReadonly")?RemoveReadonlyInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"AddOptional")?AddOptionalInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveOptional")?RemoveOptionalInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Capitalize")?CapitalizeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Conditional")?ConditionalInstantiate(context,state,parameters[0],parameters[1],parameters[2],parameters[3],options):guard_exports.IsEqual(action,"ConstructorParameters")?ConstructorParametersInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Evaluate")?EvaluateInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Exclude")?ExcludeInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Extract")?ExtractInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Index")?IndexInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"InstanceType")?InstanceTypeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Interface")?InterfaceInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"KeyOf")?KeyOfInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Lowercase")?LowercaseInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Mapped")?MappedInstantiate(context,state,parameters[0],parameters[1],parameters[2],parameters[3],options):guard_exports.IsEqual(action,"Module")?ModuleInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"NonNullable")?NonNullableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Pick")?PickInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Parameters")?ParametersInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Partial")?PartialInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Omit")?OmitInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"ReadonlyObject")?ReadonlyObjectInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Record")?RecordInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Required")?RequiredInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"ReturnType")?ReturnTypeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"TemplateLiteral")?TemplateLiteralInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Uncapitalize")?UncapitalizeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Uppercase")?UppercaseInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"With")?WithInstantiate(context,state,parameters[0],parameters[1]):Deferred(action,parameters,options)}function InstantiateImmediate(context,state,type){let instantiatedType=IsRef(type)?RefInstantiate(context,state,type,type.$ref):IsArray3(type)?_Array_(InstantiateType(context,state,type.items),ArrayOptions(type)):IsCall(type)?CallInstantiate(context,state,type.target,type.arguments):IsConstructor3(type)?Constructor(InstantiateTypes(context,state,type.parameters),InstantiateType(context,state,type.instanceType),ConstructorOptions(type)):IsFunction3(type)?_Function_(InstantiateTypes(context,state,type.parameters),InstantiateType(context,state,type.returnType),FunctionOptions(type)):IsDependent(type)?Dependent(InstantiateType(context,state,type.if),InstantiateType(context,state,type.then),InstantiateType(context,state,type.else),DependentOptions(type)):IsIntersect(type)?Intersect(InstantiateTypes(context,state,type.allOf),IntersectOptions(type)):IsObject3(type)?_Object_(InstantiateProperties(context,state,type.properties),ObjectOptions(type)):IsRecord(type)?RecordFromPattern(RecordPattern(type),InstantiateType(context,state,RecordValue(type))):IsRest(type)?Rest(InstantiateType(context,state,type.items)):IsTuple(type)?Tuple(InstantiateElements(context,state,type.items),TupleOptions(type)):IsUnion(type)?Union(InstantiateTypes(context,state,type.anyOf),UnionOptions(type)):type;return WithModifiers(type,instantiatedType)}function InstantiateType(context,state,type){return IsDeferred(type)?InstantiateDeferred(context,state,type.action,type.parameters,type.options):InstantiateImmediate(context,state,type)}function Instantiate(context,type){return InstantiateType(context,State([],[]),type)}function AddImmutableOperation(type){return memory_exports.Update(type,{"~immutable":!0},{})}function AddImmutableAction(type,options){return memory_exports.Update(AddImmutableOperation(type),{},options)}function AddImmutableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return AddImmutableAction(instantiatedType,options)}function AddImmutableDeferred(type,options={}){return Deferred("AddImmutable",[type],options)}function AddImmutable(type,options={}){return AddImmutableAction(type,options)}function RemoveImmutableDeferred(type,options={}){return Deferred("RemoveImmutable",[type],options)}function RemoveImmutable(type,options={}){return RemoveImmutableAction(type,options)}function EvaluateDeferred(type,options={}){return Deferred("Evaluate",[type],options)}function Evaluate2(type,options={}){return EvaluateAction(type,options)}function ModuleDeferred(declarations,options={}){return Deferred("Module",[declarations],options)}function Module2(declarations,options={}){return ModuleInstantiate({},State([],[]),declarations,options)}function Comparer(left,right){let compareResult=Compare(left,right);return guard_exports.IsEqual(compareResult,CompareResultRightInside)||guard_exports.IsEqual(compareResult,CompareResultDisjoint)?1:0}function Insert(type,types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>guard_exports.IsEqual(Comparer(type,left),1)?Insert(type,right,[...result,left]):[...result,type,...types],()=>[...result,type])}function Sort(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>Sort(right,Insert(left,result)),()=>result)}function Priority(types){return Sort(types)}function IsTemplateLiteralPattern(pattern){let types=ParsePatternIntoTypes(pattern);return!guard_exports.IsEqual(types.length,0)}function Script2(...args){let[context,input,options]=arguments_exports.Match(args,{2:(script,options2)=>guard_exports.IsString(script)?[{},script,options2]:[script,options2,{}],3:(context2,script,options2)=>[context2,script,options2],1:script=>[{},script,{}]}),result=Script(input),parsed=guard_exports.IsArray(result)&&guard_exports.IsEqual(result.length,2)?InstantiateType(context,State([],[]),result[0]):Never();return memory_exports.Update(parsed,{},options)}var typebox_exports={};__export(typebox_exports,{Any:()=>Any,Array:()=>_Array_,BigInt:()=>BigInt2,Boolean:()=>Boolean2,Call:()=>Call2,Capitalize:()=>Capitalize,Codec:()=>Codec,Conditional:()=>Conditional,Constructor:()=>Constructor,ConstructorParameters:()=>ConstructorParameters,Cyclic:()=>Cyclic,Decode:()=>Decode,DecodeBuilder:()=>DecodeBuilder,Dependent:()=>Dependent,Encode:()=>Encode,EncodeBuilder:()=>EncodeBuilder,Enum:()=>Enum,Evaluate:()=>Evaluate2,Exclude:()=>Exclude,Extends:()=>Extends,ExtendsResult:()=>result_exports,Extract:()=>Extract,Function:()=>_Function_,Generic:()=>Generic,Identifier:()=>Identifier,Immutable:()=>Immutable,Index:()=>Index,Infer:()=>Infer,InstanceType:()=>InstanceType,Instantiate:()=>Instantiate,Integer:()=>Integer,Interface:()=>Interface,Intersect:()=>Intersect,IsAny:()=>IsAny,IsArray:()=>IsArray3,IsBigInt:()=>IsBigInt3,IsBoolean:()=>IsBoolean4,IsCall:()=>IsCall,IsCodec:()=>IsCodec,IsConstructor:()=>IsConstructor3,IsCyclic:()=>IsCyclic,IsDependent:()=>IsDependent,IsEnum:()=>IsEnum,IsEnumValue:()=>IsEnumValue,IsFunction:()=>IsFunction3,IsGeneric:()=>IsGeneric,IsIdentifier:()=>IsIdentifier2,IsImmutable:()=>IsImmutable,IsInfer:()=>IsInfer,IsInteger:()=>IsInteger3,IsIntersect:()=>IsIntersect,IsKind:()=>IsKind,IsLiteral:()=>IsLiteral,IsNever:()=>IsNever,IsNull:()=>IsNull3,IsNumber:()=>IsNumber4,IsObject:()=>IsObject3,IsOptional:()=>IsOptional,IsParameter:()=>IsParameter,IsReadonly:()=>IsReadonly,IsRecord:()=>IsRecord,IsRef:()=>IsRef,IsRefine:()=>IsRefine,IsRest:()=>IsRest,IsSchema:()=>IsSchema,IsString:()=>IsString4,IsSymbol:()=>IsSymbol3,IsTemplateLiteral:()=>IsTemplateLiteral,IsThis:()=>IsThis,IsTuple:()=>IsTuple,IsUndefined:()=>IsUndefined3,IsUnion:()=>IsUnion,IsUnknown:()=>IsUnknown,IsUnsafe:()=>IsUnsafe,IsVoid:()=>IsVoid,KeyOf:()=>KeyOf2,Literal:()=>Literal,Lowercase:()=>Lowercase,Mapped:()=>Mapped,Module:()=>Module2,Never:()=>Never,NonNullable:()=>NonNullable,Null:()=>Null,Number:()=>Number2,Object:()=>_Object_,Omit:()=>Omit,Optional:()=>Optional,Parameter:()=>Parameter,Parameters:()=>Parameters,Partial:()=>Partial,Pick:()=>Pick,Readonly:()=>Readonly,ReadonlyObject:()=>ReadonlyObject,ReadonlyType:()=>ReadonlyType,Record:()=>Record,RecordKey:()=>RecordKey,RecordPattern:()=>RecordPattern,RecordValue:()=>RecordValue,Ref:()=>Ref,Refine:()=>Refine,Required:()=>Required,Rest:()=>Rest,ReturnType:()=>ReturnType,Script:()=>Script2,String:()=>String2,Symbol:()=>Symbol,TemplateLiteral:()=>TemplateLiteral2,This:()=>This,Tuple:()=>Tuple,Uncapitalize:()=>Uncapitalize,Undefined:()=>Undefined,Union:()=>Union,Unknown:()=>Unknown,Unsafe:()=>Unsafe,Uppercase:()=>Uppercase,Void:()=>Void,With:()=>With2});var build_default=typebox_exports;function buildProviderErrorPattern(patterns){return new RegExp(patterns.join("|"),"i")}var NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN=buildProviderErrorPattern(["GoUsageLimitError","FreeUsageLimitError","Monthly usage limit reached","available balance","insufficient_quota","out of budget","quota exceeded","billing","subscription_sharing_usage_limit_exceeded","subscription_sharing_workplace_individual_usage_limit_exceeded",'"code"\\s*:\\s*"?1308(?![0-9])']),RETRYABLE_PROVIDER_ERROR_PATTERN=buildProviderErrorPattern(["overloaded","server_busy","servers are currently busy","currently experiencing high demand","model is at capacity","rate.?limit","too many requests","(?<![a-z0-9])(?:429|500|502|503|504|520|524)(?![a-z0-9])","service.?(?:is.?)?(?:temporarily.?)?unavailable","server.?error","internal.?error","provider.?returned.?(?:an.?)?error","exceeded request buffer limit while retrying upstream","unable to forward upstream","upstream.?request.?failed","upstream_stream_read_error","stream was interrupted","http/?2 stream failed","network.?error","connection.?error","connection.?refused","connection.?lost","other side closed","fetch failed","request to \\S+ failed, reason:","getaddrinfo","ENOTFOUND","EAI_AGAIN","upstream.?connect","reset before headers","socket hang up","socket connection was closed","timed? out","timeout","terminated","websocket.?closed","websocket.?error","ended without","stream ended before message_stop","stream ended before a terminal response event","http2 request did not get a response","stream disconnected before completion","cut short after the reply had begun","pending stream has been canceled","retry delay","you can retry your request","try your request again","please retry your request","ResourceExhausted","subscription_sharing_usage_unavailable","subscription_sharing_user_unavailable"]),DEFAULT_MAX_AGENT_RETRY_DELAY_MS=6e4;function retryDelayMs(policy,attempt){let delay=policy.baseDelayMs*2**Math.max(0,attempt-1),safeDelay=Number.isSafeInteger(delay)?delay:Number.MAX_SAFE_INTEGER;return Math.min(safeDelay,policy.maxAgentDelayMs??DEFAULT_MAX_AGENT_RETRY_DELAY_MS)}var RetrySleepAbortError=class extends Error{constructor(){super("Aborted")}};function sleep(ms,signal){return new Promise((resolve,reject)=>{if(signal?.aborted){reject(new RetrySleepAbortError);return}let timeout=setTimeout(resolve,ms);signal?.addEventListener("abort",()=>{clearTimeout(timeout),reject(new RetrySleepAbortError)},{once:!0})})}async function retryAssistantCall(produce,policy,signal,callbacks){let maxAttempts=policy?.enabled?policy.maxRetries:0,attempt=0,lastRetry;for(;;){let response=await produce();if(response.stopReason==="aborted")return lastRetry&&await callbacks?.onRetryFinished?.(!1,lastRetry.attempt),response;if(response.stopReason!=="error")return lastRetry&&await callbacks?.onRetryFinished?.(!0,lastRetry.attempt),response;if(attempt>=maxAttempts||!isRetryableAssistantError(response))return lastRetry&&await callbacks?.onRetryFinished?.(!1,lastRetry.attempt,response.errorMessage),response;attempt++,lastRetry={attempt,errorMessage:response.errorMessage||"Unknown error"};let delayMs=retryDelayMs(policy,attempt);await callbacks?.onRetryScheduled?.(attempt,maxAttempts,delayMs,lastRetry.errorMessage);try{await sleep(delayMs,signal)}catch(error){if(await callbacks?.onRetryFinished?.(!1,attempt,lastRetry.errorMessage),error instanceof RetrySleepAbortError){let{errorMessage:_errorMessage,...rest}=response;return{...rest,stopReason:"aborted"}}throw error}await callbacks?.onRetryAttemptStart?.()}}function isRetryableAssistantError(message){if(message.stopReason!=="error"||!message.errorMessage)return!1;let errorMessage=message.errorMessage;return NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)?!1:RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage)}export{DEFAULT_MAX_AGENT_RETRY_DELAY_MS,retryDelayMs,retryAssistantCall,isRetryableAssistantError,guard_exports,emit_exports,globals_exports,guard_default,settings_exports,Clone,IsSchema,_Array_,IsArray3 as IsArray,ArrayOptions,IsConstructor3 as IsConstructor,IsFunction3 as IsFunction,Ref,IsRef,IsNever,IsOptional,_Object_,IsObject3 as IsObject,Unknown,IsCyclic,arguments_exports,IsEnum,Intersect,IsIntersect,environment_exports,Unreachable,hash_exports,Get2 as Get,IsCodec,IsRefine,IsBigInt3 as IsBigInt,IsBoolean4 as IsBoolean,IsInteger3 as IsInteger,Literal,IsLiteralBigInt,IsLiteralBoolean,IsLiteralNumber,IsLiteralString,IsLiteral,IsNull3 as IsNull,IsNumber4 as IsNumber,IsSymbol3 as IsSymbol,String2 as String,IsString4 as IsString,Union,IsUnion,TemplateLiteralDecode,Tuple,IsTuple,Flatten,Record,RecordPattern,RecordKey,RecordValue,IsRecord,IsUndefined3 as IsUndefined,IsVoid,IsTemplateLiteral,With2 as With,Instantiate,Evaluate2 as Evaluate,Priority,typebox_exports,build_exports};