@sinclair/typebox 0.34.31 → 0.34.32

package/build/esm/syntax/mapping.d.mts

@@ -0,0 +1,167 @@
+import * as T from '@sinclair/typebox.mjs';
+type TDereference<Context extends T.TProperties, Key extends string> = (Key extends keyof Context ? Context[Key] : T.TRef<Key>);
+type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (Input extends [infer Left, ...infer Right] ? Left extends [infer Item, infer _] ? TDelimitedDecode<Right, [...Result, Item]> : TDelimitedDecode<Right, [...Result, Left]> : Result);
+type TDelimited<Input extends [unknown, unknown]> = Input extends [infer Left extends unknown[], infer Right extends unknown[]] ? TDelimitedDecode<[...Left, ...Right]> : [];
+export type TGenericReferenceParameterListMapping<Input extends [unknown, unknown], Context extends T.TProperties> = TDelimited<Input>;
+export declare function GenericReferenceParameterListMapping(input: [unknown, unknown], context: unknown): unknown[];
+export type TGenericReferenceMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties, Result = Context extends T.TProperties ? Input extends [infer Reference extends string, '<', infer Args extends T.TSchema[], '>'] ? T.TInstantiate<TDereference<Context, Reference>, Args> : never : never> = Result;
+export declare function GenericReferenceMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TGenericArgumentsListMapping<Input extends [unknown, unknown], Context extends T.TProperties> = TDelimited<Input>;
+export declare function GenericArgumentsListMapping(input: [unknown, unknown], context: unknown): unknown[];
+type GenericArgumentsContext<Arguments extends string[], Context extends T.TProperties, Result extends T.TProperties = {}> = (Arguments extends [...infer Left extends string[], infer Right extends string] ? GenericArgumentsContext<Left, Context, Result & {
+    [_ in Right]: T.TArgument<Left['length']>;
+}> : T.Evaluate<Result & Context>);
+export type TGenericArgumentsMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['<', infer Arguments extends string[], '>'] ? Context extends infer Context extends T.TProperties ? GenericArgumentsContext<Arguments, Context> : never : never;
+declare const GenericArgumentsContext: (_arguments: string[], context: T.TProperties) => T.TProperties;
+export declare function GenericArgumentsMapping(input: [unknown, unknown, unknown], context: unknown): T.TProperties;
+export type TKeywordStringMapping<Input extends 'string', Context extends T.TProperties> = T.TString;
+export declare function KeywordStringMapping(input: 'string', context: unknown): T.TString;
+export type TKeywordNumberMapping<Input extends 'number', Context extends T.TProperties> = T.TNumber;
+export declare function KeywordNumberMapping(input: 'number', context: unknown): T.TNumber;
+export type TKeywordBooleanMapping<Input extends 'boolean', Context extends T.TProperties> = T.TBoolean;
+export declare function KeywordBooleanMapping(input: 'boolean', context: unknown): T.TBoolean;
+export type TKeywordUndefinedMapping<Input extends 'undefined', Context extends T.TProperties> = T.TUndefined;
+export declare function KeywordUndefinedMapping(input: 'undefined', context: unknown): T.TUndefined;
+export type TKeywordNullMapping<Input extends 'null', Context extends T.TProperties> = T.TNull;
+export declare function KeywordNullMapping(input: 'null', context: unknown): T.TNull;
+export type TKeywordIntegerMapping<Input extends 'integer', Context extends T.TProperties> = T.TInteger;
+export declare function KeywordIntegerMapping(input: 'integer', context: unknown): T.TInteger;
+export type TKeywordBigIntMapping<Input extends 'bigint', Context extends T.TProperties> = T.TBigInt;
+export declare function KeywordBigIntMapping(input: 'bigint', context: unknown): T.TBigInt;
+export type TKeywordUnknownMapping<Input extends 'unknown', Context extends T.TProperties> = T.TUnknown;
+export declare function KeywordUnknownMapping(input: 'unknown', context: unknown): T.TUnknown;
+export type TKeywordAnyMapping<Input extends 'any', Context extends T.TProperties> = T.TAny;
+export declare function KeywordAnyMapping(input: 'any', context: unknown): T.TAny;
+export type TKeywordNeverMapping<Input extends 'never', Context extends T.TProperties> = T.TNever;
+export declare function KeywordNeverMapping(input: 'never', context: unknown): T.TNever;
+export type TKeywordSymbolMapping<Input extends 'symbol', Context extends T.TProperties> = T.TSymbol;
+export declare function KeywordSymbolMapping(input: 'symbol', context: unknown): T.TSymbol;
+export type TKeywordVoidMapping<Input extends 'void', Context extends T.TProperties> = T.TVoid;
+export declare function KeywordVoidMapping(input: 'void', context: unknown): T.TVoid;
+export type TKeywordMapping<Input extends unknown, Context extends T.TProperties> = Input;
+export declare function KeywordMapping(input: unknown, context: unknown): unknown;
+export type TLiteralStringMapping<Input extends string, Context extends T.TProperties> = Input extends T.TLiteralValue ? T.TLiteral<Input> : never;
+export declare function LiteralStringMapping(input: string, context: unknown): T.TLiteral<string>;
+export type TLiteralNumberMapping<Input extends string, Context extends T.TProperties> = Input extends `${infer Value extends number}` ? T.TLiteral<Value> : never;
+export declare function LiteralNumberMapping(input: string, context: unknown): T.TLiteral<number>;
+export type TLiteralBooleanMapping<Input extends 'true' | 'false', Context extends T.TProperties> = Input extends 'true' ? T.TLiteral<true> : T.TLiteral<false>;
+export declare function LiteralBooleanMapping(input: 'true' | 'false', context: unknown): T.TLiteral<boolean>;
+export type TLiteralMapping<Input extends unknown, Context extends T.TProperties> = Input;
+export declare function LiteralMapping(input: unknown, context: unknown): unknown;
+export type TKeyOfMapping<Input extends [unknown] | [], Context extends T.TProperties> = Input extends [unknown] ? true : false;
+export declare function KeyOfMapping(input: [unknown] | [], context: unknown): boolean;
+type TIndexArrayMappingReduce<Input extends unknown[], Result extends unknown[] = []> = (Input extends [infer Left extends unknown, ...infer Right extends unknown[]] ? Left extends ['[', infer Type extends T.TSchema, ']'] ? TIndexArrayMappingReduce<Right, [...Result, [Type]]> : TIndexArrayMappingReduce<Right, [...Result, []]> : Result);
+export type TIndexArrayMapping<Input extends ([unknown, unknown, unknown] | [unknown, unknown])[], Context extends T.TProperties> = Input extends unknown[] ? TIndexArrayMappingReduce<Input> : [];
+export declare function IndexArrayMapping(input: ([unknown, unknown, unknown] | [unknown, unknown])[], context: unknown): unknown[];
+export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], Context extends T.TProperties> = Input extends ['extends', infer Type extends T.TSchema, '?', infer True extends T.TSchema, ':', infer False extends T.TSchema] ? [Type, True, False] : [];
+export declare function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | [], context: unknown): unknown[];
+export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown, Context extends T.TProperties> = (Input extends ['(', infer Type extends T.TSchema, ')'] ? Type : Input extends infer Type extends T.TSchema ? Type : never);
+export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown, context: unknown): unknown;
+type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [...infer Left extends unknown[], infer Right extends T.TSchema[]] ? (Right extends [infer Indexer extends T.TSchema] ? T.TIndex<TFactorIndexArray<Type, Left>, T.TIndexPropertyKeys<Indexer>> : Right extends [] ? T.TArray<TFactorIndexArray<Type, Left>> : T.TNever) : Type);
+type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? T.TExtends<Type, Right, True, False> : Type);
+export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]] ? KeyOf extends true ? TFactorExtends<T.TKeyOf<TFactorIndexArray<Type, IndexArray>>, Extends> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extends> : never;
+export declare function FactorMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (Operator extends '&' ? (Schema extends T.TIntersect<infer Types extends T.TSchema[]> ? T.TIntersect<[Left, ...Types]> : T.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends T.TUnion<infer Types extends T.TSchema[]> ? T.TUnion<[Left, ...Types]> : T.TUnion<[Left, Schema]>) : never) : never) : Left);
+export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | [], Context extends T.TProperties> = Input;
+export declare function ExprTermTailMapping(input: [unknown, unknown, unknown] | [], context: unknown): [] | [unknown, unknown, unknown];
+export type TExprTermMapping<Input extends [unknown, unknown], Context extends T.TProperties> = (Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]] ? TExprBinaryMapping<Left, Rest> : []);
+export declare function ExprTermMapping(input: [unknown, unknown], context: unknown): T.TSchema;
+export type TExprTailMapping<Input extends [unknown, unknown, unknown] | [], Context extends T.TProperties> = Input;
+export declare function ExprTailMapping(input: [unknown, unknown, unknown] | [], context: unknown): [] | [unknown, unknown, unknown];
+export type TExprMapping<Input extends [unknown, unknown], Context extends T.TProperties> = Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]] ? TExprBinaryMapping<Left, Rest> : [];
+export declare function ExprMapping(input: [unknown, unknown], context: unknown): T.TSchema;
+export type TTypeMapping<Input extends unknown, Context extends T.TProperties> = Input;
+export declare function TypeMapping(input: unknown, context: unknown): unknown;
+export type TPropertyKeyMapping<Input extends string, Context extends T.TProperties> = Input;
+export declare function PropertyKeyMapping(input: string, context: unknown): string;
+export type TReadonlyMapping<Input extends [unknown] | [], Context extends T.TProperties> = Input extends [unknown] ? true : false;
+export declare function ReadonlyMapping(input: [unknown] | [], context: unknown): boolean;
+export type TOptionalMapping<Input extends [unknown] | [], Context extends T.TProperties> = Input extends [unknown] ? true : false;
+export declare function OptionalMapping(input: [unknown] | [], context: unknown): boolean;
+export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends T.TSchema] ? {
+    [_ in Key]: ([
+        IsReadonly,
+        IsOptional
+    ] extends [true, true] ? T.TReadonlyOptional<Type> : [
+        IsReadonly,
+        IsOptional
+    ] extends [true, false] ? T.TReadonly<Type> : [
+        IsReadonly,
+        IsOptional
+    ] extends [false, true] ? T.TOptional<Type> : Type);
+} : never;
+export declare function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown], context: unknown): {
+    [x: string]: T.TSchema;
+};
+export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown], Context extends T.TProperties> = Input;
+export declare function PropertyDelimiterMapping(input: [unknown, unknown] | [unknown], context: unknown): [unknown] | [unknown, unknown];
+export type TPropertyListMapping<Input extends [unknown, unknown], Context extends T.TProperties> = TDelimited<Input>;
+export declare function PropertyListMapping(input: [unknown, unknown], context: unknown): unknown[];
+type TObjectMappingReduce<PropertiesList extends T.TProperties[], Result extends T.TProperties = {}> = (PropertiesList extends [infer Left extends T.TProperties, ...infer Right extends T.TProperties[]] ? TObjectMappingReduce<Right, Result & Left> : {
+    [Key in keyof Result]: Result[Key];
+});
+export type TObjectMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['{', infer PropertyList extends T.TProperties[], '}'] ? T.TObject<TObjectMappingReduce<PropertyList>> : never;
+export declare function ObjectMapping(input: [unknown, unknown, unknown], context: unknown): T.TObject<T.TProperties>;
+export type TElementListMapping<Input extends [unknown, unknown], Context extends T.TProperties> = TDelimited<Input>;
+export declare function ElementListMapping(input: [unknown, unknown], context: unknown): unknown[];
+export type TTupleMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never;
+export declare function TupleMapping(input: [unknown, unknown, unknown], context: unknown): T.TTuple<T.TSchema[]>;
+export type TParameterMapping<Input extends [unknown, unknown, unknown], Context extends T.TProperties> = Input extends [string, ':', infer Type extends T.TSchema] ? Type : never;
+export declare function ParameterMapping(input: [unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TParameterListMapping<Input extends [unknown, unknown], Context extends T.TProperties> = TDelimited<Input>;
+export declare function ParameterListMapping(input: [unknown, unknown], context: unknown): unknown[];
+export type TFunctionMapping<Input extends [unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['(', infer ParameterList extends T.TSchema[], ')', '=>', infer ReturnType extends T.TSchema] ? T.TFunction<ParameterList, ReturnType> : never;
+export declare function FunctionMapping(input: [unknown, unknown, unknown, unknown, unknown], context: unknown): T.TFunction<T.TSchema[], T.TSchema>;
+export type TConstructorMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema] ? T.TConstructor<ParameterList, InstanceType> : never;
+export declare function ConstructorMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TConstructor<T.TSchema[], T.TSchema>;
+export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['{', '[', infer _Key extends string, 'in', infer _Right extends T.TSchema, ']', ':', infer _Type extends T.TSchema, '}'] ? T.TLiteral<'Mapped types not supported'> : never;
+export declare function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TLiteral<"Mapped types not supported">;
+export type TAsyncIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['AsyncIterator', '<', infer Type extends T.TSchema, '>'] ? T.TAsyncIterator<Type> : never;
+export declare function AsyncIteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TAsyncIterator<T.TSchema>;
+export type TIteratorMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Iterator', '<', infer Type extends T.TSchema, '>'] ? T.TIterator<Type> : never;
+export declare function IteratorMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TIterator<T.TSchema>;
+export type TArgumentMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Argument', '<', infer Type extends T.TSchema, '>'] ? Type extends T.TLiteral<infer Index extends number> ? T.TArgument<Index> : T.TNever : never;
+export declare function ArgumentMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TNever | T.TArgument<number>;
+export type TAwaitedMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Awaited', '<', infer Type extends T.TSchema, '>'] ? T.TAwaited<Type> : never;
+export declare function AwaitedMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TArrayMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Array', '<', infer Type extends T.TSchema, '>'] ? T.TArray<Type> : never;
+export declare function ArrayMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TArray<T.TSchema>;
+export type TRecordMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Record', '<', infer Key extends T.TSchema, ',', infer Type extends T.TSchema, '>'] ? T.TRecordOrObject<Key, Type> : never;
+export declare function RecordMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TNever;
+export type TPromiseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Promise', '<', infer Type extends T.TSchema, '>'] ? T.TPromise<Type> : never;
+export declare function PromiseMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TPromise<T.TSchema>;
+export type TConstructorParametersMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['ConstructorParameters', '<', infer Type extends T.TSchema, '>'] ? T.TConstructorParameters<Type> : never;
+export declare function ConstructorParametersMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TNever;
+export type TFunctionParametersMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Parameters', '<', infer Type extends T.TSchema, '>'] ? T.TParameters<Type> : never;
+export declare function FunctionParametersMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TNever;
+export type TInstanceTypeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['InstanceType', '<', infer Type extends T.TSchema, '>'] ? T.TInstanceType<Type> : never;
+export declare function InstanceTypeMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TNever;
+export type TReturnTypeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['ReturnType', '<', infer Type extends T.TSchema, '>'] ? T.TReturnType<Type> : never;
+export declare function ReturnTypeMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TNever;
+export type TPartialMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Partial', '<', infer Type extends T.TSchema, '>'] ? T.TPartial<Type> : never;
+export declare function PartialMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TObject<{}>;
+export type TRequiredMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Required', '<', infer Type extends T.TSchema, '>'] ? T.TRequired<Type> : never;
+export declare function RequiredMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TObject<{}>;
+export type TPickMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Pick', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>'] ? T.TPick<Type, Key> : never;
+export declare function PickMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TObject<{}>;
+export type TOmitMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Omit', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>'] ? T.TOmit<Type, Key> : never;
+export declare function OmitMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TObject<{}>;
+export type TExcludeMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Exclude', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>'] ? T.TExclude<Type, Key> : never;
+export declare function ExcludeMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TNever;
+export type TExtractMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Extract', '<', infer Type extends T.TSchema, ',', infer Key extends T.TSchema, '>'] ? T.TExtract<Type, Key> : never;
+export declare function ExtractMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TUppercaseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Uppercase', '<', infer Type extends T.TSchema, '>'] ? T.TUppercase<Type> : never;
+export declare function UppercaseMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TLowercaseMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Lowercase', '<', infer Type extends T.TSchema, '>'] ? T.TLowercase<Type> : never;
+export declare function LowercaseMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TCapitalizeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Capitalize', '<', infer Type extends T.TSchema, '>'] ? T.TCapitalize<Type> : never;
+export declare function CapitalizeMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TUncapitalizeMapping<Input extends [unknown, unknown, unknown, unknown], Context extends T.TProperties> = Input extends ['Uncapitalize', '<', infer Type extends T.TSchema, '>'] ? T.TUncapitalize<Type> : never;
+export declare function UncapitalizeMapping(input: [unknown, unknown, unknown, unknown], context: unknown): T.TSchema;
+export type TDateMapping<Input extends 'Date', Context extends T.TProperties> = T.TDate;
+export declare function DateMapping(input: 'Date', context: unknown): T.TDate;
+export type TUint8ArrayMapping<Input extends 'Uint8Array', Context extends T.TProperties> = T.TUint8Array;
+export declare function Uint8ArrayMapping(input: 'Uint8Array', context: unknown): T.TUint8Array;
+export type TReferenceMapping<Input extends string, Context extends T.TProperties> = Context extends T.TProperties ? Input extends string ? TDereference<Context, Input> : never : never;
+export declare function ReferenceMapping(input: string, context: unknown): T.TSchema;
+export {};

package/build/esm/syntax/mapping.mjs

@@ -0,0 +1,386 @@
+import * as T from '@sinclair/typebox.mjs';
+// prettier-ignore
+const Dereference = (context, key) => {
+    return key in context ? context[key] : T.Ref(key);
+};
+// prettier-ignore
+const DelimitedDecode = (input, result = []) => {
+    return input.reduce((result, left) => {
+        return T.ValueGuard.IsArray(left) && left.length === 2
+            ? [...result, left[0]]
+            : [...result, left];
+    }, []);
+};
+// prettier-ignore
+const Delimited = (input) => {
+    const [left, right] = input;
+    return DelimitedDecode([...left, ...right]);
+};
+// prettier-ignore
+export function GenericReferenceParameterListMapping(input, context) {
+    return Delimited(input);
+}
+// prettier-ignore
+export function GenericReferenceMapping(input, context) {
+    const type = Dereference(context, input[0]);
+    const args = input[2];
+    return T.Instantiate(type, args);
+}
+// prettier-ignore
+export function GenericArgumentsListMapping(input, context) {
+    return Delimited(input);
+}
+// ...
+// prettier-ignore
+const GenericArgumentsContext = (_arguments, context) => {
+    return _arguments.reduce((result, arg, index) => {
+        return { ...result, [arg]: T.Argument(index) };
+    }, context);
+};
+// prettier-ignore
+export function GenericArgumentsMapping(input, context) {
+    return input.length === 3
+        ? GenericArgumentsContext(input[1], context)
+        : {};
+}
+// prettier-ignore
+export function KeywordStringMapping(input, context) {
+    return T.String();
+}
+// prettier-ignore
+export function KeywordNumberMapping(input, context) {
+    return T.Number();
+}
+// prettier-ignore
+export function KeywordBooleanMapping(input, context) {
+    return T.Boolean();
+}
+// prettier-ignore
+export function KeywordUndefinedMapping(input, context) {
+    return T.Undefined();
+}
+// prettier-ignore
+export function KeywordNullMapping(input, context) {
+    return T.Null();
+}
+// prettier-ignore
+export function KeywordIntegerMapping(input, context) {
+    return T.Integer();
+}
+// prettier-ignore
+export function KeywordBigIntMapping(input, context) {
+    return T.BigInt();
+}
+// prettier-ignore
+export function KeywordUnknownMapping(input, context) {
+    return T.Unknown();
+}
+// prettier-ignore
+export function KeywordAnyMapping(input, context) {
+    return T.Any();
+}
+// prettier-ignore
+export function KeywordNeverMapping(input, context) {
+    return T.Never();
+}
+// prettier-ignore
+export function KeywordSymbolMapping(input, context) {
+    return T.Symbol();
+}
+// prettier-ignore
+export function KeywordVoidMapping(input, context) {
+    return T.Void();
+}
+// prettier-ignore
+export function KeywordMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function LiteralStringMapping(input, context) {
+    return T.Literal(input);
+}
+// prettier-ignore
+export function LiteralNumberMapping(input, context) {
+    return T.Literal(parseFloat(input));
+}
+// prettier-ignore
+export function LiteralBooleanMapping(input, context) {
+    return T.Literal(input === 'true');
+}
+// prettier-ignore
+export function LiteralMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function KeyOfMapping(input, context) {
+    return input.length > 0;
+}
+// prettier-ignore
+export function IndexArrayMapping(input, context) {
+    return input.reduce((result, current) => {
+        return current.length === 3
+            ? [...result, [current[1]]]
+            : [...result, []];
+    }, []);
+}
+// prettier-ignore
+export function ExtendsMapping(input, context) {
+    return input.length === 6
+        ? [input[1], input[3], input[5]]
+        : [];
+}
+// prettier-ignore
+export function BaseMapping(input, context) {
+    return T.ValueGuard.IsArray(input) && input.length === 3 ? input[1] : input;
+}
+// ...
+// prettier-ignore
+const FactorIndexArray = (Type, indexArray) => {
+    return indexArray.reduceRight((result, right) => {
+        const _right = right;
+        return (_right.length === 1 ? T.Index(result, _right[0]) :
+            _right.length === 0 ? T.Array(result, _right[0]) :
+                T.Never());
+    }, Type);
+};
+// prettier-ignore
+const FactorExtends = (Type, Extends) => {
+    return Extends.length === 3
+        ? T.Extends(Type, Extends[0], Extends[1], Extends[2])
+        : Type;
+};
+// prettier-ignore
+export function FactorMapping(input, context) {
+    const [KeyOf, Type, IndexArray, Extends] = input;
+    return KeyOf
+        ? FactorExtends(T.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+        : FactorExtends(FactorIndexArray(Type, IndexArray), Extends);
+}
+// prettier-ignore
+function ExprBinaryMapping(Left, Rest) {
+    return (Rest.length === 3 ? (() => {
+        const [Operator, Right, Next] = Rest;
+        const Schema = ExprBinaryMapping(Right, Next);
+        if (Operator === '&') {
+            return T.TypeGuard.IsIntersect(Schema)
+                ? T.Intersect([Left, ...Schema.allOf])
+                : T.Intersect([Left, Schema]);
+        }
+        if (Operator === '|') {
+            return T.TypeGuard.IsUnion(Schema)
+                ? T.Union([Left, ...Schema.anyOf])
+                : T.Union([Left, Schema]);
+        }
+        throw 1;
+    })() : Left);
+}
+// prettier-ignore
+export function ExprTermTailMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function ExprTermMapping(input, context) {
+    const [left, rest] = input;
+    return ExprBinaryMapping(left, rest);
+}
+// prettier-ignore
+export function ExprTailMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function ExprMapping(input, context) {
+    const [left, rest] = input;
+    return ExprBinaryMapping(left, rest);
+}
+// prettier-ignore
+export function TypeMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function PropertyKeyMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function ReadonlyMapping(input, context) {
+    return input.length > 0;
+}
+// prettier-ignore
+export function OptionalMapping(input, context) {
+    return input.length > 0;
+}
+// prettier-ignore
+export function PropertyMapping(input, context) {
+    const [isReadonly, key, isOptional, _colon, type] = input;
+    return {
+        [key]: (isReadonly && isOptional ? T.ReadonlyOptional(type) :
+            isReadonly && !isOptional ? T.Readonly(type) :
+                !isReadonly && isOptional ? T.Optional(type) :
+                    type)
+    };
+}
+// prettier-ignore
+export function PropertyDelimiterMapping(input, context) {
+    return input;
+}
+// prettier-ignore
+export function PropertyListMapping(input, context) {
+    return Delimited(input);
+}
+// prettier-ignore
+export function ObjectMapping(input, context) {
+    const propertyList = input[1];
+    return T.Object(propertyList.reduce((result, property) => {
+        return { ...result, ...property };
+    }, {}));
+}
+// prettier-ignore
+export function ElementListMapping(input, context) {
+    return Delimited(input);
+}
+// prettier-ignore
+export function TupleMapping(input, context) {
+    return T.Tuple(input[1]);
+}
+// prettier-ignore
+export function ParameterMapping(input, context) {
+    const [_ident, _colon, type] = input;
+    return type;
+}
+// prettier-ignore
+export function ParameterListMapping(input, context) {
+    return Delimited(input);
+}
+// prettier-ignore
+export function FunctionMapping(input, context) {
+    const [_lparan, parameterList, _rparan, _arrow, returnType] = input;
+    return T.Function(parameterList, returnType);
+}
+// prettier-ignore
+export function ConstructorMapping(input, context) {
+    const [_new, _lparan, parameterList, _rparan, _arrow, instanceType] = input;
+    return T.Constructor(parameterList, instanceType);
+}
+// prettier-ignore
+export function MappedMapping(input, context) {
+    const [_lbrace, _lbracket, _key, _in, _right, _rbracket, _colon, _type] = input;
+    return T.Literal('Mapped types not supported');
+}
+// prettier-ignore
+export function AsyncIteratorMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.AsyncIterator(type);
+}
+// prettier-ignore
+export function IteratorMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Iterator(type);
+}
+// prettier-ignore
+export function ArgumentMapping(input, context) {
+    return T.KindGuard.IsLiteralNumber(input[2])
+        ? T.Argument(Math.trunc(input[2].const))
+        : T.Never();
+}
+// prettier-ignore
+export function AwaitedMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Awaited(type);
+}
+// prettier-ignore
+export function ArrayMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Array(type);
+}
+// prettier-ignore
+export function RecordMapping(input, context) {
+    const [_name, _langle, key, _comma, type, _rangle] = input;
+    return T.Record(key, type);
+}
+// prettier-ignore
+export function PromiseMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Promise(type);
+}
+// prettier-ignore
+export function ConstructorParametersMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.ConstructorParameters(type);
+}
+// prettier-ignore
+export function FunctionParametersMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Parameters(type);
+}
+// prettier-ignore
+export function InstanceTypeMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.InstanceType(type);
+}
+// prettier-ignore
+export function ReturnTypeMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.ReturnType(type);
+}
+// prettier-ignore
+export function PartialMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Partial(type);
+}
+// prettier-ignore
+export function RequiredMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Required(type);
+}
+// prettier-ignore
+export function PickMapping(input, context) {
+    const [_name, _langle, key, _comma, type, _rangle] = input;
+    return T.Pick(key, type);
+}
+// prettier-ignore
+export function OmitMapping(input, context) {
+    const [_name, _langle, key, _comma, type, _rangle] = input;
+    return T.Omit(key, type);
+}
+// prettier-ignore
+export function ExcludeMapping(input, context) {
+    const [_name, _langle, key, _comma, type, _rangle] = input;
+    return T.Exclude(key, type);
+}
+// prettier-ignore
+export function ExtractMapping(input, context) {
+    const [_name, _langle, key, _comma, type, _rangle] = input;
+    return T.Extract(key, type);
+}
+// prettier-ignore
+export function UppercaseMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Uppercase(type);
+}
+// prettier-ignore
+export function LowercaseMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Lowercase(type);
+}
+// prettier-ignore
+export function CapitalizeMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Capitalize(type);
+}
+// prettier-ignore
+export function UncapitalizeMapping(input, context) {
+    const [_name, _langle, type, _rangle] = input;
+    return T.Uncapitalize(type);
+}
+// prettier-ignore
+export function DateMapping(input, context) {
+    return T.Date();
+}
+// prettier-ignore
+export function Uint8ArrayMapping(input, context) {
+    return T.Uint8Array();
+}
+// prettier-ignore
+export function ReferenceMapping(input, context) {
+    const target = Dereference(context, input);
+    return target;
+}