@sinclair/typebox 0.34.15 → 0.34.17

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

@@ -1,71 +1,57 @@
-import { Runtime } from './parsebox/index.mjs';
-import * as Types from '../type/index.mjs';
+import { Runtime } from '../parser/index.mjs';
+import * as t from '../type/index.mjs';
 export declare const Module: Runtime.Module<{
-    ExportModifier: Runtime.IUnion<boolean>;
-    HeritageList: Runtime.IUnion<Types.TSchema[]>;
-    Heritage: Runtime.IUnion<unknown[]>;
-    InterfaceDeclaration: Runtime.ITuple<{
-        [x: string]: Types.TIntersect<[...Types.TRef<string>[], Types.TObject<Types.TProperties>]>;
-    }>;
-    TypeAliasDeclaration: Runtime.ITuple<{
-        [x: string]: Types.TSchema;
-    }>;
-    ModuleType: Runtime.IUnion<unknown>;
-    ModuleProperties: Runtime.IUnion<Types.TProperties>;
-    ModuleDeclaration: Runtime.ITuple<Types.TModule<Types.TProperties, {
-        [x: string]: Types.TSchema;
-        [x: number]: Types.TSchema;
-    }>>;
-    Literal: Runtime.IUnion<Types.TLiteral<string> | Types.TLiteral<number> | Types.TLiteral<boolean>>;
-    Keyword: Runtime.IUnion<Types.TAny | Types.TNever | Types.TString | Types.TBoolean | Types.TNumber | Types.TInteger | Types.TBigInt | Types.TNull | Types.TSymbol | Types.TUndefined | Types.TUnknown | Types.TVoid>;
+    Literal: Runtime.IUnion<t.TLiteral<string> | t.TLiteral<number> | t.TLiteral<boolean>>;
+    Keyword: Runtime.IUnion<t.TAny | t.TBoolean | t.TBigInt | t.TNever | t.TString | t.TNumber | t.TInteger | t.TNull | t.TSymbol | t.TUndefined | t.TUnknown | t.TVoid>;
     KeyOf: Runtime.IUnion<boolean>;
     IndexArray: Runtime.IUnion<unknown[]>;
     Extends: Runtime.IUnion<unknown[]>;
     Base: Runtime.IUnion<unknown>;
-    Factor: Runtime.ITuple<Types.TSchema>;
+    Factor: Runtime.ITuple<t.TSchema>;
     ExprTermTail: Runtime.IUnion<[] | ["&", unknown, unknown]>;
-    ExprTerm: Runtime.ITuple<Types.TSchema>;
+    ExprTerm: Runtime.ITuple<t.TSchema>;
     ExprTail: Runtime.IUnion<[] | ["|", unknown, unknown]>;
-    Expr: Runtime.ITuple<Types.TSchema>;
+    Expr: Runtime.ITuple<t.TSchema>;
     Type: Runtime.IRef<unknown>;
     PropertyKey: Runtime.IUnion<string>;
     Readonly: Runtime.IUnion<boolean>;
     Optional: Runtime.IUnion<boolean>;
     Property: Runtime.ITuple<{
-        [x: string]: Types.TSchema;
+        [x: string]: t.TSchema;
     }>;
     PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
-    Properties: Runtime.IUnion<Types.TProperties>;
-    Object: Runtime.ITuple<Types.TObject<Types.TProperties>>;
+    Properties: Runtime.IUnion<t.TProperties>;
+    Object: Runtime.ITuple<t.TObject<t.TProperties>>;
     Elements: Runtime.IUnion<unknown[]>;
-    Tuple: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
-    Parameter: Runtime.ITuple<Types.TSchema>;
-    Function: Runtime.ITuple<Types.TFunction<Types.TSchema[], Types.TSchema>>;
+    Tuple: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
+    Parameter: Runtime.ITuple<t.TSchema>;
+    Function: Runtime.ITuple<t.TFunction<t.TSchema[], t.TSchema>>;
     Parameters: Runtime.IUnion<unknown[]>;
-    Constructor: Runtime.ITuple<Types.TConstructor<Types.TSchema[], Types.TSchema>>;
-    Mapped: Runtime.ITuple<Types.TLiteral<"Mapped types not supported">>;
-    AsyncIterator: Runtime.ITuple<Types.TAsyncIterator<Types.TSchema>>;
-    Iterator: Runtime.ITuple<Types.TIterator<Types.TSchema>>;
-    Awaited: Runtime.ITuple<Types.TSchema>;
-    Array: Runtime.ITuple<Types.TArray<Types.TSchema>>;
-    Record: Runtime.ITuple<Types.TNever>;
-    Promise: Runtime.ITuple<Types.TPromise<Types.TSchema>>;
-    ConstructorParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
-    FunctionParameters: Runtime.ITuple<Types.TTuple<Types.TSchema[]>>;
-    InstanceType: Runtime.ITuple<Types.TSchema>;
-    ReturnType: Runtime.ITuple<Types.TSchema>;
-    Partial: Runtime.ITuple<Types.TObject<{}>>;
-    Required: Runtime.ITuple<Types.TObject<{}>>;
-    Pick: Runtime.ITuple<Types.TObject<{}>>;
-    Omit: Runtime.ITuple<Types.TObject<{}>>;
-    Exclude: Runtime.ITuple<Types.TNever>;
-    Extract: Runtime.ITuple<Types.TSchema>;
-    Uppercase: Runtime.ITuple<Types.TSchema>;
-    Lowercase: Runtime.ITuple<Types.TSchema>;
-    Capitalize: Runtime.ITuple<Types.TSchema>;
-    Uncapitalize: Runtime.ITuple<Types.TSchema>;
-    Date: Runtime.IConst<Types.TDate>;
-    Uint8Array: Runtime.IConst<Types.TUint8Array>;
-    Reference: Runtime.IIdent<Types.TSchema>;
-    Main: Runtime.IUnion<unknown>;
+    Constructor: Runtime.ITuple<t.TConstructor<t.TSchema[], t.TSchema>>;
+    Mapped: Runtime.ITuple<t.TLiteral<"Mapped types not supported">>;
+    AsyncIterator: Runtime.ITuple<t.TAsyncIterator<t.TSchema>>;
+    Iterator: Runtime.ITuple<t.TIterator<t.TSchema>>;
+    Argument: Runtime.ITuple<t.TNever | t.TArgument<number>>;
+    Awaited: Runtime.ITuple<t.TSchema>;
+    Array: Runtime.ITuple<t.TArray<t.TSchema>>;
+    Record: Runtime.ITuple<t.TNever>;
+    Promise: Runtime.ITuple<t.TPromise<t.TSchema>>;
+    ConstructorParameters: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
+    FunctionParameters: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
+    InstanceType: Runtime.ITuple<t.TSchema>;
+    ReturnType: Runtime.ITuple<t.TSchema>;
+    Partial: Runtime.ITuple<t.TObject<{}>>;
+    Required: Runtime.ITuple<t.TObject<{}>>;
+    Pick: Runtime.ITuple<t.TObject<{}>>;
+    Omit: Runtime.ITuple<t.TObject<{}>>;
+    Exclude: Runtime.ITuple<t.TNever>;
+    Extract: Runtime.ITuple<t.TSchema>;
+    Uppercase: Runtime.ITuple<t.TSchema>;
+    Lowercase: Runtime.ITuple<t.TSchema>;
+    Capitalize: Runtime.ITuple<t.TSchema>;
+    Uncapitalize: Runtime.ITuple<t.TSchema>;
+    Date: Runtime.IConst<t.TDate>;
+    Uint8Array: Runtime.IConst<t.TUint8Array>;
+    GenericReference: Runtime.ITuple<t.TSchema>;
+    Reference: Runtime.IIdent<t.TSchema>;
 }>;

package/build/esm/syntax/runtime.mjs

@@ -1,5 +1,5 @@
-import { Runtime } from './parsebox/index.mjs';
-import * as Types from '../type/index.mjs';
+import { Runtime } from '../parser/index.mjs';
+import * as t from '../type/index.mjs';
 // ------------------------------------------------------------------
 // Tokens
 // ------------------------------------------------------------------
@@ -30,159 +30,54 @@ function DestructureRight(values) {
         : [values, undefined];
 }
 // ------------------------------------------------------------------
-// Deref
+// Dereference
 // ------------------------------------------------------------------
-const Deref = (context, key) => {
-    return key in context ? context[key] : Types.Ref(key);
+const Dereference = (context, key) => {
+    return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
-// ExportModifier
+// GenericReference
 // ------------------------------------------------------------------
-// prettier-ignore
-const ExportModifierMapping = (values) => {
-    return values.length === 1;
-};
-// prettier-ignore
-const ExportModifier = Runtime.Union([
-    Runtime.Tuple([Runtime.Const('export')]), Runtime.Tuple([])
-], ExportModifierMapping);
-// ------------------------------------------------------------------
-// TypeAliasDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-const TypeAliasDeclarationMapping = (_Export, _Keyword, Ident, _Equals, Type) => {
-    return { [Ident]: Type };
-};
-// prettier-ignore
-const TypeAliasDeclaration = Runtime.Tuple([
-    Runtime.Ref('ExportModifier'),
-    Runtime.Const('type'),
-    Runtime.Ident(),
-    Runtime.Const(Equals),
-    Runtime.Ref('Type')
-], value => TypeAliasDeclarationMapping(...value));
-// ------------------------------------------------------------------
-// HeritageList
-// ------------------------------------------------------------------
-// prettier-ignore (note, heritage list should disallow trailing comma)
-const HeritageListDelimiter = Runtime.Union([Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]), Runtime.Tuple([Runtime.Const(Comma)])]);
-// prettier-ignore
-const HeritageListMapping = (values, context) => {
-    return (values.length === 3 ? [Deref(context, values[0]), ...values[2]] :
-        values.length === 1 ? [Deref(context, values[0])] :
-            []);
-};
-// prettier-ignore
-const HeritageList = Runtime.Union([
-    Runtime.Tuple([Runtime.Ident(), HeritageListDelimiter, Runtime.Ref('HeritageList')]),
-    Runtime.Tuple([Runtime.Ident()]),
-    Runtime.Tuple([])
-], HeritageListMapping);
-// ------------------------------------------------------------------
-// Heritage
-// ------------------------------------------------------------------
-// prettier-ignore
-const HeritageMapping = (values) => {
-    return (values.length === 2 ? values[1] : []);
-};
-// prettier-ignore
-const Heritage = Runtime.Union([
-    Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('HeritageList')]),
-    Runtime.Tuple([])
-], HeritageMapping);
-// ------------------------------------------------------------------
-// InterfaceDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-const InterfaceDeclarationMapping = (_0, _1, Ident, Heritage, _4, Properties, _6) => {
-    return { [Ident]: Types.Intersect([...Heritage, Types.Object(Properties)]) };
-};
-// prettier-ignore
-const InterfaceDeclaration = Runtime.Tuple([
-    Runtime.Ref('ExportModifier'),
-    Runtime.Const('interface'),
-    Runtime.Ident(),
-    Runtime.Ref('Heritage'),
-    Runtime.Const(LBrace),
-    Runtime.Ref('Properties'),
-    Runtime.Const(RBrace),
-], values => InterfaceDeclarationMapping(...values));
-// ------------------------------------------------------------------
-// ModuleType
-// ------------------------------------------------------------------
-// prettier-ignore
-const ModuleType = Runtime.Union([
-    Runtime.Ref('InterfaceDeclaration'),
-    Runtime.Ref('TypeAliasDeclaration')
-]);
-// ------------------------------------------------------------------
-// ModuleProperties
-// ------------------------------------------------------------------
-// prettier-ignore
-const ModulePropertiesDelimiter = Runtime.Union([
-    Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
-    Runtime.Tuple([Runtime.Const(SemiColon)]),
-    Runtime.Tuple([Runtime.Const(Newline)]),
-]);
-// prettier-ignore
-const ModulePropertiesMapping = (values) => {
-    return (values.length === 3 ? { ...values[0], ...values[2] } :
-        values.length === 1 ? values[0] :
-            {});
-};
-// prettier-ignore
-const ModuleProperties = Runtime.Union([
-    Runtime.Tuple([Runtime.Ref('ModuleType'), ModulePropertiesDelimiter, Runtime.Ref('ModuleProperties')]),
-    Runtime.Tuple([Runtime.Ref('ModuleType')]),
-    Runtime.Tuple([]),
-], ModulePropertiesMapping);
-// ------------------------------------------------------------------
-// ModuleDeclaration
-// ------------------------------------------------------------------
-// prettier-ignore
-const ModuleIdentifier = Runtime.Union([
-    Runtime.Tuple([Runtime.Ident()]),
-    Runtime.Tuple([])
-]);
-// prettier-ignore
-const ModuleDeclarationMapping = (_1, _2, _Ident, _3, Properties, _5) => {
-    return Types.Module(Properties);
-};
-// prettier-ignore
-const ModuleDeclaration = Runtime.Tuple([
-    Runtime.Ref('ExportModifier'), Runtime.Const('module'), ModuleIdentifier, Runtime.Const(LBrace), Runtime.Ref('ModuleProperties'), Runtime.Const(RBrace)
-], values => ModuleDeclarationMapping(...values));
+function GenericReferenceMapping(results, context) {
+    const target = Dereference(context, results[0]);
+    return t.Instantiate(target, results[2]);
+}
+const GenericReference = Runtime.Tuple([Runtime.Ident(), Runtime.Const(LAngle), Runtime.Ref('Elements'), Runtime.Const(RAngle)], (results, context) => GenericReferenceMapping(results, context));
 // ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
+function ReferenceMapping(result, context) {
+    const target = Dereference(context, result);
+    return target;
+}
 // prettier-ignore
-const Reference = Runtime.Ident((value, context) => Deref(context, value));
+const Reference = Runtime.Ident((result, context) => ReferenceMapping(result, context));
 // ------------------------------------------------------------------
 // Literal
 // ------------------------------------------------------------------
 // prettier-ignore
 const Literal = Runtime.Union([
-    Runtime.Union([Runtime.Const('true'), Runtime.Const('false')], value => Types.Literal(value === 'true')),
-    Runtime.Number(value => Types.Literal(parseFloat(value))),
-    Runtime.String([SingleQuote, DoubleQuote, Tilde], value => Types.Literal(value))
+    Runtime.Union([Runtime.Const('true'), Runtime.Const('false')], value => t.Literal(value === 'true')),
+    Runtime.Number(value => t.Literal(parseFloat(value))),
+    Runtime.String([SingleQuote, DoubleQuote, Tilde], value => t.Literal(value))
 ]);
 // ------------------------------------------------------------------
 // Keyword
 // ------------------------------------------------------------------
 // prettier-ignore
 const Keyword = Runtime.Union([
-    Runtime.Const('any', Runtime.As(Types.Any())),
-    Runtime.Const('bigint', Runtime.As(Types.BigInt())),
-    Runtime.Const('boolean', Runtime.As(Types.Boolean())),
-    Runtime.Const('integer', Runtime.As(Types.Integer())),
-    Runtime.Const('never', Runtime.As(Types.Never())),
-    Runtime.Const('null', Runtime.As(Types.Null())),
-    Runtime.Const('number', Runtime.As(Types.Number())),
-    Runtime.Const('string', Runtime.As(Types.String())),
-    Runtime.Const('symbol', Runtime.As(Types.Symbol())),
-    Runtime.Const('undefined', Runtime.As(Types.Undefined())),
-    Runtime.Const('unknown', Runtime.As(Types.Unknown())),
-    Runtime.Const('void', Runtime.As(Types.Void())),
+    Runtime.Const('any', Runtime.As(t.Any())),
+    Runtime.Const('bigint', Runtime.As(t.BigInt())),
+    Runtime.Const('boolean', Runtime.As(t.Boolean())),
+    Runtime.Const('integer', Runtime.As(t.Integer())),
+    Runtime.Const('never', Runtime.As(t.Never())),
+    Runtime.Const('null', Runtime.As(t.Null())),
+    Runtime.Const('number', Runtime.As(t.Number())),
+    Runtime.Const('string', Runtime.As(t.String())),
+    Runtime.Const('symbol', Runtime.As(t.Symbol())),
+    Runtime.Const('undefined', Runtime.As(t.Undefined())),
+    Runtime.Const('unknown', Runtime.As(t.Unknown())),
+    Runtime.Const('void', Runtime.As(t.Void())),
 ]);
 // ------------------------------------------------------------------
 // KeyOf
@@ -248,6 +143,7 @@ const Base = Runtime.Union([
             Runtime.Ref('FunctionParameters'),
             Runtime.Ref('InstanceType'),
             Runtime.Ref('ReturnType'),
+            Runtime.Ref('Argument'),
             Runtime.Ref('Awaited'),
             Runtime.Ref('Array'),
             Runtime.Ref('Record'),
@@ -264,6 +160,7 @@ const Base = Runtime.Union([
             Runtime.Ref('Uncapitalize'),
             Runtime.Ref('Date'),
             Runtime.Ref('Uint8Array'),
+            Runtime.Ref('GenericReference'),
             Runtime.Ref('Reference')
         ])])
 ], BaseMapping);
@@ -273,22 +170,22 @@ const Base = Runtime.Union([
 // prettier-ignore
 const FactorExtends = (Type, Extends) => {
     return Extends.length === 3
-        ? Types.Extends(Type, Extends[0], Extends[1], Extends[2])
+        ? t.Extends(Type, Extends[0], Extends[1], Extends[2])
         : Type;
 };
 // prettier-ignore
 const FactorIndexArray = (Type, IndexArray) => {
     const [Left, Right] = DestructureRight(IndexArray);
-    return (!Types.ValueGuard.IsUndefined(Right) ? (
+    return (!t.ValueGuard.IsUndefined(Right) ? (
     // note: Indexed types require reimplementation to replace `[number]` indexers
-    Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
-        Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
-            Types.Never()) : Type);
+    Right.length === 1 ? t.Index(FactorIndexArray(Type, Left), Right[0]) :
+        Right.length === 0 ? t.Array(FactorIndexArray(Type, Left)) :
+            t.Never()) : Type);
 };
 // prettier-ignore
 const FactorMapping = (KeyOf, Type, IndexArray, Extends) => {
     return KeyOf
-        ? FactorExtends(Types.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+        ? FactorExtends(t.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
         : FactorExtends(FactorIndexArray(Type, IndexArray), Extends);
 };
 // prettier-ignore
@@ -307,14 +204,14 @@ function ExprBinaryMapping(Left, Rest) {
         const [Operator, Right, Next] = Rest;
         const Schema = ExprBinaryMapping(Right, Next);
         if (Operator === '&') {
-            return Types.TypeGuard.IsIntersect(Schema)
-                ? Types.Intersect([Left, ...Schema.allOf])
-                : Types.Intersect([Left, Schema]);
+            return t.TypeGuard.IsIntersect(Schema)
+                ? t.Intersect([Left, ...Schema.allOf])
+                : t.Intersect([Left, Schema]);
         }
         if (Operator === '|') {
-            return Types.TypeGuard.IsUnion(Schema)
-                ? Types.Union([Left, ...Schema.anyOf])
-                : Types.Union([Left, Schema]);
+            return t.TypeGuard.IsUnion(Schema)
+                ? t.Union([Left, ...Schema.anyOf])
+                : t.Union([Left, Schema]);
         }
         throw 1;
     })() : Left);
@@ -349,9 +246,9 @@ const Readonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runt
 const Optional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], (value) => value.length > 0);
 // prettier-ignore
 const PropertyMapping = (IsReadonly, Key, IsOptional, _, Type) => ({
-    [Key]: (IsReadonly && IsOptional ? Types.ReadonlyOptional(Type) :
-        IsReadonly && !IsOptional ? Types.Readonly(Type) :
-            !IsReadonly && IsOptional ? Types.Optional(Type) :
+    [Key]: (IsReadonly && IsOptional ? t.ReadonlyOptional(Type) :
+        IsReadonly && !IsOptional ? t.Readonly(Type) :
+            !IsReadonly && IsOptional ? t.Optional(Type) :
                 Type)
 });
 // prettier-ignore
@@ -384,7 +281,7 @@ const Properties = Runtime.Union([
 // Object
 // ------------------------------------------------------------------
 // prettier-ignore
-const ObjectMapping = (_0, Properties, _2) => Types.Object(Properties);
+const ObjectMapping = (_0, Properties, _2) => t.Object(Properties);
 // prettier-ignore
 const _Object = Runtime.Tuple([
     Runtime.Const(LBrace),
@@ -409,7 +306,7 @@ const Tuple = Runtime.Tuple([
     Runtime.Const(LBracket),
     Runtime.Ref('Elements'),
     Runtime.Const(RBracket)
-], value => Types.Tuple(value[1]));
+], value => t.Tuple(value[1]));
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
@@ -438,7 +335,7 @@ const Constructor = Runtime.Tuple([
     Runtime.Const(RParen),
     Runtime.Const('=>'),
     Runtime.Ref('Type')
-], value => Types.Constructor(value[2], value[5]));
+], value => t.Constructor(value[2], value[5]));
 // ------------------------------------------------------------------
 // Function
 // ------------------------------------------------------------------
@@ -449,13 +346,13 @@ const Function = Runtime.Tuple([
     Runtime.Const(RParen),
     Runtime.Const('=>'),
     Runtime.Ref('Type')
-], value => Types.Function(value[1], value[4]));
+], value => t.Function(value[1], value[4]));
 // ------------------------------------------------------------------
 // Mapped (requires deferred types)
 // ------------------------------------------------------------------
 // prettier-ignore
 const MappedMapping = (values) => {
-    return Types.Literal('Mapped types not supported');
+    return t.Literal('Mapped types not supported');
 };
 // prettier-ignore
 const Mapped = Runtime.Tuple([
@@ -478,7 +375,7 @@ const AsyncIterator = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.AsyncIterator(value[2]));
+], value => t.AsyncIterator(value[2]));
 // ------------------------------------------------------------------
 // Iterator
 // ------------------------------------------------------------------
@@ -488,7 +385,7 @@ const Iterator = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Iterator(value[2]));
+], value => t.Iterator(value[2]));
 // ------------------------------------------------------------------
 // ConstructorParameters
 // ------------------------------------------------------------------
@@ -498,7 +395,7 @@ const ConstructorParameters = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.ConstructorParameters(value[2]));
+], value => t.ConstructorParameters(value[2]));
 // ------------------------------------------------------------------
 // Parameters
 // ------------------------------------------------------------------
@@ -508,7 +405,7 @@ const FunctionParameters = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Parameters(value[2]));
+], value => t.Parameters(value[2]));
 // ------------------------------------------------------------------
 // InstanceType
 // ------------------------------------------------------------------
@@ -518,7 +415,7 @@ const InstanceType = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.InstanceType(value[2]));
+], value => t.InstanceType(value[2]));
 // ------------------------------------------------------------------
 // ReturnType
 // ------------------------------------------------------------------
@@ -528,7 +425,21 @@ const ReturnType = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.ReturnType(value[2]));
+], value => t.ReturnType(value[2]));
+// ------------------------------------------------------------------
+// Argument
+// ------------------------------------------------------------------
+// prettier-ignore
+const Argument = Runtime.Tuple([
+    Runtime.Const('Argument'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], results => {
+    return t.KindGuard.IsLiteralNumber(results[2])
+        ? t.Argument(Math.trunc(results[2].const))
+        : t.Never();
+});
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -538,7 +449,7 @@ const Awaited = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Awaited(value[2]));
+], value => t.Awaited(value[2]));
 // ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
@@ -548,7 +459,7 @@ const Array = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Array(value[2]));
+], value => t.Array(value[2]));
 // ------------------------------------------------------------------
 // Record
 // ------------------------------------------------------------------
@@ -560,7 +471,7 @@ const Record = Runtime.Tuple([
     Runtime.Const(Comma),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Record(value[2], value[4]));
+], value => t.Record(value[2], value[4]));
 // ------------------------------------------------------------------
 // Promise
 // ------------------------------------------------------------------
@@ -570,7 +481,7 @@ const Promise = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Promise(value[2]));
+], value => t.Promise(value[2]));
 // ------------------------------------------------------------------
 // Partial
 // ------------------------------------------------------------------
@@ -580,7 +491,7 @@ const Partial = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Partial(value[2]));
+], value => t.Partial(value[2]));
 // ------------------------------------------------------------------
 // Required
 // ------------------------------------------------------------------
@@ -590,7 +501,7 @@ const Required = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Required(value[2]));
+], value => t.Required(value[2]));
 // ------------------------------------------------------------------
 // Pick
 // ------------------------------------------------------------------
@@ -602,7 +513,7 @@ const Pick = Runtime.Tuple([
     Runtime.Const(Comma),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Pick(value[2], value[4]));
+], value => t.Pick(value[2], value[4]));
 // ------------------------------------------------------------------
 // Omit
 // ------------------------------------------------------------------
@@ -614,7 +525,7 @@ const Omit = Runtime.Tuple([
     Runtime.Const(Comma),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Omit(value[2], value[4]));
+], value => t.Omit(value[2], value[4]));
 // ------------------------------------------------------------------
 // Exclude
 // ------------------------------------------------------------------
@@ -626,7 +537,7 @@ const Exclude = Runtime.Tuple([
     Runtime.Const(Comma),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Exclude(value[2], value[4]));
+], value => t.Exclude(value[2], value[4]));
 // ------------------------------------------------------------------
 // Extract
 // ------------------------------------------------------------------
@@ -638,7 +549,7 @@ const Extract = Runtime.Tuple([
     Runtime.Const(Comma),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Extract(value[2], value[4]));
+], value => t.Extract(value[2], value[4]));
 // ------------------------------------------------------------------
 // Uppercase
 // ------------------------------------------------------------------
@@ -648,7 +559,7 @@ const Uppercase = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Uppercase(value[2]));
+], value => t.Uppercase(value[2]));
 // ------------------------------------------------------------------
 // Lowercase
 // ------------------------------------------------------------------
@@ -658,7 +569,7 @@ const Lowercase = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Lowercase(value[2]));
+], value => t.Lowercase(value[2]));
 // ------------------------------------------------------------------
 // Capitalize
 // ------------------------------------------------------------------
@@ -668,7 +579,7 @@ const Capitalize = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Capitalize(value[2]));
+], value => t.Capitalize(value[2]));
 // ------------------------------------------------------------------
 // Uncapitalize
 // ------------------------------------------------------------------
@@ -678,41 +589,20 @@ const Uncapitalize = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.Uncapitalize(value[2]));
+], value => t.Uncapitalize(value[2]));
 // ------------------------------------------------------------------
 // Date
 // ------------------------------------------------------------------
-const Date = Runtime.Const('Date', Runtime.As(Types.Date()));
+const Date = Runtime.Const('Date', Runtime.As(t.Date()));
 // ------------------------------------------------------------------
 // Uint8Array
 // ------------------------------------------------------------------
-const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(Types.Uint8Array()));
-// ------------------------------------------------------------------
-// Main
-// ------------------------------------------------------------------
-// prettier-ignore
-const Main = Runtime.Union([
-    ModuleDeclaration,
-    TypeAliasDeclaration,
-    InterfaceDeclaration,
-    Type
-]);
+const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(t.Uint8Array()));
 // ------------------------------------------------------------------
 // Module
 // ------------------------------------------------------------------
 // prettier-ignore
 export const Module = new Runtime.Module({
-    // ----------------------------------------------------------------
-    // Modules, Interfaces and Type Aliases
-    // ----------------------------------------------------------------
-    ExportModifier,
-    HeritageList,
-    Heritage,
-    InterfaceDeclaration,
-    TypeAliasDeclaration,
-    ModuleType,
-    ModuleProperties,
-    ModuleDeclaration,
     // ----------------------------------------------------------------
     // Type Expressions
     // ----------------------------------------------------------------
@@ -744,6 +634,7 @@ export const Module = new Runtime.Module({
     Mapped,
     AsyncIterator,
     Iterator,
+    Argument,
     Awaited,
     Array,
     Record,
@@ -764,9 +655,6 @@ export const Module = new Runtime.Module({
     Uncapitalize,
     Date,
     Uint8Array,
+    GenericReference,
     Reference,
-    // ----------------------------------------------------------------
-    // Main
-    // ----------------------------------------------------------------
-    Main
 });