@sinclair/typebox 0.34.29 → 0.34.30

package/build/cjs/syntax/static.d.ts

@@ -39,18 +39,20 @@ type GenericArgumentsContext<Args extends string[], Context extends t.TPropertie
 interface GenericArgumentsMapping extends Static.IMapping {
     output: this['input'] extends [LAngle, infer Args extends string[], RAngle] ? this['context'] extends infer Context extends t.TProperties ? GenericArgumentsContext<Args, Context> : never : never;
 }
+type GenericArgumentsList = Delimit<Static.Ident, Static.Const<Comma>>;
 type GenericArguments = Static.Tuple<[
     Static.Const<LAngle>,
-    Delimit<Static.Ident, Static.Const<Comma>>,
+    GenericArgumentsList,
     Static.Const<RAngle>
 ], GenericArgumentsMapping>;
 interface GenericReferenceMapping extends Static.IMapping {
     output: this['context'] extends t.TProperties ? this['input'] extends [infer Reference extends string, LAngle, infer Args extends t.TSchema[], RAngle] ? t.TInstantiate<Dereference<this['context'], Reference>, Args> : never : never;
 }
+type GenericReferenceParameters = Delimit<Type, Static.Const<Comma>>;
 type GenericReference = Static.Tuple<[
     Static.Ident,
     Static.Const<LAngle>,
-    Elements,
+    GenericReferenceParameters,
     Static.Const<RAngle>
 ], GenericReferenceMapping>;
 interface ReferenceMapping extends Static.IMapping {
@@ -58,13 +60,13 @@ interface ReferenceMapping extends Static.IMapping {
 }
 type Reference = Static.Ident<ReferenceMapping>;
 interface LiteralBooleanMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends boolean}` ? t.TLiteral<S> : never;
+    output: this['input'] extends `${infer Value extends boolean}` ? t.TLiteral<Value> : never;
 }
 interface LiteralNumberMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends number}` ? t.TLiteral<S> : never;
+    output: this['input'] extends `${infer Value extends number}` ? t.TLiteral<Value> : never;
 }
 interface LiteralStringMapping extends Static.IMapping {
-    output: this['input'] extends `${infer S extends string}` ? t.TLiteral<S> : never;
+    output: this['input'] extends `${infer Value extends string}` ? t.TLiteral<Value> : never;
 }
 type Literal = Static.Union<[
     Static.Union<[Static.Const<'true'>, Static.Const<'false'>], LiteralBooleanMapping>,
@@ -72,17 +74,17 @@ type Literal = Static.Union<[
     Static.String<[DoubleQuote, SingleQuote, Tilde], LiteralStringMapping>
 ]>;
 type Keyword = Static.Union<[
-    Static.Const<'any', Static.As<t.TAny>>,
-    Static.Const<'bigint', Static.As<t.TBigInt>>,
+    Static.Const<'string', Static.As<t.TString>>,
+    Static.Const<'number', Static.As<t.TNumber>>,
     Static.Const<'boolean', Static.As<t.TBoolean>>,
+    Static.Const<'undefined', Static.As<t.TUndefined>>,
+    Static.Const<'null', Static.As<t.TNull>>,
     Static.Const<'integer', Static.As<t.TInteger>>,
+    Static.Const<'bigint', Static.As<t.TBigInt>>,
+    Static.Const<'unknown', Static.As<t.TUnknown>>,
+    Static.Const<'any', Static.As<t.TAny>>,
     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 {
@@ -92,15 +94,14 @@ type KeyOf = Static.Union<[
     Static.Tuple<[Static.Const<'keyof'>]>,
     Static.Tuple<[]>
 ], KeyOfMapping>;
+type IndexArrayReduce<Values extends unknown[], Result extends unknown[] = []> = (Values extends [infer Left extends unknown, ...infer Right extends unknown[]] ? Left extends [LBracket, infer Type extends t.TSchema, RBracket] ? IndexArrayReduce<Right, [...Result, [Type]]> : IndexArrayReduce<Right, [...Result, []]> : Result);
 interface IndexArrayMapping extends Static.IMapping {
-    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] : [
-    ]);
+    output: this['input'] extends unknown[] ? IndexArrayReduce<this['input']> : [];
 }
-type IndexArray = Static.Union<[
-    Static.Tuple<[Static.Const<LBracket>, Type, Static.Const<RBracket>, IndexArray]>,
-    Static.Tuple<[Static.Const<LBracket>, Static.Const<RBracket>, IndexArray]>,
-    Static.Tuple<[]>
-], IndexArrayMapping>;
+type IndexArray = Static.Array<Static.Union<[
+    Static.Tuple<[Static.Const<LBracket>, Type, Static.Const<RBracket>]>,
+    Static.Tuple<[Static.Const<LBracket>, Static.Const<RBracket>]>
+]>, IndexArrayMapping>;
 interface ExtendsMapping extends Static.IMapping {
     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] : [];
 }
@@ -109,50 +110,42 @@ type Extends = Static.Union<[
     Static.Tuple<[]>
 ], ExtendsMapping>;
 interface BaseMapping extends Static.IMapping {
-    output: (this['input'] extends [LParen, infer Type extends t.TSchema, RParen] ? Type : this['input'] extends [infer Type extends t.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<[
-        Static.Const<LParen>,
-        Type,
-        Static.Const<RParen>
-    ]>,
-    Static.Tuple<[
-        Static.Union<[
-            Literal,
-            Keyword,
-            Object,
-            Tuple,
-            Function,
-            Constructor,
-            Mapped,
-            AsyncIterator,
-            Iterator,
-            ConstructorParameters,
-            FunctionParameters,
-            Argument,
-            InstanceType,
-            ReturnType,
-            Awaited,
-            Array,
-            Record,
-            Promise,
-            Partial,
-            Required,
-            Pick,
-            Omit,
-            Exclude,
-            Extract,
-            Lowercase,
-            Uppercase,
-            Capitalize,
-            Uncapitalize,
-            Date,
-            Uint8Array,
-            GenericReference,
-            Reference
-        ]>
-    ]>
+    Static.Tuple<[Static.Const<LParen>, Type, Static.Const<RParen>]>,
+    Keyword,
+    Object,
+    Tuple,
+    Literal,
+    Function,
+    Constructor,
+    Mapped,
+    AsyncIterator,
+    Iterator,
+    ConstructorParameters,
+    FunctionParameters,
+    Argument,
+    InstanceType,
+    ReturnType,
+    Awaited,
+    Array,
+    Record,
+    Promise,
+    Partial,
+    Required,
+    Pick,
+    Omit,
+    Exclude,
+    Extract,
+    Lowercase,
+    Uppercase,
+    Capitalize,
+    Uncapitalize,
+    Date,
+    Uint8Array,
+    GenericReference,
+    Reference
 ], BaseMapping>;
 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);
@@ -224,26 +217,23 @@ type PropertyDelimiter = Static.Union<[
     Static.Tuple<[Static.Const<SemiColon>]>,
     Static.Tuple<[Static.Const<Newline>]>
 ]>;
-type PropertiesReduce<PropertiesArray extends t.TProperties[], Result extends t.TProperties = {}> = (PropertiesArray extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]] ? PropertiesReduce<Right, Result & Left> : t.Evaluate<Result>);
-interface PropertiesMapping extends Static.IMapping {
-    output: this['input'] extends t.TProperties[] ? PropertiesReduce<this['input']> : never;
-}
-type Properties = Static.Union<[Delimit<Property, PropertyDelimiter>], PropertiesMapping>;
+type PropertyList = Delimit<Property, PropertyDelimiter>;
+type ObjectReduce<PropertiesList extends t.TProperties[], Result extends t.TProperties = {}> = (PropertiesList extends [infer Left extends t.TProperties, ...infer Right extends t.TProperties[]] ? ObjectReduce<Right, Result & Left> : t.Evaluate<Result>);
 interface ObjectMapping extends Static.IMapping {
-    output: this['input'] extends [unknown, infer Properties extends t.TProperties, unknown] ? t.TObject<Properties> : never;
+    output: this['input'] extends [LBrace, infer PropertyList extends t.TProperties[], RBrace] ? t.TObject<ObjectReduce<PropertyList>> : never;
 }
 type Object = Static.Tuple<[
     Static.Const<LBrace>,
-    Properties,
+    PropertyList,
     Static.Const<RBrace>
 ], ObjectMapping>;
-type Elements = Delimit<Type, Static.Const<Comma>>;
+type ElementList = Delimit<Type, Static.Const<Comma>>;
 interface TupleMapping extends Static.IMapping {
-    output: this['input'] extends [unknown, infer Elements extends t.TSchema[], unknown] ? t.TTuple<Elements> : never;
+    output: this['input'] extends [unknown, infer ElementList extends t.TSchema[], unknown] ? t.TTuple<ElementList> : never;
 }
 type Tuple = Static.Tuple<[
     Static.Const<LBracket>,
-    Elements,
+    ElementList,
     Static.Const<RBracket>
 ], TupleMapping>;
 interface ParameterMapping extends Static.IMapping {
@@ -254,24 +244,24 @@ type Parameter = Static.Tuple<[
     Static.Const<Colon>,
     Type
 ], ParameterMapping>;
-type Parameters = Delimit<Parameter, Static.Const<Comma>>;
+type ParameterList = Delimit<Parameter, Static.Const<Comma>>;
 interface FunctionMapping extends Static.IMapping {
-    output: this['input'] extends [LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema] ? t.TFunction<Parameters, ReturnType> : never;
+    output: this['input'] extends [LParen, infer ParameterList extends t.TSchema[], RParen, '=>', infer ReturnType extends t.TSchema] ? t.TFunction<ParameterList, ReturnType> : never;
 }
 type Function = Static.Tuple<[
     Static.Const<LParen>,
-    Parameters,
+    ParameterList,
     Static.Const<RParen>,
     Static.Const<'=>'>,
     Type
 ], FunctionMapping>;
 interface ConstructorMapping extends Static.IMapping {
-    output: this['input'] extends ['new', LParen, infer Parameters extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema] ? t.TConstructor<Parameters, InstanceType> : never;
+    output: this['input'] extends ['new', LParen, infer ParameterList extends t.TSchema[], RParen, '=>', infer InstanceType extends t.TSchema] ? t.TConstructor<ParameterList, InstanceType> : never;
 }
 type Constructor = Static.Tuple<[
     Static.Const<'new'>,
     Static.Const<LParen>,
-    Parameters,
+    ParameterList,
     Static.Const<RParen>,
     Static.Const<'=>'>,
     Type

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

@@ -1,12 +1,12 @@
 import { Runtime } from '../parser/index.mjs';
 import * as t from '../type/index.mjs';
 export declare const Module: Runtime.Module<{
-    GenericArgumentList: Runtime.IUnion<unknown[]>;
+    GenericArgumentsList: Runtime.ITuple<unknown[]>;
     GenericArguments: Runtime.ITuple<t.TProperties>;
     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[]>;
+    IndexArray: Runtime.IArray<unknown[]>;
     Extends: Runtime.IUnion<unknown[]>;
     Base: Runtime.IUnion<unknown>;
     Factor: Runtime.ITuple<t.TSchema>;
@@ -22,13 +22,13 @@ export declare const Module: Runtime.Module<{
         [x: string]: t.TSchema;
     }>;
     PropertyDelimiter: Runtime.IUnion<[","] | [",", "\n"] | [";"] | [";", "\n"] | ["\n"]>;
-    Properties: Runtime.IUnion<t.TProperties>;
+    PropertyList: Runtime.ITuple<unknown[]>;
     Object: Runtime.ITuple<t.TObject<t.TProperties>>;
-    Elements: Runtime.IUnion<unknown[]>;
+    ElementList: Runtime.ITuple<unknown[]>;
     Tuple: Runtime.ITuple<t.TTuple<t.TSchema[]>>;
     Parameter: Runtime.ITuple<t.TSchema>;
+    ParameterList: Runtime.ITuple<unknown[]>;
     Function: Runtime.ITuple<t.TFunction<t.TSchema[], t.TSchema>>;
-    Parameters: 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>>;
@@ -54,6 +54,7 @@ export declare const Module: Runtime.Module<{
     Uncapitalize: Runtime.ITuple<t.TSchema>;
     Date: Runtime.IConst<t.TDate>;
     Uint8Array: Runtime.IConst<t.TUint8Array>;
+    GenericReferenceParameters: Runtime.ITuple<unknown[]>;
     GenericReference: Runtime.ITuple<t.TSchema>;
     Reference: Runtime.IIdent<t.TSchema>;
 }>;