@sinclair/typebox 0.34.15 → 0.34.16

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

@@ -1,5 +1,5 @@
-import { Static } from './parsebox/index.mjs';
-import * as Types from '../type/index.mjs';
+import { Static } from '../parser/index.mjs';
+import * as t from '../type/index.mjs';
 type Newline = '\n';
 type LBracket = '[';
 type RBracket = ']';
@@ -16,7 +16,6 @@ type SemiColon = ';';
 type SingleQuote = "'";
 type DoubleQuote = '"';
 type Tilde = '`';
-type Equals = '=';
 interface DelimitTailMapping<_ = unknown> extends Static.IMapping {
     output: (this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer I, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, I, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer H, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, H, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer G, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, G, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer F, _, infer Rest extends unknown[]] ? [A, B, C, D, E, F, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer E, _, infer Rest extends unknown[]] ? [A, B, C, D, E, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer D, _, infer Rest extends unknown[]] ? [A, B, C, D, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer C, _, infer Rest extends unknown[]] ? [A, B, C, ...Rest] : this['input'] extends [_, infer A, _, infer B, _, infer Rest extends unknown[]] ? [A, B, ...Rest] : this['input'] extends [_, infer A, _, infer Rest extends unknown[]] ? [A, ...Rest] : this['input'] extends [_, infer Rest extends unknown[]] ? [...Rest] : this['input'] extends [_] ? [] : [
     ]);
@@ -42,98 +41,19 @@ type Delimit<Parser extends Static.IParser, Delimiter extends Static.IParser> =
     Static.Tuple<[Parser, DelimitTail<Parser, Delimiter>]>,
     Static.Tuple<[]>
 ], DelimitMapping>);
-type Deref<Context extends Types.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : Types.TRef<Ref>);
-interface ExportModifierMapping extends Static.IMapping {
-    output: this['input'] extends [string] ? true : false;
-}
-type ExportModifier = Static.Union<[
-    Static.Tuple<[Static.Const<'export'>]>,
-    Static.Tuple<[]>
-], ExportModifierMapping>;
-interface TypeAliasDeclarationMapping extends Static.IMapping {
-    output: this['input'] extends [infer _Export extends boolean, 'type', infer Ident extends string, Equals, infer Type extends Types.TSchema] ? {
-        [_ in Ident]: Type;
-    } : never;
-}
-type TypeAliasDeclaration = Static.Tuple<[
-    ExportModifier,
-    Static.Const<'type'>,
-    Static.Ident,
-    Static.Const<Equals>,
-    Type
-], TypeAliasDeclarationMapping>;
-type HeritageListDelimiter = Static.Union<[Static.Tuple<[Static.Const<Comma>, Static.Const<Newline>]>, Static.Tuple<[Static.Const<Comma>]>]>;
-type HeritageListReduce<Values extends string[], Context extends Types.TProperties, Result extends Types.TSchema[] = []> = (Values extends [infer Ref extends string, ...infer Rest extends string[]] ? HeritageListReduce<Rest, Context, [...Result, Deref<Context, Ref>]> : Result);
-interface HeritageListMapping extends Static.IMapping {
-    output: (this['context'] extends Types.TProperties ? this['input'] extends string[] ? HeritageListReduce<this['input'], this['context']> : [] : []);
-}
-type HeritageList = Static.Union<[Delimit<Static.Ident, HeritageListDelimiter>], HeritageListMapping>;
-interface HeritageMapping extends Static.IMapping {
-    output: this['input'] extends ['extends', infer List extends Types.TSchema[]] ? List : [];
-}
-type Heritage = Static.Union<[
-    Static.Tuple<[Static.Const<'extends'>, HeritageList]>,
-    Static.Tuple<[]>
-], HeritageMapping>;
-interface InterfaceDeclarationMapping extends Static.IMapping {
-    output: this['input'] extends [boolean, 'interface', infer Ident extends string, infer Heritage extends Types.TSchema[], LBrace, infer Properties extends Types.TProperties, RBrace] ? {
-        [_ in Ident]: Types.TIntersectEvaluated<[...Heritage, Types.TObject<Properties>]>;
-    } : never;
-}
-type InterfaceDeclaration = Static.Tuple<[
-    ExportModifier,
-    Static.Const<'interface'>,
-    Static.Ident,
-    Heritage,
-    Static.Const<LBrace>,
-    Properties,
-    Static.Const<RBrace>
-], InterfaceDeclarationMapping>;
-type ModuleType = Static.Union<[
-    InterfaceDeclaration,
-    TypeAliasDeclaration
-]>;
-type ModulePropertiesDelimiter = Static.Union<[
-    Static.Tuple<[Static.Const<SemiColon>, Static.Const<Newline>]>,
-    Static.Tuple<[Static.Const<SemiColon>]>,
-    Static.Tuple<[Static.Const<Newline>]>
-]>;
-type ModulePropertiesReduce<Value extends unknown[], Result extends Types.TProperties = {}> = (Value extends [infer ModuleType extends Types.TProperties, unknown[], ...infer Rest extends unknown[]] ? ModulePropertiesReduce<Rest, Result & ModuleType> : Value extends [infer ModuleType extends Types.TProperties] ? ModulePropertiesReduce<[], Result & ModuleType> : Types.Evaluate<Result>);
-interface ModulePropertiesMapping extends Static.IMapping {
-    output: this['input'] extends unknown[] ? ModulePropertiesReduce<this['input']> : never;
-}
-type ModuleProperties = Static.Union<[
-    Static.Tuple<[ModuleType, ModulePropertiesDelimiter, ModuleProperties]>,
-    Static.Tuple<[ModuleType]>,
-    Static.Tuple<[]>
-], ModulePropertiesMapping>;
-type ModuleIdentifier = Static.Union<[
-    Static.Tuple<[Static.Ident]>,
-    Static.Tuple<[]>
-]>;
-interface ModuleDeclarationMapping extends Static.IMapping {
-    output: this['input'] extends [boolean, 'module', infer _Ident extends string[], LBrace, infer Properties extends Types.TProperties, RBrace] ? Types.TModule<Properties> : never;
-}
-type ModuleDeclaration = Static.Tuple<[
-    ExportModifier,
-    Static.Const<'module'>,
-    ModuleIdentifier,
-    Static.Const<LBrace>,
-    ModuleProperties,
-    Static.Const<RBrace>
-], ModuleDeclarationMapping>;
+type Deref<Context extends t.TProperties, Ref extends string> = (Ref extends keyof Context ? Context[Ref] : t.TRef<Ref>);
 interface ReferenceMapping extends Static.IMapping {
-    output: this['context'] extends Types.TProperties ? this['input'] extends string ? Deref<this['context'], this['input']> : never : never;
+    output: this['context'] extends t.TProperties ? this['input'] extends string ? Deref<this['context'], this['input']> : never : never;
 }
 type Reference = Static.Ident<ReferenceMapping>;
 interface LiteralBooleanMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends boolean}` ? Types.TLiteral<S> : never;
+    output: this['input'] extends `${infer S extends boolean}` ? t.TLiteral<S> : never;
 }
 interface LiteralNumberMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends number}` ? Types.TLiteral<S> : never;
+    output: this['input'] extends `${infer S extends number}` ? t.TLiteral<S> : never;
 }
 interface LiteralStringMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends string}` ? Types.TLiteral<S> : never;
+    output: this['input'] extends `${infer S extends string}` ? t.TLiteral<S> : never;
 }
 type Literal = Static.Union<[
     Static.Union<[Static.Const<'true'>, Static.Const<'false'>], LiteralBooleanMapping>,
@@ -141,18 +61,18 @@ type Literal = Static.Union<[
     Static.String<[DoubleQuote, SingleQuote, Tilde], LiteralStringMapping>
 ]>;
 type Keyword = Static.Union<[
-    Static.Const<'any', Static.As<Types.TAny>>,
-    Static.Const<'bigint', Static.As<Types.TBigInt>>,
-    Static.Const<'boolean', Static.As<Types.TBoolean>>,
-    Static.Const<'integer', Static.As<Types.TInteger>>,
-    Static.Const<'never', Static.As<Types.TNever>>,
-    Static.Const<'null', Static.As<Types.TNull>>,
-    Static.Const<'number', Static.As<Types.TNumber>>,
-    Static.Const<'string', Static.As<Types.TString>>,
-    Static.Const<'symbol', Static.As<Types.TSymbol>>,
-    Static.Const<'undefined', Static.As<Types.TUndefined>>,
-    Static.Const<'unknown', Static.As<Types.TUnknown>>,
-    Static.Const<'void', Static.As<Types.TVoid>>
+    Static.Const<'any', Static.As<t.TAny>>,
+    Static.Const<'bigint', Static.As<t.TBigInt>>,
+    Static.Const<'boolean', Static.As<t.TBoolean>>,
+    Static.Const<'integer', Static.As<t.TInteger>>,
+    Static.Const<'never', Static.As<t.TNever>>,
+    Static.Const<'null', Static.As<t.TNull>>,
+    Static.Const<'number', Static.As<t.TNumber>>,
+    Static.Const<'string', Static.As<t.TString>>,
+    Static.Const<'symbol', Static.As<t.TSymbol>>,
+    Static.Const<'undefined', Static.As<t.TUndefined>>,
+    Static.Const<'unknown', Static.As<t.TUnknown>>,
+    Static.Const<'void', Static.As<t.TVoid>>
 ]>;
 interface KeyOfMapping extends Static.IMapping {
     output: this['input'] extends [] ? false : true;
@@ -162,7 +82,7 @@ type KeyOf = Static.Union<[
     Static.Tuple<[]>
 ], KeyOfMapping>;
 interface IndexArrayMapping extends Static.IMapping {
-    output: (this['input'] extends [LBracket, infer Type extends Types.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] : this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] : [
+    output: (this['input'] extends [LBracket, infer Type extends t.TSchema, RBracket, infer Rest extends unknown[]] ? [[Type], ...Rest] : this['input'] extends [LBracket, RBracket, infer Rest extends unknown[]] ? [[], ...Rest] : [
     ]);
 }
 type IndexArray = Static.Union<[
@@ -171,14 +91,14 @@ type IndexArray = Static.Union<[
     Static.Tuple<[]>
 ], IndexArrayMapping>;
 interface ExtendsMapping extends Static.IMapping {
-    output: this['input'] extends ['extends', infer Type extends Types.TSchema, Question, infer True extends Types.TSchema, Colon, infer False extends Types.TSchema] ? [Type, True, False] : [];
+    output: this['input'] extends ['extends', infer Type extends t.TSchema, Question, infer True extends t.TSchema, Colon, infer False extends t.TSchema] ? [Type, True, False] : [];
 }
 type Extends = Static.Union<[
     Static.Tuple<[Static.Const<'extends'>, Type, Static.Const<Question>, Type, Static.Const<Colon>, Type]>,
     Static.Tuple<[]>
 ], ExtendsMapping>;
 interface BaseMapping extends Static.IMapping {
-    output: (this['input'] extends [LParen, infer Type extends Types.TSchema, RParen] ? Type : this['input'] extends [infer Type extends Types.TSchema] ? Type : never);
+    output: (this['input'] extends [LParen, infer Type extends t.TSchema, RParen] ? Type : this['input'] extends [infer Type extends t.TSchema] ? Type : never);
 }
 type Base = Static.Union<[
     Static.Tuple<[
@@ -221,10 +141,10 @@ type Base = Static.Union<[
         ]>
     ]>
 ], BaseMapping>;
-type FactorExtends<Type extends Types.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends Types.TSchema, infer True extends Types.TSchema, infer False extends Types.TSchema] ? Types.TExtends<Type, Right, True, False> : Type);
-type FactorIndexArray<Type extends Types.TSchema, IndexArray extends unknown[]> = (IndexArray extends [...infer Left extends unknown[], infer Right extends Types.TSchema[]] ? (Right extends [infer Indexer extends Types.TSchema] ? Types.TIndex<FactorIndexArray<Type, Left>, Types.TIndexPropertyKeys<Indexer>> : Right extends [] ? Types.TArray<FactorIndexArray<Type, Left>> : Types.TNever) : Type);
+type FactorExtends<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);
+type FactorIndexArray<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<FactorIndexArray<Type, Left>, t.TIndexPropertyKeys<Indexer>> : Right extends [] ? t.TArray<FactorIndexArray<Type, Left>> : t.TNever) : Type);
 interface FactorMapping extends Static.IMapping {
-    output: this['input'] extends [infer KeyOf extends boolean, infer Type extends Types.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]] ? KeyOf extends true ? FactorExtends<Types.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends> : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends> : never;
+    output: this['input'] extends [infer KeyOf extends boolean, infer Type extends t.TSchema, infer IndexArray extends unknown[], infer Extends extends unknown[]] ? KeyOf extends true ? FactorExtends<t.TKeyOf<FactorIndexArray<Type, IndexArray>>, Extends> : FactorExtends<FactorIndexArray<Type, IndexArray>, Extends> : never;
 }
 type Factor = Static.Tuple<[
     KeyOf,
@@ -232,9 +152,9 @@ type Factor = Static.Tuple<[
     IndexArray,
     Extends
 ], FactorMapping>;
-type ExprBinaryReduce<Left extends Types.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends Types.TSchema, infer Next extends unknown[]] ? (ExprBinaryReduce<Right, Next> extends infer Schema extends Types.TSchema ? (Operator extends '&' ? (Schema extends Types.TIntersect<infer Types extends Types.TSchema[]> ? Types.TIntersect<[Left, ...Types]> : Types.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends Types.TUnion<infer Types extends Types.TSchema[]> ? Types.TUnion<[Left, ...Types]> : Types.TUnion<[Left, Schema]>) : never) : never) : Left);
+type ExprBinaryReduce<Left extends t.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends t.TSchema, infer Next extends unknown[]] ? (ExprBinaryReduce<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);
 interface ExprBinaryMapping extends Static.IMapping {
-    output: (this['input'] extends [infer Left extends Types.TSchema, infer Rest extends unknown[]] ? ExprBinaryReduce<Left, Rest> : []);
+    output: (this['input'] extends [infer Left extends t.TSchema, infer Rest extends unknown[]] ? ExprBinaryReduce<Left, Rest> : []);
 }
 type ExprTermTail = Static.Union<[
     Static.Tuple<[Static.Const<'&'>, Factor, ExprTermTail]>,
@@ -252,7 +172,7 @@ type Expr = Static.Tuple<[
     ExprTerm,
     ExprTail
 ], ExprBinaryMapping>;
-type Type = Expr;
+export type Type = Expr;
 interface PropertyKeyStringMapping extends Static.IMapping {
     output: this['input'];
 }
@@ -267,17 +187,17 @@ interface OptionalMapping extends Static.IMapping {
 }
 type Optional = Static.Union<[Static.Tuple<[Static.Const<Question>]>, Static.Tuple<[]>], OptionalMapping>;
 interface PropertyMapping extends Static.IMapping {
-    output: this['input'] extends [infer IsReadonly extends boolean, infer Key extends string, infer IsOptional extends boolean, string, infer Type extends Types.TSchema] ? {
+    output: this['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] ? Types.TReadonlyOptional<Type> : [
+        ] extends [true, true] ? t.TReadonlyOptional<Type> : [
             IsReadonly,
             IsOptional
-        ] extends [true, false] ? Types.TReadonly<Type> : [
+        ] extends [true, false] ? t.TReadonly<Type> : [
             IsReadonly,
             IsOptional
-        ] extends [false, true] ? Types.TOptional<Type> : Type);
+        ] extends [false, true] ? t.TOptional<Type> : Type);
     } : never;
 }
 type Property = Static.Tuple<[Readonly, PropertyKey, Optional, Static.Const<Colon>, Type], PropertyMapping>;
@@ -288,13 +208,13 @@ type PropertyDelimiter = Static.Union<[
     Static.Tuple<[Static.Const<SemiColon>]>,
     Static.Tuple<[Static.Const<Newline>]>
 ]>;
-type PropertiesReduce<PropertiesArray extends Types.TProperties[], Result extends Types.TProperties = {}> = (PropertiesArray extends [infer Left extends Types.TProperties, ...infer Right extends Types.TProperties[]] ? PropertiesReduce<Right, Types.Evaluate<Result & Left>> : Result);
+type PropertiesReduce<PropertiesArray extends t.TProperties[], Result extends t.TProperties = {}> = (PropertiesArray extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]] ? PropertiesReduce<Right, t.Evaluate<Result & Left>> : Result);
 interface PropertiesMapping extends Static.IMapping {
-    output: this['input'] extends Types.TProperties[] ? PropertiesReduce<this['input']> : never;
+    output: this['input'] extends t.TProperties[] ? PropertiesReduce<this['input']> : never;
 }
 type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], PropertiesMapping>;
 interface ObjectMapping extends Static.IMapping {
-    output: this['input'] extends [unknown, infer Properties extends Types.TProperties, unknown] ? Types.TObject<Properties> : never;
+    output: this['input'] extends [unknown, infer Properties extends t.TProperties, unknown] ? t.TObject<Properties> : never;
 }
 type Object = Static.Tuple<[
     Static.Const<LBrace>,
@@ -303,7 +223,7 @@ type Object = Static.Tuple<[
 ], ObjectMapping>;
 type Elements = Delimit<Type, Static.Const<Comma>>;
 interface TupleMapping extends Static.IMapping {
-    output: this['input'] extends [unknown, infer Elements extends Types.TSchema[], unknown] ? Types.TTuple<Elements> : never;
+    output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] ? t.TTuple<Elements> : never;
 }
 type Tuple = Static.Tuple<[
     Static.Const<LBracket>,
@@ -311,7 +231,7 @@ type Tuple = Static.Tuple<[
     Static.Const<RBracket>
 ], TupleMapping>;
 interface ParameterMapping extends Static.IMapping {
-    output: this['input'] extends [string, Colon, infer Type extends Types.TSchema] ? Type : never;
+    output: this['input'] extends [string, Colon, infer Type extends t.TSchema] ? Type : never;
 }
 type Parameter = Static.Tuple<[
     Static.Ident,
@@ -320,7 +240,7 @@ type Parameter = Static.Tuple<[
 ], ParameterMapping>;
 type Parameters = Delimit<Parameter, Static.Const<Comma>>;
 interface FunctionMapping extends Static.IMapping {
-    output: this['input'] extends [LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer ReturnType extends Types.TSchema] ? Types.TFunction<Parameters, ReturnType> : never;
+    output: this['input'] extends [LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema] ? t.TFunction<Parameters, ReturnType> : never;
 }
 type Function = Static.Tuple<[
     Static.Const<LParen>,
@@ -330,7 +250,7 @@ type Function = Static.Tuple<[
     Type
 ], FunctionMapping>;
 interface ConstructorMapping extends Static.IMapping {
-    output: this['input'] extends ['new', LParen, infer Parameters extends Types.TSchema[], RParen, '=>', infer InstanceType extends Types.TSchema] ? Types.TConstructor<Parameters, InstanceType> : never;
+    output: this['input'] extends ['new', LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema] ? t.TConstructor<Parameters, InstanceType> : never;
 }
 type Constructor = Static.Tuple<[
     Static.Const<'new'>,
@@ -341,7 +261,7 @@ type Constructor = Static.Tuple<[
     Type
 ], ConstructorMapping>;
 interface MappedMapping extends Static.IMapping {
-    output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends Types.TSchema, RBracket, Colon, infer Type extends Types.TSchema, RBrace] ? Types.TLiteral<'Mapped types not supported'> : this['input'];
+    output: this['input'] extends [LBrace, LBracket, infer _Key extends string, 'in', infer _Right extends t.TSchema, RBracket, Colon, infer Type extends t.TSchema, RBrace] ? t.TLiteral<'Mapped types not supported'> : this['input'];
 }
 type Mapped = Static.Tuple<[
     Static.Const<LBrace>,
@@ -355,7 +275,7 @@ type Mapped = Static.Tuple<[
     Static.Const<RBrace>
 ], MappedMapping>;
 interface ArrayMapping extends Static.IMapping {
-    output: this['input'] extends ['Array', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TArray<Type> : never;
+    output: this['input'] extends ['Array', LAngle, infer Type extends t.TSchema, RAngle] ? t.TArray<Type> : never;
 }
 type Array = Static.Tuple<[
     Static.Const<'Array'>,
@@ -364,7 +284,7 @@ type Array = Static.Tuple<[
     Static.Const<RAngle>
 ], ArrayMapping>;
 interface AsyncIteratorMapping extends Static.IMapping {
-    output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TAsyncIterator<Type> : never;
+    output: this['input'] extends ['AsyncIterator', LAngle, infer Type extends t.TSchema, RAngle] ? t.TAsyncIterator<Type> : never;
 }
 type AsyncIterator = Static.Tuple<[
     Static.Const<'AsyncIterator'>,
@@ -373,7 +293,7 @@ type AsyncIterator = Static.Tuple<[
     Static.Const<RAngle>
 ], AsyncIteratorMapping>;
 interface IteratorMapping extends Static.IMapping {
-    output: this['input'] extends ['Iterator', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TIterator<Type> : never;
+    output: this['input'] extends ['Iterator', LAngle, infer Type extends t.TSchema, RAngle] ? t.TIterator<Type> : never;
 }
 type Iterator = Static.Tuple<[
     Static.Const<'Iterator'>,
@@ -382,7 +302,7 @@ type Iterator = Static.Tuple<[
     Static.Const<RAngle>
 ], IteratorMapping>;
 interface ConstructorParametersMapping extends Static.IMapping {
-    output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends Types.TConstructor, RAngle] ? Types.TConstructorParameters<Type> : never;
+    output: this['input'] extends ['ConstructorParameters', LAngle, infer Type extends t.TSchema, RAngle] ? t.TConstructorParameters<Type> : never;
 }
 type ConstructorParameters = Static.Tuple<[
     Static.Const<'ConstructorParameters'>,
@@ -391,7 +311,7 @@ type ConstructorParameters = Static.Tuple<[
     Static.Const<RAngle>
 ], ConstructorParametersMapping>;
 interface FunctionParametersMapping extends Static.IMapping {
-    output: this['input'] extends ['Parameters', LAngle, infer Type extends Types.TFunction, RAngle] ? Types.TParameters<Type> : never;
+    output: this['input'] extends ['Parameters', LAngle, infer Type extends t.TSchema, RAngle] ? t.TParameters<Type> : never;
 }
 type FunctionParameters = Static.Tuple<[
     Static.Const<'Parameters'>,
@@ -400,7 +320,7 @@ type FunctionParameters = Static.Tuple<[
     Static.Const<RAngle>
 ], FunctionParametersMapping>;
 interface InstanceTypeMapping extends Static.IMapping {
-    output: this['input'] extends ['InstanceType', LAngle, infer Type extends Types.TConstructor, RAngle] ? Types.TInstanceType<Type> : never;
+    output: this['input'] extends ['InstanceType', LAngle, infer Type extends t.TSchema, RAngle] ? t.TInstanceType<Type> : never;
 }
 type InstanceType = Static.Tuple<[
     Static.Const<'InstanceType'>,
@@ -409,7 +329,7 @@ type InstanceType = Static.Tuple<[
     Static.Const<RAngle>
 ], InstanceTypeMapping>;
 interface ReturnTypeMapping extends Static.IMapping {
-    output: this['input'] extends ['ReturnType', LAngle, infer Type extends Types.TFunction, RAngle] ? Types.TReturnType<Type> : never;
+    output: this['input'] extends ['ReturnType', LAngle, infer Type extends t.TSchema, RAngle] ? t.TReturnType<Type> : never;
 }
 type ReturnType = Static.Tuple<[
     Static.Const<'ReturnType'>,
@@ -418,7 +338,7 @@ type ReturnType = Static.Tuple<[
     Static.Const<RAngle>
 ], ReturnTypeMapping>;
 interface AwaitedMapping extends Static.IMapping {
-    output: this['input'] extends ['Awaited', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TAwaited<Type> : never;
+    output: this['input'] extends ['Awaited', LAngle, infer Type extends t.TSchema, RAngle] ? t.TAwaited<Type> : never;
 }
 type Awaited = Static.Tuple<[
     Static.Const<'Awaited'>,
@@ -427,7 +347,7 @@ type Awaited = Static.Tuple<[
     Static.Const<RAngle>
 ], AwaitedMapping>;
 interface PromiseMapping extends Static.IMapping {
-    output: this['input'] extends ['Promise', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TPromise<Type> : never;
+    output: this['input'] extends ['Promise', LAngle, infer Type extends t.TSchema, RAngle] ? t.TPromise<Type> : never;
 }
 type Promise = Static.Tuple<[
     Static.Const<'Promise'>,
@@ -436,7 +356,7 @@ type Promise = Static.Tuple<[
     Static.Const<RAngle>
 ], PromiseMapping>;
 interface RecordMapping extends Static.IMapping {
-    output: this['input'] extends ['Record', LAngle, infer Key extends Types.TSchema, Comma, infer Type extends Types.TSchema, RAngle] ? Types.TRecord<Key, Type> : never;
+    output: this['input'] extends ['Record', LAngle, infer Key extends t.TSchema, Comma, infer Type extends t.TSchema, RAngle] ? t.TRecord<Key, Type> : never;
 }
 type Record = Static.Tuple<[
     Static.Const<'Record'>,
@@ -447,7 +367,7 @@ type Record = Static.Tuple<[
     Static.Const<RAngle>
 ], RecordMapping>;
 interface PartialMapping extends Static.IMapping {
-    output: this['input'] extends ['Partial', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TPartial<Type> : never;
+    output: this['input'] extends ['Partial', LAngle, infer Type extends t.TSchema, RAngle] ? t.TPartial<Type> : never;
 }
 type Partial = Static.Tuple<[
     Static.Const<'Partial'>,
@@ -456,7 +376,7 @@ type Partial = Static.Tuple<[
     Static.Const<RAngle>
 ], PartialMapping>;
 interface RequiredMapping extends Static.IMapping {
-    output: this['input'] extends ['Required', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TRequired<Type> : never;
+    output: this['input'] extends ['Required', LAngle, infer Type extends t.TSchema, RAngle] ? t.TRequired<Type> : never;
 }
 type Required = Static.Tuple<[
     Static.Const<'Required'>,
@@ -465,7 +385,7 @@ type Required = Static.Tuple<[
     Static.Const<RAngle>
 ], RequiredMapping>;
 interface PickMapping extends Static.IMapping {
-    output: this['input'] extends ['Pick', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TPick<Type, Key> : never;
+    output: this['input'] extends ['Pick', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle] ? t.TPick<Type, Key> : never;
 }
 type Pick = Static.Tuple<[
     Static.Const<'Pick'>,
@@ -476,7 +396,7 @@ type Pick = Static.Tuple<[
     Static.Const<RAngle>
 ], PickMapping>;
 interface OmitMapping extends Static.IMapping {
-    output: this['input'] extends ['Omit', LAngle, infer Type extends Types.TSchema, Comma, infer Key extends Types.TSchema, RAngle] ? Types.TOmit<Type, Key> : never;
+    output: this['input'] extends ['Omit', LAngle, infer Type extends t.TSchema, Comma, infer Key extends t.TSchema, RAngle] ? t.TOmit<Type, Key> : never;
 }
 type Omit = Static.Tuple<[
     Static.Const<'Omit'>,
@@ -487,7 +407,7 @@ type Omit = Static.Tuple<[
     Static.Const<RAngle>
 ], OmitMapping>;
 interface ExcludeMapping extends Static.IMapping {
-    output: this['input'] extends ['Exclude', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TExclude<Type, PropertyKey> : never;
+    output: this['input'] extends ['Exclude', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle] ? t.TExclude<Type, PropertyKey> : never;
 }
 type Exclude = Static.Tuple<[
     Static.Const<'Exclude'>,
@@ -498,7 +418,7 @@ type Exclude = Static.Tuple<[
     Static.Const<RAngle>
 ], ExcludeMapping>;
 interface ExtractMapping extends Static.IMapping {
-    output: this['input'] extends ['Extract', LAngle, infer Type extends Types.TSchema, Comma, infer PropertyKey extends Types.TSchema, RAngle] ? Types.TExtract<Type, PropertyKey> : never;
+    output: this['input'] extends ['Extract', LAngle, infer Type extends t.TSchema, Comma, infer PropertyKey extends t.TSchema, RAngle] ? t.TExtract<Type, PropertyKey> : never;
 }
 type Extract = Static.Tuple<[
     Static.Const<'Extract'>,
@@ -509,7 +429,7 @@ type Extract = Static.Tuple<[
     Static.Const<RAngle>
 ], ExtractMapping>;
 interface UppercaseMapping extends Static.IMapping {
-    output: this['input'] extends ['Uppercase', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TUppercase<Type> : never;
+    output: this['input'] extends ['Uppercase', LAngle, infer Type extends t.TSchema, RAngle] ? t.TUppercase<Type> : never;
 }
 type Uppercase = Static.Tuple<[
     Static.Const<'Uppercase'>,
@@ -518,7 +438,7 @@ type Uppercase = Static.Tuple<[
     Static.Const<RAngle>
 ], UppercaseMapping>;
 interface LowercaseMapping extends Static.IMapping {
-    output: this['input'] extends ['Lowercase', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TLowercase<Type> : never;
+    output: this['input'] extends ['Lowercase', LAngle, infer Type extends t.TSchema, RAngle] ? t.TLowercase<Type> : never;
 }
 type Lowercase = Static.Tuple<[
     Static.Const<'Lowercase'>,
@@ -527,7 +447,7 @@ type Lowercase = Static.Tuple<[
     Static.Const<RAngle>
 ], LowercaseMapping>;
 interface CapitalizeMapping extends Static.IMapping {
-    output: this['input'] extends ['Capitalize', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TCapitalize<Type> : never;
+    output: this['input'] extends ['Capitalize', LAngle, infer Type extends t.TSchema, RAngle] ? t.TCapitalize<Type> : never;
 }
 type Capitalize = Static.Tuple<[
     Static.Const<'Capitalize'>,
@@ -536,7 +456,7 @@ type Capitalize = Static.Tuple<[
     Static.Const<RAngle>
 ], CapitalizeMapping>;
 interface UncapitalizeMapping extends Static.IMapping {
-    output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends Types.TSchema, RAngle] ? Types.TUncapitalize<Type> : never;
+    output: this['input'] extends ['Uncapitalize', LAngle, infer Type extends t.TSchema, RAngle] ? t.TUncapitalize<Type> : never;
 }
 type Uncapitalize = Static.Tuple<[
     Static.Const<'Uncapitalize'>,
@@ -544,12 +464,6 @@ type Uncapitalize = Static.Tuple<[
     Type,
     Static.Const<RAngle>
 ], UncapitalizeMapping>;
-type Date = Static.Const<'Date', Static.As<Types.TDate>>;
-type Uint8Array = Static.Const<'Uint8Array', Static.As<Types.TUint8Array>>;
-export type Main = Static.Union<[
-    ModuleDeclaration,
-    TypeAliasDeclaration,
-    InterfaceDeclaration,
-    Type
-]>;
+type Date = Static.Const<'Date', Static.As<t.TDate>>;
+type Uint8Array = Static.Const<'Uint8Array', Static.As<t.TUint8Array>>;
 export {};

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

@@ -0,0 +1,33 @@
+import * as Types from '../type/index.mjs';
+import { Static } from '../parser/index.mjs';
+import { Type } from './static.mjs';
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+export declare function NoInfer<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+export declare function NoInfer<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/** Infers a TSchema type from TypeScript syntax. */
+export type TSyntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string> = (Static.Parse<Type, Code, Context> extends [infer Type extends Types.TSchema, string] ? Type : Types.TNever);
+/** Parses a TSchema type from TypeScript syntax */
+export declare function Syntax<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+/** Parses a TSchema type from TypeScript syntax */
+export declare function Syntax<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export declare function Parse<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): TSyntax<Context, Code>;
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export declare function Parse<Code extends string>(code: Code, options?: Types.SchemaOptions): TSyntax<{}, Code>;
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export declare function ParseOnly<Context extends Record<PropertyKey, Types.TSchema>, Code extends string>(context: Context, code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export declare function ParseOnly<Code extends string>(code: Code, options?: Types.SchemaOptions): Types.TSchema | undefined;

package/build/esm/syntax/syntax.mjs

@@ -0,0 +1,30 @@
+import * as Types from '../type/index.mjs';
+import { Module } from './runtime.mjs';
+/** Parses a TSchema type from TypeScript syntax but does not infer schematics */
+// prettier-ignore
+export function NoInfer(...args) {
+    const withContext = typeof args[0] === 'string' ? false : true;
+    const [context, code, options] = withContext ? [args[0], args[1], args[2] || {}] : [{}, args[0], args[1] || {}];
+    const type = Module.Parse('Type', code, context)[0];
+    return Types.KindGuard.IsSchema(type)
+        ? Types.CloneType(type, options)
+        : Types.Never(options);
+}
+/** Parses a TSchema type from TypeScript syntax */
+export function Syntax(...args) {
+    return NoInfer.apply(null, args);
+}
+/**
+ * Parses a TSchema type from Syntax.
+ * @deprecated Use Syntax() function
+ */
+export function Parse(...args) {
+    return NoInfer.apply(null, args);
+}
+/**
+ * Parses a TSchema from TypeScript Syntax
+ * @deprecated Use NoInfer() function
+ */
+export function ParseOnly(...args) {
+    return NoInfer.apply(null, args);
+}

package/build/esm/type/constructor-parameters/constructor-parameters.d.mts

@@ -1,7 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { Ensure } from '../helpers/index.mjs';
 import type { TConstructor } from '../constructor/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = (Ensure<TTuple<T['parameters']>>);
+import { type TNever } from '../never/index.mjs';
+export type TConstructorParameters<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _InstanceType extends TSchema> ? TTuple<Parameters> : TNever);
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export declare function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
+export declare function ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type>;

package/build/esm/type/constructor-parameters/constructor-parameters.mjs

@@ -1,5 +1,7 @@
 import { Tuple } from '../tuple/index.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
 export function ConstructorParameters(schema, options) {
-    return Tuple(schema.parameters, options);
+    return (KindGuard.IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options));
 }

package/build/esm/type/instance-type/instance-type.d.mts

@@ -1,5 +1,6 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import type { TConstructor } from '../constructor/index.mjs';
-export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+import { type TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TConstructor } from '../constructor/index.mjs';
+import { type TNever } from '../never/index.mjs';
+export type TInstanceType<Type extends TSchema, Result extends TSchema = Type extends TConstructor<infer _Parameters extends TSchema[], infer InstanceType extends TSchema> ? InstanceType : TNever> = Result;
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-export declare function InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
+export declare function InstanceType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TInstanceType<Type>;

package/build/esm/type/instance-type/instance-type.mjs

@@ -1,5 +1,7 @@
 import { CreateType } from '../create/type.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
 export function InstanceType(schema, options) {
-    return CreateType(schema.returns, options);
+    return (KindGuard.IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options));
 }

package/build/esm/type/parameters/parameters.d.mts

@@ -1,7 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TFunction } from '../function/index.mjs';
-import type { Ensure } from '../helpers/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
-export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+import { type TNever } from '../never/index.mjs';
+export type TParameters<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ReturnType extends TSchema> ? TTuple<Parameters> : TNever);
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
-export declare function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
+export declare function Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type>;

package/build/esm/type/parameters/parameters.mjs

@@ -1,5 +1,7 @@
 import { Tuple } from '../tuple/index.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
 export function Parameters(schema, options) {
-    return Tuple(schema.parameters, options);
+    return (KindGuard.IsFunction(schema) ? Tuple(schema.parameters, options) : Never());
 }

package/build/esm/type/return-type/return-type.d.mts

@@ -1,5 +1,6 @@
-import type { SchemaOptions } from '../schema/index.mjs';
-import type { TFunction } from '../function/index.mjs';
-export type TReturnType<T extends TFunction> = T['returns'];
+import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TNever } from '../never/index.mjs';
+export type TReturnType<Type extends TSchema, Result extends TSchema = Type extends TFunction<infer _Parameters extends TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever> = Result;
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-export declare function ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
+export declare function ReturnType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TReturnType<Type>;