@sinclair/typebox 0.33.19 → 0.33.20

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

@@ -0,0 +1,55 @@
+import { Runtime } from './parsebox/index.mjs';
+import * as Types from '../type/index.mjs';
+export declare const Module: Runtime.Module<{
+    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>;
+    KeyOf: Runtime.IUnion<boolean>;
+    IndexArray: Runtime.IUnion<unknown[]>;
+    Extends: Runtime.IUnion<unknown[]>;
+    Base: Runtime.IUnion<unknown>;
+    Factor: Runtime.ITuple<Types.TSchema>;
+    ExprTermTail: Runtime.IUnion<[] | ["&", unknown, unknown]>;
+    ExprTerm: Runtime.ITuple<Types.TSchema>;
+    ExprTail: Runtime.IUnion<[] | ["|", unknown, unknown]>;
+    Expr: Runtime.ITuple<Types.TSchema>;
+    Type: Runtime.IRef<unknown>;
+    PropertyKey: Runtime.IUnion<string>;
+    PropertyReadonly: Runtime.IUnion<boolean>;
+    PropertyOptional: Runtime.IUnion<boolean>;
+    Property: Runtime.ITuple<{
+        [x: string]: Types.TSchema;
+    }>;
+    PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
+    Properties: Runtime.IUnion<unknown[]>;
+    Object: Runtime.ITuple<Types.TObject<Record<string, Types.TSchema>>>;
+    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>>;
+    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>;
+}>;

package/build/esm/parse/runtime.mjs

@@ -0,0 +1,617 @@
+import { Runtime } from './parsebox/index.mjs';
+import * as Types from '../type/index.mjs';
+// ------------------------------------------------------------------
+// Tokens
+// ------------------------------------------------------------------
+const Newline = '\n';
+const LBracket = '[';
+const RBracket = ']';
+const LParen = '(';
+const RParen = ')';
+const LBrace = '{';
+const RBrace = '}';
+const LAngle = '<';
+const RAngle = '>';
+const Question = '?';
+const Colon = ':';
+const Comma = ',';
+const SemiColon = ';';
+const SingleQuote = "'";
+const DoubleQuote = '"';
+const Tilde = '`';
+// ------------------------------------------------------------------
+// DestructureRight
+// ------------------------------------------------------------------
+// prettier-ignore
+function DestructureRight(values) {
+    return (values.length > 0)
+        ? [values.slice(0, values.length - 1), values[values.length - 1]]
+        : [values, undefined];
+}
+// ------------------------------------------------------------------
+// Reference
+// ------------------------------------------------------------------
+// prettier-ignore
+const Reference = Runtime.Ident((value, context) => {
+    return value in context ? context[value] : Types.Ref(value);
+});
+// ------------------------------------------------------------------
+// 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))
+]);
+// ------------------------------------------------------------------
+// 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())),
+]);
+// ------------------------------------------------------------------
+// KeyOf
+// ------------------------------------------------------------------
+// prettier-ignore
+const KeyOfMapping = (values) => (values.length > 0);
+// prettier-ignore
+const KeyOf = Runtime.Union([
+    Runtime.Tuple([Runtime.Const('keyof')]), Runtime.Tuple([])
+], KeyOfMapping);
+// ------------------------------------------------------------------
+// IndexArray
+// ------------------------------------------------------------------
+// prettier-ignore
+const IndexArrayMapping = (values) => (values.length === 4 ? [[values[1]], ...values[3]] :
+    values.length === 3 ? [[], ...values[2]] :
+        []);
+// prettier-ignore
+const IndexArray = Runtime.Union([
+    Runtime.Tuple([Runtime.Const(LBracket), Runtime.Ref('Type'), Runtime.Const(RBracket), Runtime.Ref('IndexArray')]),
+    Runtime.Tuple([Runtime.Const(LBracket), Runtime.Const(RBracket), Runtime.Ref('IndexArray')]),
+    Runtime.Tuple([])
+], value => IndexArrayMapping(value));
+// ------------------------------------------------------------------
+// Extends
+// ------------------------------------------------------------------
+// prettier-ignore
+const ExtendsMapping = (values) => {
+    return values.length === 6
+        ? [values[1], values[3], values[5]]
+        : [];
+};
+// prettier-ignore
+const Extends = Runtime.Union([
+    Runtime.Tuple([Runtime.Const('extends'), Runtime.Ref('Type'), Runtime.Const(Question), Runtime.Ref('Type'), Runtime.Const(Colon), Runtime.Ref('Type')]),
+    Runtime.Tuple([])
+], ExtendsMapping);
+// ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+// prettier-ignore
+const BaseMapping = (values) => {
+    return values.length === 3 ? values[1] : values[0];
+};
+// prettier-ignore
+const Base = Runtime.Union([
+    Runtime.Tuple([
+        Runtime.Const(LParen),
+        Runtime.Ref('Type'),
+        Runtime.Const(RParen)
+    ]),
+    Runtime.Tuple([Runtime.Union([
+            Runtime.Ref('Literal'),
+            Runtime.Ref('Keyword'),
+            Runtime.Ref('Object'),
+            Runtime.Ref('Tuple'),
+            Runtime.Ref('Constructor'),
+            Runtime.Ref('Function'),
+            Runtime.Ref('Mapped'),
+            Runtime.Ref('AsyncIterator'),
+            Runtime.Ref('Iterator'),
+            Runtime.Ref('ConstructorParameters'),
+            Runtime.Ref('FunctionParameters'),
+            Runtime.Ref('InstanceType'),
+            Runtime.Ref('ReturnType'),
+            Runtime.Ref('Awaited'),
+            Runtime.Ref('Array'),
+            Runtime.Ref('Record'),
+            Runtime.Ref('Promise'),
+            Runtime.Ref('Partial'),
+            Runtime.Ref('Required'),
+            Runtime.Ref('Pick'),
+            Runtime.Ref('Omit'),
+            Runtime.Ref('Exclude'),
+            Runtime.Ref('Extract'),
+            Runtime.Ref('Uppercase'),
+            Runtime.Ref('Lowercase'),
+            Runtime.Ref('Capitalize'),
+            Runtime.Ref('Uncapitalize'),
+            Runtime.Ref('Date'),
+            Runtime.Ref('Uint8Array'),
+            Runtime.Ref('Reference')
+        ])])
+], BaseMapping);
+// ------------------------------------------------------------------
+// Factor
+// ------------------------------------------------------------------
+// prettier-ignore
+const FactorExtends = (Type, Extends) => {
+    return Extends.length === 3
+        ? Types.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) ? (Right.length === 1 ? Types.Index(FactorIndexArray(Type, Left), Right[0]) :
+        Right.length === 0 ? Types.Array(FactorIndexArray(Type, Left)) :
+            Types.Never()) : Type);
+};
+// prettier-ignore
+const FactorMapping = (KeyOf, Type, IndexArray, Extends) => {
+    return KeyOf
+        ? FactorExtends(Types.KeyOf(FactorIndexArray(Type, IndexArray)), Extends)
+        : FactorExtends(FactorIndexArray(Type, IndexArray), Extends);
+};
+// prettier-ignore
+const Factor = Runtime.Tuple([
+    Runtime.Ref('KeyOf'),
+    Runtime.Ref('Base'),
+    Runtime.Ref('IndexArray'),
+    Runtime.Ref('Extends')
+], values => FactorMapping(...values));
+// ------------------------------------------------------------------
+// Expr
+// ------------------------------------------------------------------
+// prettier-ignore
+function ExprBinaryMapping(Left, Rest) {
+    return (Rest.length === 3 ? (() => {
+        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]);
+        }
+        if (Operator === '|') {
+            return Types.TypeGuard.IsUnion(Schema)
+                ? Types.Union([Left, ...Schema.anyOf])
+                : Types.Union([Left, Schema]);
+        }
+        throw 1;
+    })() : Left);
+}
+// prettier-ignore
+const ExprTermTail = Runtime.Union([
+    Runtime.Tuple([Runtime.Const('&'), Runtime.Ref('Factor'), Runtime.Ref('ExprTermTail')]),
+    Runtime.Tuple([])
+]);
+// prettier-ignore
+const ExprTerm = Runtime.Tuple([
+    Runtime.Ref('Factor'), Runtime.Ref('ExprTermTail')
+], value => ExprBinaryMapping(...value));
+// prettier-ignore
+const ExprTail = Runtime.Union([
+    Runtime.Tuple([Runtime.Const('|'), Runtime.Ref('ExprTerm'), Runtime.Ref('ExprTail')]),
+    Runtime.Tuple([])
+]);
+// prettier-ignore
+const Expr = Runtime.Tuple([
+    Runtime.Ref('ExprTerm'), Runtime.Ref('ExprTail')
+], value => ExprBinaryMapping(...value));
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+const Type = Runtime.Ref('Expr');
+// ------------------------------------------------------------------
+// Properties
+// ------------------------------------------------------------------
+// prettier-ignore
+const PropertyKey = Runtime.Union([Runtime.Ident(), Runtime.String([SingleQuote, DoubleQuote])]);
+// prettier-ignore
+const PropertyReadonly = Runtime.Union([Runtime.Tuple([Runtime.Const('readonly')]), Runtime.Tuple([])], value => value.length > 0);
+// prettier-ignore
+const PropertyOptional = Runtime.Union([Runtime.Tuple([Runtime.Const(Question)]), Runtime.Tuple([])], value => value.length > 0);
+// prettier-ignore
+const PropertyMapping = (Readonly, Key, Optional, _, Type) => ({
+    [Key]: (Readonly && Optional ? Types.ReadonlyOptional(Type) :
+        Readonly && !Optional ? Types.Readonly(Type) :
+            !Readonly && Optional ? Types.Optional(Type) :
+                Type)
+});
+// prettier-ignore
+const Property = Runtime.Tuple([
+    Runtime.Ref('PropertyReadonly'),
+    Runtime.Ref('PropertyKey'),
+    Runtime.Ref('PropertyOptional'),
+    Runtime.Const(Colon),
+    Runtime.Ref('Type'),
+], value => PropertyMapping(...value));
+// prettier-ignore
+const PropertyDelimiter = Runtime.Union([
+    Runtime.Tuple([Runtime.Const(Comma), Runtime.Const(Newline)]),
+    Runtime.Tuple([Runtime.Const(SemiColon), Runtime.Const(Newline)]),
+    Runtime.Tuple([Runtime.Const(Comma)]),
+    Runtime.Tuple([Runtime.Const(SemiColon)]),
+    Runtime.Tuple([Runtime.Const(Newline)]),
+]);
+// prettier-ignore
+const Properties = Runtime.Union([
+    Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter'), Runtime.Ref('Properties')]),
+    Runtime.Tuple([Runtime.Ref('Property'), Runtime.Ref('PropertyDelimiter')]),
+    Runtime.Tuple([Runtime.Ref('Property')]),
+    Runtime.Tuple([])
+], values => (values.length === 3 ? [values[0], ...values[2]] :
+    values.length === 2 ? [values[0]] :
+        values.length === 1 ? [values[0]] :
+            []));
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+const ObjectMapping = (values) => Types.Object(values.reduce((properties, record) => {
+    return { ...properties, ...record };
+}, {}));
+// prettier-ignore
+const Object = Runtime.Tuple([
+    Runtime.Const(LBrace),
+    Runtime.Ref('Properties'),
+    Runtime.Const(RBrace)
+], values => ObjectMapping(values[1]));
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+const Elements = Runtime.Union([
+    Runtime.Tuple([Runtime.Ref('Type'), Runtime.Const(Comma), Runtime.Ref('Elements')]),
+    Runtime.Tuple([Runtime.Ref('Type'), Runtime.Const(Comma)]),
+    Runtime.Tuple([Runtime.Ref('Type')]),
+    Runtime.Tuple([]),
+], value => (value.length === 3 ? [value[0], ...value[2]] :
+    value.length === 2 ? [value[0]] :
+        value.length === 1 ? [value[0]] :
+            []));
+// prettier-ignore
+const Tuple = Runtime.Tuple([
+    Runtime.Const(LBracket),
+    Runtime.Ref('Elements'),
+    Runtime.Const(RBracket)
+], value => Types.Tuple(value[1]));
+// ------------------------------------------------------------------
+// Parameters
+// ------------------------------------------------------------------
+// prettier-ignore
+const Parameter = Runtime.Tuple([
+    Runtime.Ident(), Runtime.Const(Colon), Runtime.Ref('Type')
+], value => value[2]);
+// prettier-ignore
+const Parameters = Runtime.Union([
+    Runtime.Tuple([Runtime.Ref('Parameter'), Runtime.Const(Comma), Runtime.Ref('Parameters')]),
+    Runtime.Tuple([Runtime.Ref('Parameter'), Runtime.Const(Comma)]),
+    Runtime.Tuple([Runtime.Ref('Parameter')]),
+    Runtime.Tuple([]),
+], value => (value.length === 3 ? [value[0], ...value[2]] :
+    value.length === 2 ? [value[0]] :
+        value.length === 1 ? [value[0]] :
+            []));
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+const Constructor = Runtime.Tuple([
+    Runtime.Const('new'),
+    Runtime.Const(LParen),
+    Runtime.Ref('Parameters'),
+    Runtime.Const(RParen),
+    Runtime.Const('=>'),
+    Runtime.Ref('Type')
+], value => Types.Constructor(value[2], value[5]));
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+const Function = Runtime.Tuple([
+    Runtime.Const(LParen),
+    Runtime.Ref('Parameters'),
+    Runtime.Const(RParen),
+    Runtime.Const('=>'),
+    Runtime.Ref('Type')
+], value => Types.Function(value[1], value[4]));
+// ------------------------------------------------------------------
+// Mapped (requires deferred types)
+// ------------------------------------------------------------------
+// prettier-ignore
+const MappedMapping = (values) => {
+    return Types.Literal('Mapped types not supported');
+};
+// prettier-ignore
+const Mapped = Runtime.Tuple([
+    Runtime.Const(LBrace), Runtime.Const(LBracket), Runtime.Ident(), Runtime.Const('in'), Runtime.Ref('Type'), Runtime.Const(RBracket), Runtime.Const(Colon), Runtime.Ref('Type'), Runtime.Const(RBrace)
+], MappedMapping);
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+const AsyncIterator = Runtime.Tuple([
+    Runtime.Const('AsyncIterator'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.AsyncIterator(value[2]));
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+const Iterator = Runtime.Tuple([
+    Runtime.Const('Iterator'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Iterator(value[2]));
+// ------------------------------------------------------------------
+// ConstructorParameters
+// ------------------------------------------------------------------
+// prettier-ignore
+const ConstructorParameters = Runtime.Tuple([
+    Runtime.Const('ConstructorParameters'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.ConstructorParameters(value[2]));
+// ------------------------------------------------------------------
+// Parameters
+// ------------------------------------------------------------------
+// prettier-ignore
+const FunctionParameters = Runtime.Tuple([
+    Runtime.Const('Parameters'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Parameters(value[2]));
+// ------------------------------------------------------------------
+// InstanceType
+// ------------------------------------------------------------------
+// prettier-ignore
+const InstanceType = Runtime.Tuple([
+    Runtime.Const('InstanceType'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.InstanceType(value[2]));
+// ------------------------------------------------------------------
+// ReturnType
+// ------------------------------------------------------------------
+// prettier-ignore
+const ReturnType = Runtime.Tuple([
+    Runtime.Const('ReturnType'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.ReturnType(value[2]));
+// ------------------------------------------------------------------
+// Awaited
+// ------------------------------------------------------------------
+// prettier-ignore
+const Awaited = Runtime.Tuple([
+    Runtime.Const('Awaited'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Awaited(value[2]));
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+const Array = Runtime.Tuple([
+    Runtime.Const('Array'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Array(value[2]));
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+const Record = Runtime.Tuple([
+    Runtime.Const('Record'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(Comma),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Record(value[2], value[4]));
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+const Promise = Runtime.Tuple([
+    Runtime.Const('Promise'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Promise(value[2]));
+// ------------------------------------------------------------------
+// Partial
+// ------------------------------------------------------------------
+// prettier-ignore
+const Partial = Runtime.Tuple([
+    Runtime.Const('Partial'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Partial(value[2]));
+// ------------------------------------------------------------------
+// Required
+// ------------------------------------------------------------------
+// prettier-ignore
+const Required = Runtime.Tuple([
+    Runtime.Const('Required'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Required(value[2]));
+// ------------------------------------------------------------------
+// Pick
+// ------------------------------------------------------------------
+// prettier-ignore
+const Pick = Runtime.Tuple([
+    Runtime.Const('Pick'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(Comma),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Pick(value[2], value[4]));
+// ------------------------------------------------------------------
+// Omit
+// ------------------------------------------------------------------
+// prettier-ignore
+const Omit = Runtime.Tuple([
+    Runtime.Const('Omit'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(Comma),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Omit(value[2], value[4]));
+// ------------------------------------------------------------------
+// Exclude
+// ------------------------------------------------------------------
+// prettier-ignore
+const Exclude = Runtime.Tuple([
+    Runtime.Const('Exclude'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(Comma),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Exclude(value[2], value[4]));
+// ------------------------------------------------------------------
+// Extract
+// ------------------------------------------------------------------
+// prettier-ignore
+const Extract = Runtime.Tuple([
+    Runtime.Const('Extract'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(Comma),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Extract(value[2], value[4]));
+// ------------------------------------------------------------------
+// Uppercase
+// ------------------------------------------------------------------
+// prettier-ignore
+const Uppercase = Runtime.Tuple([
+    Runtime.Const('Uppercase'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Uppercase(value[2]));
+// ------------------------------------------------------------------
+// Lowercase
+// ------------------------------------------------------------------
+// prettier-ignore
+const Lowercase = Runtime.Tuple([
+    Runtime.Const('Lowercase'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Lowercase(value[2]));
+// ------------------------------------------------------------------
+// Capitalize
+// ------------------------------------------------------------------
+// prettier-ignore
+const Capitalize = Runtime.Tuple([
+    Runtime.Const('Capitalize'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Capitalize(value[2]));
+// ------------------------------------------------------------------
+// Uncapitalize
+// ------------------------------------------------------------------
+// prettier-ignore
+const Uncapitalize = Runtime.Tuple([
+    Runtime.Const('Uncapitalize'),
+    Runtime.Const(LAngle),
+    Runtime.Ref('Type'),
+    Runtime.Const(RAngle),
+], value => Types.Uncapitalize(value[2]));
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+const Date = Runtime.Const('Date', Runtime.As(Types.Date()));
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+const Uint8Array = Runtime.Const('Uint8Array', Runtime.As(Types.Uint8Array()));
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+// prettier-ignore
+export const Module = new Runtime.Module({
+    Literal,
+    Keyword,
+    KeyOf,
+    IndexArray,
+    Extends,
+    Base,
+    Factor,
+    ExprTermTail,
+    ExprTerm,
+    ExprTail,
+    Expr,
+    Type,
+    PropertyKey,
+    PropertyReadonly,
+    PropertyOptional,
+    Property,
+    PropertyDelimiter,
+    Properties,
+    Object,
+    Elements,
+    Tuple,
+    Parameter,
+    Function,
+    Parameters,
+    Constructor,
+    Mapped,
+    AsyncIterator,
+    Iterator,
+    Awaited,
+    Array,
+    Record,
+    Promise,
+    ConstructorParameters,
+    FunctionParameters,
+    InstanceType,
+    ReturnType,
+    Partial,
+    Required,
+    Pick,
+    Omit,
+    Exclude,
+    Extract,
+    Uppercase,
+    Lowercase,
+    Capitalize,
+    Uncapitalize,
+    Date,
+    Uint8Array,
+    Reference
+});