typebox 1.0.31 → 1.0.33

package/build/cjs/type/script/mapping.js

@@ -0,0 +1,644 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericParameterExtendsEqualsMapping = GenericParameterExtendsEqualsMapping;
+exports.GenericParameterExtendsMapping = GenericParameterExtendsMapping;
+exports.GenericParameterEqualsMapping = GenericParameterEqualsMapping;
+exports.GenericParameterIdentifierMapping = GenericParameterIdentifierMapping;
+exports.GenericParameterMapping = GenericParameterMapping;
+exports.GenericParameterListMapping = GenericParameterListMapping;
+exports.GenericParametersMapping = GenericParametersMapping;
+exports.GenericCallArgumentListMapping = GenericCallArgumentListMapping;
+exports.GenericCallArgumentsMapping = GenericCallArgumentsMapping;
+exports.GenericCallMapping = GenericCallMapping;
+exports.KeywordStringMapping = KeywordStringMapping;
+exports.KeywordNumberMapping = KeywordNumberMapping;
+exports.KeywordBooleanMapping = KeywordBooleanMapping;
+exports.KeywordUndefinedMapping = KeywordUndefinedMapping;
+exports.KeywordNullMapping = KeywordNullMapping;
+exports.KeywordIntegerMapping = KeywordIntegerMapping;
+exports.KeywordBigIntMapping = KeywordBigIntMapping;
+exports.KeywordUnknownMapping = KeywordUnknownMapping;
+exports.KeywordAnyMapping = KeywordAnyMapping;
+exports.KeywordObjectMapping = KeywordObjectMapping;
+exports.KeywordNeverMapping = KeywordNeverMapping;
+exports.KeywordSymbolMapping = KeywordSymbolMapping;
+exports.KeywordVoidMapping = KeywordVoidMapping;
+exports.KeywordThisMapping = KeywordThisMapping;
+exports.KeywordMapping = KeywordMapping;
+exports.TemplateInterpolateMapping = TemplateInterpolateMapping;
+exports.TemplateSpanMapping = TemplateSpanMapping;
+exports.TemplateBodyMapping = TemplateBodyMapping;
+exports.TemplateLiteralTypesMapping = TemplateLiteralTypesMapping;
+exports.TemplateLiteralMapping = TemplateLiteralMapping;
+exports.LiteralBigIntMapping = LiteralBigIntMapping;
+exports.LiteralBooleanMapping = LiteralBooleanMapping;
+exports.LiteralNumberMapping = LiteralNumberMapping;
+exports.LiteralStringMapping = LiteralStringMapping;
+exports.LiteralMapping = LiteralMapping;
+exports.KeyOfMapping = KeyOfMapping;
+exports.IndexArrayMapping = IndexArrayMapping;
+exports.ExtendsMapping = ExtendsMapping;
+exports.BaseMapping = BaseMapping;
+exports.FactorMapping = FactorMapping;
+exports.ExprTermTailMapping = ExprTermTailMapping;
+exports.ExprTermMapping = ExprTermMapping;
+exports.ExprTailMapping = ExprTailMapping;
+exports.ExprMapping = ExprMapping;
+exports.ExprPipeMapping = ExprPipeMapping;
+exports.GenericTypeMapping = GenericTypeMapping;
+exports.InferTypeMapping = InferTypeMapping;
+exports.TypeMapping = TypeMapping;
+exports.PropertyKeyNumberMapping = PropertyKeyNumberMapping;
+exports.PropertyKeyIdentMapping = PropertyKeyIdentMapping;
+exports.PropertyKeyQuotedMapping = PropertyKeyQuotedMapping;
+exports.PropertyKeyIndexMapping = PropertyKeyIndexMapping;
+exports.PropertyKeyMapping = PropertyKeyMapping;
+exports.ReadonlyMapping = ReadonlyMapping;
+exports.OptionalMapping = OptionalMapping;
+exports.PropertyMapping = PropertyMapping;
+exports.PropertyDelimiterMapping = PropertyDelimiterMapping;
+exports.PropertyListMapping = PropertyListMapping;
+exports.PropertiesMapping = PropertiesMapping;
+exports._Object_Mapping = _Object_Mapping;
+exports.ElementNamedMapping = ElementNamedMapping;
+exports.ElementReadonlyOptionalMapping = ElementReadonlyOptionalMapping;
+exports.ElementReadonlyMapping = ElementReadonlyMapping;
+exports.ElementOptionalMapping = ElementOptionalMapping;
+exports.ElementBaseMapping = ElementBaseMapping;
+exports.ElementMapping = ElementMapping;
+exports.ElementListMapping = ElementListMapping;
+exports.TupleMapping = TupleMapping;
+exports.ParameterReadonlyOptionalMapping = ParameterReadonlyOptionalMapping;
+exports.ParameterReadonlyMapping = ParameterReadonlyMapping;
+exports.ParameterOptionalMapping = ParameterOptionalMapping;
+exports.ParameterTypeMapping = ParameterTypeMapping;
+exports.ParameterBaseMapping = ParameterBaseMapping;
+exports.ParameterMapping = ParameterMapping;
+exports.ParameterListMapping = ParameterListMapping;
+exports.FunctionMapping = FunctionMapping;
+exports.ConstructorMapping = ConstructorMapping;
+exports.MappedReadonlyMapping = MappedReadonlyMapping;
+exports.MappedOptionalMapping = MappedOptionalMapping;
+exports.MappedAsMapping = MappedAsMapping;
+exports.MappedMapping = MappedMapping;
+exports.ReferenceMapping = ReferenceMapping;
+exports.OptionsMapping = OptionsMapping;
+exports.JsonNumberMapping = JsonNumberMapping;
+exports.JsonBooleanMapping = JsonBooleanMapping;
+exports.JsonStringMapping = JsonStringMapping;
+exports.JsonNullMapping = JsonNullMapping;
+exports.JsonPropertyMapping = JsonPropertyMapping;
+exports.JsonPropertyListMapping = JsonPropertyListMapping;
+exports.JsonObjectMapping = JsonObjectMapping;
+exports.JsonElementListMapping = JsonElementListMapping;
+exports.JsonArrayMapping = JsonArrayMapping;
+exports.JsonMapping = JsonMapping;
+exports.PatternBigIntMapping = PatternBigIntMapping;
+exports.PatternStringMapping = PatternStringMapping;
+exports.PatternNumberMapping = PatternNumberMapping;
+exports.PatternIntegerMapping = PatternIntegerMapping;
+exports.PatternNeverMapping = PatternNeverMapping;
+exports.PatternTextMapping = PatternTextMapping;
+exports.PatternBaseMapping = PatternBaseMapping;
+exports.PatternGroupMapping = PatternGroupMapping;
+exports.PatternUnionMapping = PatternUnionMapping;
+exports.PatternTermMapping = PatternTermMapping;
+exports.PatternBodyMapping = PatternBodyMapping;
+exports.PatternMapping = PatternMapping;
+exports.InterfaceDeclarationHeritageListMapping = InterfaceDeclarationHeritageListMapping;
+exports.InterfaceDeclarationHeritageMapping = InterfaceDeclarationHeritageMapping;
+exports.InterfaceDeclarationGenericMapping = InterfaceDeclarationGenericMapping;
+exports.InterfaceDeclarationMapping = InterfaceDeclarationMapping;
+exports.TypeAliasDeclarationGenericMapping = TypeAliasDeclarationGenericMapping;
+exports.TypeAliasDeclarationMapping = TypeAliasDeclarationMapping;
+exports.ExportKeywordMapping = ExportKeywordMapping;
+exports.ModuleDeclarationDelimiterMapping = ModuleDeclarationDelimiterMapping;
+exports.ModuleDeclarationListMapping = ModuleDeclarationListMapping;
+exports.ModuleDeclarationMapping = ModuleDeclarationMapping;
+exports.ModuleMapping = ModuleMapping;
+exports.ScriptMapping = ScriptMapping;
+const index_1 = require("../../system/memory/index");
+const index_2 = require("../../guard/index");
+const C = require("../action/index");
+const T = require("../types/index");
+function IntrinsicOrCall(ref, parameters) {
+    // deno-coverage-ignore-start
+    //
+    // Have extensively tested but reports show no Omit coverage (review)
+    return (index_2.Guard.IsEqual(ref, 'Array') ? T.Array(parameters[0]) :
+        index_2.Guard.IsEqual(ref, 'AsyncIterator') ? T.AsyncIterator(parameters[0]) :
+            index_2.Guard.IsEqual(ref, 'Iterator') ? T.Iterator(parameters[0]) :
+                index_2.Guard.IsEqual(ref, 'Promise') ? T.Promise(parameters[0]) :
+                    index_2.Guard.IsEqual(ref, 'Awaited') ? C.AwaitedDeferred(parameters[0]) :
+                        index_2.Guard.IsEqual(ref, 'Capitalize') ? C.CapitalizeDeferred(parameters[0]) :
+                            index_2.Guard.IsEqual(ref, 'ConstructorParameters') ? C.ConstructorParametersDeferred(parameters[0]) :
+                                index_2.Guard.IsEqual(ref, 'Evaluate') ? C.EvaluateDeferred(parameters[0]) :
+                                    index_2.Guard.IsEqual(ref, 'Exclude') ? C.ExcludeDeferred(parameters[0], parameters[1]) :
+                                        index_2.Guard.IsEqual(ref, 'Extract') ? C.ExtractDeferred(parameters[0], parameters[1]) :
+                                            index_2.Guard.IsEqual(ref, 'Index') ? C.IndexDeferred(parameters[0], parameters[1]) :
+                                                index_2.Guard.IsEqual(ref, 'InstanceType') ? C.InstanceTypeDeferred(parameters[0]) :
+                                                    index_2.Guard.IsEqual(ref, 'Lowercase') ? C.LowercaseDeferred(parameters[0]) :
+                                                        index_2.Guard.IsEqual(ref, 'NonNullable') ? C.NonNullableDeferred(parameters[0]) :
+                                                            index_2.Guard.IsEqual(ref, 'Omit') ? C.OmitDeferred(parameters[0], parameters[1]) :
+                                                                index_2.Guard.IsEqual(ref, 'Options') ? C.OptionsDeferred(parameters[0], parameters[1]) :
+                                                                    index_2.Guard.IsEqual(ref, 'Parameters') ? C.ParametersDeferred(parameters[0]) :
+                                                                        index_2.Guard.IsEqual(ref, 'Partial') ? C.PartialDeferred(parameters[0]) :
+                                                                            index_2.Guard.IsEqual(ref, 'Pick') ? C.PickDeferred(parameters[0], parameters[1]) :
+                                                                                index_2.Guard.IsEqual(ref, 'KeyOf') ? C.KeyOfDeferred(parameters[0]) :
+                                                                                    index_2.Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
+                                                                                        index_2.Guard.IsEqual(ref, 'Required') ? C.RequiredDeferred(parameters[0]) :
+                                                                                            index_2.Guard.IsEqual(ref, 'ReturnType') ? C.ReturnTypeDeferred(parameters[0]) :
+                                                                                                index_2.Guard.IsEqual(ref, 'Uncapitalize') ? C.UncapitalizeDeferred(parameters[0]) :
+                                                                                                    index_2.Guard.IsEqual(ref, 'Uppercase') ? C.UppercaseDeferred(parameters[0]) :
+                                                                                                        T.CallConstruct(T.Ref(ref), parameters));
+    // deno-coverage-ignore-stop
+}
+// ------------------------------------------------------------------
+// Unreachable
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start
+function Unreachable() {
+    throw Error('Unreachable');
+}
+const DelimitedDecode = (input, result = []) => {
+    return input.reduce((result, left) => {
+        return index_2.Guard.IsArray(left) && index_2.Guard.IsEqual(left.length, 2)
+            ? [...result, left[0]]
+            : [...result, left];
+    }, []);
+};
+const Delimited = (input) => {
+    const [left, right] = input;
+    return DelimitedDecode([...left, ...right]);
+};
+function GenericParameterExtendsEqualsMapping(input) {
+    return T.Parameter(input[0], input[2], input[4]);
+}
+function GenericParameterExtendsMapping(input) {
+    return T.Parameter(input[0], input[2], input[2]);
+}
+function GenericParameterEqualsMapping(input) {
+    return T.Parameter(input[0], T.Unknown(), input[2]);
+}
+function GenericParameterIdentifierMapping(input) {
+    return T.Parameter(input, T.Unknown(), T.Unknown());
+}
+function GenericParameterMapping(input) {
+    return input;
+}
+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 KeywordStringMapping(input) {
+    return T.String();
+}
+function KeywordNumberMapping(input) {
+    return T.Number();
+}
+function KeywordBooleanMapping(input) {
+    return T.Boolean();
+}
+function KeywordUndefinedMapping(input) {
+    return T.Undefined();
+}
+function KeywordNullMapping(input) {
+    return T.Null();
+}
+function KeywordIntegerMapping(input) {
+    return T.Integer();
+}
+function KeywordBigIntMapping(input) {
+    return T.BigInt();
+}
+function KeywordUnknownMapping(input) {
+    return T.Unknown();
+}
+function KeywordAnyMapping(input) {
+    return T.Any();
+}
+function KeywordObjectMapping(input) {
+    return T.Object({});
+}
+function KeywordNeverMapping(input) {
+    return T.Never();
+}
+function KeywordSymbolMapping(input) {
+    return T.Symbol();
+}
+function KeywordVoidMapping(input) {
+    return T.Void();
+}
+function KeywordThisMapping(input) {
+    return T.This();
+}
+function KeywordMapping(input) {
+    return input;
+}
+function TemplateInterpolateMapping(input) {
+    return input[1];
+}
+function TemplateSpanMapping(input) {
+    return T.Literal(input);
+}
+function TemplateBodyMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 3)
+        ? [input[0], input[1], ...input[2]]
+        : [input[0]]);
+}
+function TemplateLiteralTypesMapping(input) {
+    return input[1];
+}
+function TemplateLiteralMapping(input) {
+    return T.TemplateLiteralDeferred(input);
+}
+function LiteralBigIntMapping(input) {
+    return T.Literal(BigInt(input));
+}
+function LiteralBooleanMapping(input) {
+    return T.Literal(index_2.Guard.IsEqual(input, 'true'));
+}
+function LiteralNumberMapping(input) {
+    return T.Literal(parseFloat(input));
+}
+function LiteralStringMapping(input) {
+    return T.Literal(input);
+}
+function LiteralMapping(input) {
+    return input;
+}
+function KeyOfMapping(input) {
+    return input.length > 0;
+}
+function IndexArrayMapping(input) {
+    return input.reduce((result, current) => {
+        return index_2.Guard.IsEqual(current.length, 3)
+            ? [...result, [current[1]]]
+            : [...result, []];
+    }, []);
+}
+function ExtendsMapping(input) {
+    return index_2.Guard.IsEqual(input.length, 6)
+        ? [input[1], input[3], input[5]]
+        : [];
+}
+function BaseMapping(input) {
+    return index_2.Guard.IsArray(input) && index_2.Guard.IsEqual(input.length, 3)
+        ? input[1]
+        : input;
+}
+// deno-coverage-ignore-start
+// ...
+const FactorIndexArray = (Type, indexArray) => {
+    return indexArray.reduceRight((result, right) => {
+        const _right = right;
+        return (index_2.Guard.IsEqual(_right.length, 1) ? C.IndexDeferred(result, _right[0]) :
+            index_2.Guard.IsEqual(_right.length, 0) ? T.Array(result) :
+                Unreachable());
+    }, Type);
+};
+// deno-coverage-ignore-stop
+const FactorExtends = (type, extend) => {
+    return index_2.Guard.IsEqual(extend.length, 3)
+        ? C.ConditionalDeferred(type, extend[0], extend[1], extend[2])
+        : type;
+};
+function FactorMapping(input) {
+    const [keyOf, type, indexArray, extend] = input;
+    return keyOf
+        ? FactorExtends(C.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
+        : FactorExtends(FactorIndexArray(type, indexArray), extend);
+}
+// deno-coverage-ignore-start
+function ExprBinaryMapping(left, rest) {
+    return (index_2.Guard.IsEqual(rest.length, 3) ? (() => {
+        const [operator, right, next] = rest;
+        const Schema = ExprBinaryMapping(right, next);
+        if (index_2.Guard.IsEqual(operator, '&')) {
+            return T.IsIntersect(Schema)
+                ? T.Intersect([left, ...Schema.allOf])
+                : T.Intersect([left, Schema]);
+        }
+        if (index_2.Guard.IsEqual(operator, '|')) {
+            return T.IsUnion(Schema)
+                ? T.Union([left, ...Schema.anyOf])
+                : T.Union([left, Schema]);
+        }
+        Unreachable();
+    })() : left);
+}
+function ExprTermTailMapping(input) {
+    return input;
+}
+function ExprTermMapping(input) {
+    const [left, rest] = input;
+    return ExprBinaryMapping(left, rest);
+}
+function ExprTailMapping(input) {
+    return input;
+}
+function ExprMapping(input) {
+    const [left, rest] = input;
+    return ExprBinaryMapping(left, rest);
+}
+function ExprPipeMapping(input) {
+    return input[1];
+}
+function GenericTypeMapping(input) {
+    return T.Generic(input[0], input[2]);
+}
+// deno-coverage-ignore-start
+function InferTypeMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 4) ? T.Infer(input[1], input[3]) :
+        index_2.Guard.IsEqual(input.length, 2) ? T.Infer(input[1], T.Unknown()) :
+            Unreachable());
+}
+function TypeMapping(input) {
+    return input;
+}
+function PropertyKeyNumberMapping(input) {
+    return `${input}`;
+}
+function PropertyKeyIdentMapping(input) {
+    return input;
+}
+function PropertyKeyQuotedMapping(input) {
+    return input;
+}
+// deno-coverage-ignore-start
+function PropertyKeyIndexMapping(input) {
+    return (T.IsInteger(input[3]) ? T.IntegerKey :
+        T.IsNumber(input[3]) ? T.NumberKey :
+            T.IsSymbol(input[3]) ? T.StringKey :
+                T.IsString(input[3]) ? T.StringKey :
+                    Unreachable());
+}
+function PropertyKeyMapping(input) {
+    return input;
+}
+function ReadonlyMapping(input) {
+    return input.length > 0;
+}
+function OptionalMapping(input) {
+    return input.length > 0;
+}
+function PropertyMapping(input) {
+    const [isReadonly, key, isOptional, _colon, type] = input;
+    return {
+        [key]: (isReadonly && isOptional ? T.ReadonlyAdd(T.OptionalAdd(type)) :
+            isReadonly && !isOptional ? T.ReadonlyAdd(type) :
+                !isReadonly && isOptional ? T.OptionalAdd(type) :
+                    type)
+    };
+}
+function PropertyDelimiterMapping(input) {
+    return input;
+}
+function PropertyListMapping(input) {
+    return Delimited(input);
+}
+function PropertiesReduce(propertyList) {
+    return propertyList.reduce((result, left) => {
+        const isPatternProperties = (index_2.Guard.HasPropertyKey(left, T.IntegerKey) || index_2.Guard.HasPropertyKey(left, T.NumberKey) || index_2.Guard.HasPropertyKey(left, T.StringKey));
+        // @ts-ignore 5.0.4 - unable to observe ...left on right arm
+        return (isPatternProperties
+            ? [result[0], index_1.Memory.Assign(result[1], left)]
+            : [index_1.Memory.Assign(result[0], left), result[1]]);
+    }, [{}, {}]);
+}
+function PropertiesMapping(input) {
+    return PropertiesReduce(input[1]);
+}
+function _Object_Mapping(input) {
+    const [properties, patternProperties] = input;
+    const options = index_2.Guard.IsEqual(index_2.Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
+    return T.Object(properties, options);
+}
+// deno-coverage-ignore-start
+function ElementNamedMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 5) ? T.ReadonlyAdd(T.OptionalAdd(input[4])) :
+        index_2.Guard.IsEqual(input.length, 3) ? input[2] :
+            index_2.Guard.IsEqual(input.length, 4) ? (index_2.Guard.IsEqual(input[2], 'readonly') ? T.ReadonlyAdd(input[3]) : T.OptionalAdd(input[3])) :
+                Unreachable());
+}
+function ElementReadonlyOptionalMapping(input) {
+    return T.ReadonlyAdd(T.OptionalAdd(input[1]));
+}
+function ElementReadonlyMapping(input) {
+    return T.ReadonlyAdd(input[1]);
+}
+function ElementOptionalMapping(input) {
+    return T.OptionalAdd(input[0]);
+}
+function ElementBaseMapping(input) {
+    return input;
+}
+// deno-coverage-ignore-start
+function ElementMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 2) ? T.Rest(input[1]) :
+        index_2.Guard.IsEqual(input.length, 1) ? input[0] :
+            Unreachable());
+}
+function ElementListMapping(input) {
+    return Delimited(input);
+}
+function TupleMapping(input) {
+    return T.Tuple(input[1]);
+}
+function ParameterReadonlyOptionalMapping(input) {
+    return T.ReadonlyAdd(T.OptionalAdd(input[4]));
+}
+function ParameterReadonlyMapping(input) {
+    return T.ReadonlyAdd(input[3]);
+}
+function ParameterOptionalMapping(input) {
+    return T.OptionalAdd(input[3]);
+}
+function ParameterTypeMapping(input) {
+    return input[2];
+}
+function ParameterBaseMapping(input) {
+    return input;
+}
+// deno-coverage-ignore-start
+function ParameterMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 2) ? T.Rest(input[1]) :
+        index_2.Guard.IsEqual(input.length, 1) ? input[0] :
+            Unreachable());
+}
+function ParameterListMapping(input) {
+    return Delimited(input);
+}
+function FunctionMapping(input) {
+    return T.Function(input[1], input[4]);
+}
+function ConstructorMapping(input) {
+    return T.Constructor(input[2], input[5]);
+}
+function ApplyReadonly(state, type) {
+    return (index_2.Guard.IsEqual(state, 'remove') ? C.ReadonlyRemoveAction(type) :
+        index_2.Guard.IsEqual(state, 'add') ? C.ReadonlyAddAction(type) :
+            type);
+}
+function MappedReadonlyMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 2) && index_2.Guard.IsEqual(input[0], '-') ? 'remove' :
+        index_2.Guard.IsEqual(input.length, 2) && index_2.Guard.IsEqual(input[0], '+') ? 'add' :
+            index_2.Guard.IsEqual(input.length, 1) ? 'add' :
+                'none');
+}
+function ApplyOptional(state, type) {
+    return (index_2.Guard.IsEqual(state, 'remove') ? C.OptionalRemoveAction(type) :
+        index_2.Guard.IsEqual(state, 'add') ? C.OptionalAddAction(type) :
+            type);
+}
+function MappedOptionalMapping(input) {
+    return (index_2.Guard.IsEqual(input.length, 2) && index_2.Guard.IsEqual(input[0], '-') ? 'remove' :
+        index_2.Guard.IsEqual(input.length, 2) && index_2.Guard.IsEqual(input[0], '+') ? 'add' :
+            index_2.Guard.IsEqual(input.length, 1) ? 'add' :
+                'none');
+}
+function MappedAsMapping(input) {
+    return index_2.Guard.IsEqual(input.length, 2) ? [input[1]] : [];
+}
+function MappedMapping(input) {
+    return (index_2.Guard.IsArray(input[6]) && index_2.Guard.IsEqual(input[6].length, 1)
+        ? C.MappedDeferred(T.Identifier(input[3]), input[5], input[6][0], ApplyReadonly(input[1], ApplyOptional(input[8], input[10])))
+        : C.MappedDeferred(T.Identifier(input[3]), input[5], T.Ref(input[3]), ApplyReadonly(input[1], ApplyOptional(input[8], input[10]))));
+}
+function ReferenceMapping(input) {
+    return T.Ref(input);
+}
+function OptionsMapping(input) {
+    return C.OptionsDeferred(input[2], input[4]);
+}
+function JsonNumberMapping(input) {
+    return parseFloat(input);
+}
+function JsonBooleanMapping(input) {
+    return index_2.Guard.IsEqual(input, 'true');
+}
+function JsonStringMapping(input) {
+    return input;
+}
+function JsonNullMapping(input) {
+    return null;
+}
+function JsonPropertyMapping(input) {
+    return { [input[0]]: input[2] };
+}
+function JsonPropertyListMapping(input) {
+    return Delimited(input);
+}
+function JsonObjectMappingReduce(propertyList) {
+    return propertyList.reduce((result, left) => {
+        return index_1.Memory.Assign(result, left);
+    }, {});
+}
+function JsonObjectMapping(input) {
+    return JsonObjectMappingReduce(input[1]);
+}
+function JsonElementListMapping(input) {
+    return Delimited(input);
+}
+function JsonArrayMapping(input) {
+    return input[1];
+}
+function JsonMapping(input) {
+    return input;
+}
+function PatternBigIntMapping(input) {
+    return T.BigInt();
+}
+function PatternStringMapping(input) {
+    return T.String();
+}
+function PatternNumberMapping(input) {
+    return T.Number();
+}
+function PatternIntegerMapping(input) {
+    return T.Integer();
+}
+function PatternNeverMapping(input) {
+    return T.Never();
+}
+function PatternTextMapping(input) {
+    return T.Literal(input);
+}
+function PatternBaseMapping(input) {
+    return input;
+}
+function PatternGroupMapping(input) {
+    return T.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 PatternBodyMapping(input) {
+    return input;
+}
+function PatternMapping(input) {
+    return input[1];
+}
+function InterfaceDeclarationHeritageListMapping(input) {
+    return Delimited(input);
+}
+function InterfaceDeclarationHeritageMapping(input) {
+    return index_2.Guard.IsEqual(input.length, 2) ? input[1] : [];
+}
+function InterfaceDeclarationGenericMapping(input) {
+    const parameters = input[2];
+    const heritage = input[3];
+    const [properties, patternProperties] = input[4];
+    const options = index_2.Guard.IsEqual(index_2.Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
+    return { [input[1]]: T.Generic(parameters, C.InterfaceDeferred(heritage, properties, options)) };
+}
+function InterfaceDeclarationMapping(input) {
+    const heritage = input[2];
+    const [properties, patternProperties] = input[3];
+    const options = index_2.Guard.IsEqual(index_2.Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
+    return { [input[1]]: C.InterfaceDeferred(heritage, properties, options) };
+}
+function TypeAliasDeclarationGenericMapping(input) {
+    return { [input[1]]: T.Generic(input[2], input[4]) };
+}
+function TypeAliasDeclarationMapping(input) {
+    return { [input[1]]: input[3] };
+}
+function ExportKeywordMapping(input) {
+    return null; // ignored-dont-care
+}
+function ModuleDeclarationDelimiterMapping(input) {
+    return input;
+}
+function ModuleDeclarationListMapping(input) {
+    return PropertiesReduce(Delimited(input));
+}
+function ModuleDeclarationMapping(input) {
+    return input[1];
+}
+function ModuleMapping(input) {
+    const moduleDeclaration = input[0];
+    const moduleDeclarationList = input[1];
+    return C.ModuleDeferred(index_1.Memory.Assign(moduleDeclaration, moduleDeclarationList[0]));
+}
+function ScriptMapping(input) {
+    return input;
+}