@sinclair/typebox 0.34.14 → 0.34.16

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
 // ------------------------------------------------------------------
@@ -33,126 +33,9 @@ function DestructureRight(values) {
 // Deref
 // ------------------------------------------------------------------
 const Deref = (context, key) => {
-    return key in context ? context[key] : Types.Ref(key);
+    return key in context ? context[key] : t.Ref(key);
 };
 // ------------------------------------------------------------------
-// ExportModifier
-// ------------------------------------------------------------------
-// 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));
-// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 // prettier-ignore
@@ -162,27 +45,27 @@ const Reference = Runtime.Ident((value, context) => Deref(context, value));
 // ------------------------------------------------------------------
 // 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
@@ -273,22 +156,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 +190,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 +232,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 +267,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 +292,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 +321,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 +332,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 +361,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 +371,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 +381,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 +391,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 +401,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 +411,7 @@ const ReturnType = Runtime.Tuple([
     Runtime.Const(LAngle),
     Runtime.Ref('Type'),
     Runtime.Const(RAngle),
-], value => Types.ReturnType(value[2]));
+], value => t.ReturnType(value[2]));
 // ------------------------------------------------------------------
 // Awaited
 // ------------------------------------------------------------------
@@ -538,7 +421,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 +431,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 +443,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 +453,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 +463,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 +473,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 +485,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 +497,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 +509,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 +521,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 +531,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 +541,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 +551,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 +561,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
     // ----------------------------------------------------------------
@@ -765,8 +627,4 @@ export const Module = new Runtime.Module({
     Date,
     Uint8Array,
     Reference,
-    // ----------------------------------------------------------------
-    // Main
-    // ----------------------------------------------------------------
-    Main
 });