@sinclair/typebox 0.32.0-dev-20 → 0.32.0-dev-22

package/build/import/type/rest/rest.d.mts

@@ -2,9 +2,9 @@ import type { TSchema } from '../schema/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TUnion } from '../union/index.mjs';
 import type { TTuple } from '../tuple/index.mjs';
-export type RestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+export type TRestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
 ];
-export declare function RestResolve<T extends TSchema>(T: T): RestResolve<T>;
-export type TRest<T extends TSchema> = RestResolve<T>;
+export declare function RestResolve<T extends TSchema>(T: T): TRestResolve<T>;
+export type TRest<T extends TSchema> = TRestResolve<T>;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 export declare function Rest<T extends TSchema>(T: T): TRest<T>;

package/build/import/type/schema/schema.d.mts

@@ -20,7 +20,7 @@ export interface SchemaOptions {
 export interface TKind {
     [Kind]: string;
 }
-export interface TSchema extends SchemaOptions, TKind {
+export interface TSchema extends TKind, SchemaOptions {
     [ReadonlyKind]?: string;
     [OptionalKind]?: string;
     [Hint]?: string;

package/build/import/type/static/static.d.mts

@@ -22,7 +22,7 @@ import type { TTransform } from '../transform/index.mjs';
 export type DecodeProperties<T extends TProperties> = {
     [K in keyof T]: DecodeType<T[K]>;
 };
-export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DecodeType<L>, ...DecodeRest<R>] : [];
+export type DecodeRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? DecodeRest<R, [...Acc, DecodeType<L>]> : Acc;
 export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<DecodeRest<P>, DecodeType<R>> : T extends TEnum<infer S> ? TEnum<S> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<DecodeRest<P>, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<DecodeRest<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<DecodeRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<DecodeRest<S>> : T);
 /** Creates an decoded static type from a TypeBox type */
 export type StaticDecode<T extends TSchema, P extends unknown[] = []> = Static<DecodeType<T>, P>;

package/build/import/type/symbol/symbol.d.mts

@@ -1,6 +1,6 @@
 import { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-export type SymbolValue = string | number | undefined;
+export type TSymbolValue = string | number | undefined;
 export interface TSymbol extends TSchema, SchemaOptions {
     [Kind]: 'Symbol';
     static: symbol;

package/build/import/type/template-literal/finite.d.mts

@@ -6,11 +6,13 @@ import type { TNumber } from '../number/index.mjs';
 import type { TInteger } from '../integer/index.mjs';
 import type { TBigInt } from '../bigint/index.mjs';
 import type { TLiteral } from '../literal/index.mjs';
-import type { Expression } from './parser.mjs';
+import type { Expression } from './parse.mjs';
 export declare class TemplateLiteralFiniteError extends Error {
 }
-type IsTemplateLiteralFiniteCheck<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? IsTemplateLiteralFiniteArray<U> : T extends TString ? false : T extends TBoolean ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TLiteral ? true : false;
-type IsTemplateLiteralFiniteArray<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? IsTemplateLiteralFiniteCheck<L> extends false ? false : IsTemplateLiteralFiniteArray<R> : true;
-export type IsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? IsTemplateLiteralFiniteArray<U> : false;
-export declare function IsTemplateLiteralFinite(expression: Expression): boolean;
+type TFromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<U> : T extends TString ? false : T extends TNumber ? false : T extends TInteger ? false : T extends TBigInt ? false : T extends TBoolean ? true : T extends TLiteral ? true : false;
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? TFromTemplateLiteralKind<L> extends false ? false : TFromTemplateLiteralKinds<R> : true;
+export declare function IsTemplateLiteralExpressionFinite(expression: Expression): boolean;
+export type TIsTemplateLiteralFinite<T> = T extends TTemplateLiteral<infer U> ? TFromTemplateLiteralKinds<U> : false;
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export declare function IsTemplateLiteralFinite<T extends TTemplateLiteral>(schema: T): boolean;
 export {};

package/build/import/type/template-literal/finite.mjs

@@ -1,3 +1,4 @@
+import { TemplateLiteralParseExact } from './parse.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralFiniteError
 // ------------------------------------------------------------------
@@ -28,12 +29,20 @@ function IsBooleanExpression(expression) {
 function IsStringExpression(expression) {
     return expression.type === 'const' && expression.const === '.*';
 }
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
 // prettier-ignore
-export function IsTemplateLiteralFinite(expression) {
-    return (IsBooleanExpression(expression) ? true :
-        IsNumberExpression(expression) || IsStringExpression(expression) ? false :
-            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
-                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralFinite(expr)) :
+export function IsTemplateLiteralExpressionFinite(expression) {
+    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+        IsBooleanExpression(expression) ? true :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
                     (expression.type === 'const') ? true :
                         (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
 }
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+export function IsTemplateLiteralFinite(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}

package/build/import/type/template-literal/generate.d.mts

@@ -1,15 +1,20 @@
+import { TIsTemplateLiteralFinite } from './finite.mjs';
+import type { Assert } from '../helpers/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
 import type { TTemplateLiteral, TTemplateLiteralKind } from './index.mjs';
 import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
-import type { Expression } from './parser.mjs';
+import type { Expression } from './parse.mjs';
 import type { TUnion } from '../union/index.mjs';
-type StringReduceUnary<L extends string, R extends string[]> = R extends [infer A extends string, ...infer B extends string[]] ? [`${L}${A}`, ...StringReduceUnary<L, B>] : [];
-type StringReduceBinary<L extends string[], R extends string[]> = L extends [infer A extends string, ...infer B extends string[]] ? [...StringReduceUnary<A, R>, ...StringReduceBinary<B, R>] : [];
-type StringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? StringReduceMany<[StringReduceBinary<L, R>, ...Rest]> : T;
-type StringReduce<T extends string[][], O = StringReduceMany<T>> = 0 extends keyof O ? O[0] : [];
-type TemplateLiteralReduceUnion<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TemplateLiteralReduceUnion<R>] : [];
-type TemplateLiteralReduce<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...TemplateLiteralReduce<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [TemplateLiteralReduceUnion<S>, ...TemplateLiteralReduce<R>] : [] : [];
 export declare class TemplateLiteralGenerateError extends Error {
 }
-export type TemplateLiteralGenerate<T> = T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TemplateLiteralReduce<S> extends infer R extends string[][] ? StringReduce<R> : [] : [];
-export declare function TemplateLiteralGenerate(expression: Expression): IterableIterator<string>;
+type TStringReduceUnary<L extends string, R extends string[], Acc extends string[] = []> = R extends [infer A extends string, ...infer B extends string[]] ? TStringReduceUnary<L, B, [...Acc, `${L}${A}`]> : Acc;
+type TStringReduceBinary<L extends string[], R extends string[], Acc extends string[] = []> = L extends [infer A extends string, ...infer B extends string[]] ? TStringReduceBinary<B, R, [...Acc, ...TStringReduceUnary<A, R>]> : Acc;
+type TStringReduceMany<T extends string[][]> = T extends [infer L extends string[], infer R extends string[], ...infer Rest extends string[][]] ? TStringReduceMany<[TStringReduceBinary<L, R>, ...Rest]> : T;
+type TStringReduce<T extends string[][], O = TStringReduceMany<T>> = 0 extends keyof O ? Assert<O[0], string[]> : [];
+type TFromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...TFromTemplateLiteralUnionKinds<R>] : [];
+type TFromTemplateLiteralKinds<T extends TTemplateLiteralKind[], Acc extends TLiteralValue[][] = []> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? TFromTemplateLiteralKinds<R, [...Acc, [S]]> : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<R, [...Acc, TFromTemplateLiteralUnionKinds<S>]> : L extends TBoolean ? TFromTemplateLiteralKinds<R, [...Acc, ['true', 'false']]> : Acc) : Acc;
+export declare function TemplateLiteralExpressionGenerate(expression: Expression): IterableIterator<string>;
+export type TTemplateLiteralGenerate<T extends TTemplateLiteral, F = TIsTemplateLiteralFinite<T>> = F extends true ? (T extends TTemplateLiteral<infer S extends TTemplateLiteralKind[]> ? TFromTemplateLiteralKinds<S> extends infer R extends string[][] ? TStringReduce<R> : [] : []) : [];
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export declare function TemplateLiteralGenerate<T extends TTemplateLiteral>(schema: T): TTemplateLiteralGenerate<T>;
 export {};

package/build/import/type/template-literal/generate.mjs

@@ -1,5 +1,12 @@
+import { IsTemplateLiteralExpressionFinite } from './finite.mjs';
+import { TemplateLiteralParseExact } from './parse.mjs';
 // ------------------------------------------------------------------
-// GenerateFromExpression
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+export class TemplateLiteralGenerateError extends Error {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
 // ------------------------------------------------------------------
 // prettier-ignore
 function* GenerateReduce(buffer) {
@@ -13,23 +20,18 @@ function* GenerateReduce(buffer) {
 }
 // prettier-ignore
 function* GenerateAnd(expression) {
-    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralGenerate(expr)]));
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
 }
 // prettier-ignore
 function* GenerateOr(expression) {
     for (const expr of expression.expr)
-        yield* TemplateLiteralGenerate(expr);
+        yield* TemplateLiteralExpressionGenerate(expr);
 }
 // prettier-ignore
 function* GenerateConst(expression) {
     return yield expression.const;
 }
-// ------------------------------------------------------------------
-// TemplateLiteralGenerateError
-// ------------------------------------------------------------------
-export class TemplateLiteralGenerateError extends Error {
-}
-export function* TemplateLiteralGenerate(expression) {
+export function* TemplateLiteralExpressionGenerate(expression) {
     return expression.type === 'and'
         ? yield* GenerateAnd(expression)
         : expression.type === 'or'
@@ -40,3 +42,11 @@ export function* TemplateLiteralGenerate(expression) {
                     throw new TemplateLiteralGenerateError('Unknown expression');
                 })();
 }
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+export function TemplateLiteralGenerate(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    // prettier-ignore
+    return (IsTemplateLiteralExpressionFinite(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}

package/build/import/type/template-literal/index.d.mts

@@ -1,7 +1,7 @@
 export * from './finite.mjs';
 export * from './generate.mjs';
 export * from './syntax.mjs';
-export * from './parser.mjs';
+export * from './parse.mjs';
 export * from './pattern.mjs';
 export * from './union.mjs';
 export * from './template-literal.mjs';

package/build/import/type/template-literal/index.mjs

@@ -1,7 +1,7 @@
 export * from './finite.mjs';
 export * from './generate.mjs';
 export * from './syntax.mjs';
-export * from './parser.mjs';
+export * from './parse.mjs';
 export * from './pattern.mjs';
 export * from './union.mjs';
 export * from './template-literal.mjs';

package/build/import/type/template-literal/{parser.mjs → parse.mjs}

@@ -127,16 +127,21 @@ function And(pattern) {
         (expressions.length === 1) ? expressions[0] :
             { type: 'and', expr: expressions });
 }
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
 /** Parses a pattern and returns an expression tree */
-// prettier-ignore
 export function TemplateLiteralParse(pattern) {
+    // prettier-ignore
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
                 { type: 'const', const: pattern });
 }
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
 /** Parses a pattern and strips forward and trailing ^ and $ */
-// prettier-ignore
 export function TemplateLiteralParseExact(pattern) {
     return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
 }

package/build/import/type/template-literal/syntax.d.mts

@@ -5,16 +5,16 @@ import { type TBoolean } from '../boolean/index.mjs';
 import { type TBigInt } from '../bigint/index.mjs';
 import { type TNumber } from '../number/index.mjs';
 import { type TString } from '../string/index.mjs';
-import { UnionEvaluated } from '../union/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
 declare function FromUnion(syntax: string): IterableIterator<TTemplateLiteralKind>;
 declare function FromTerminal(syntax: string): IterableIterator<TTemplateLiteralKind>;
 type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [TLiteral<Trim<L>>, ...FromUnionLiteral<R>] : T extends `${infer L}` ? [TLiteral<Trim<L>>] : [
 ];
-type FromUnion<T extends string> = UnionEvaluated<FromUnionLiteral<T>>;
+type FromUnion<T extends string> = TUnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
 type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
-export type TemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
+export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export declare function TemplateLiteralSyntax(syntax: string): TTemplateLiteralKind[];
 export {};

package/build/import/type/template-literal/syntax.mjs

@@ -3,7 +3,7 @@ import { Boolean } from '../boolean/index.mjs';
 import { BigInt } from '../bigint/index.mjs';
 import { Number } from '../number/index.mjs';
 import { String } from '../string/index.mjs';
-import { Union } from '../union/index.mjs';
+import { UnionEvaluated } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 // ------------------------------------------------------------------
 // SyntaxParsers
@@ -19,7 +19,7 @@ function* FromUnion(syntax) {
                         const literals = trim.split('|').map((literal) => Literal(literal.trim()));
                         return (literals.length === 0 ? Never() :
                             literals.length === 1 ? literals[0] :
-                                Union(literals));
+                                UnionEvaluated(literals));
                     })());
 }
 // prettier-ignore
@@ -49,7 +49,6 @@ function* FromSyntax(syntax) {
     }
     yield Literal(syntax);
 }
-// prettier-ignore
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
 export function TemplateLiteralSyntax(syntax) {
     return [...FromSyntax(syntax)];

package/build/import/type/template-literal/template-literal.d.mts

@@ -9,7 +9,7 @@ import type { TString } from '../string/index.mjs';
 import type { TBoolean } from '../boolean/index.mjs';
 import type { TNever } from '../never/index.mjs';
 import type { Static } from '../static/index.mjs';
-import { TemplateLiteralSyntax } from './syntax.mjs';
+import { TTemplateLiteralSyntax } from './syntax.mjs';
 import { EmptyString } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {
@@ -24,7 +24,7 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
     pattern: string;
 }
 /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+export declare function TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
 /** `[Json]` Creates a TemplateLiteral type */
 export declare function TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
 export {};

package/build/import/type/template-literal/template-literal.mjs

@@ -1,5 +1,5 @@
-import { TemplateLiteralPattern } from './pattern.mjs';
 import { TemplateLiteralSyntax } from './syntax.mjs';
+import { TemplateLiteralPattern } from './pattern.mjs';
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a TemplateLiteral type */

package/build/import/type/template-literal/union.d.mts

@@ -3,5 +3,5 @@ import { type TUnion } from '../union/index.mjs';
 import { type TLiteral } from '../literal/index.mjs';
 import { type TString } from '../string/index.mjs';
 import { type TNever } from '../never/index.mjs';
-/** Resolves a template literal as a TUnion */
-export declare function TemplateLiteralToUnion(template: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;
+/** Returns a Union from the given TemplateLiteral */
+export declare function TemplateLiteralToUnion(schema: TTemplateLiteral): TNever | TString | TUnion<TLiteral[]>;

package/build/import/type/template-literal/union.mjs

@@ -1,17 +1,12 @@
 import { Union } from '../union/index.mjs';
 import { Literal } from '../literal/index.mjs';
-import { String } from '../string/index.mjs';
 import { TemplateLiteralGenerate } from './generate.mjs';
-import { TemplateLiteralParseExact } from './parser.mjs';
-import { IsTemplateLiteralFinite } from './finite.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralToUnion
 // ------------------------------------------------------------------
-/** Resolves a template literal as a TUnion */
-export function TemplateLiteralToUnion(template) {
-    const expression = TemplateLiteralParseExact(template.pattern);
-    if (!IsTemplateLiteralFinite(expression))
-        return String();
-    const literals = [...TemplateLiteralGenerate(expression)].map((value) => Literal(value));
-    return Union(literals);
+/** Returns a Union from the given TemplateLiteral */
+export function TemplateLiteralToUnion(schema) {
+    const R = TemplateLiteralGenerate(schema);
+    const L = R.map((S) => Literal(S));
+    return Union(L);
 }

package/build/import/type/transform/transform.mjs

@@ -3,7 +3,6 @@ import { TransformKind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsTransform } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // TransformBuilders

package/build/import/type/tuple/tuple.d.mts

@@ -1,8 +1,7 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type TupleStaticRest<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TupleStaticRest<R, P>] : [];
-type TupleStatic<T extends TSchema[], P extends unknown[], R extends unknown[] = TupleStaticRest<T, P>> = R;
+type TupleStatic<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TupleStatic<R, P, [...Acc, Static<L, P>]> : Acc;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: TupleStatic<T, this['params']>;

package/build/import/type/type/json.d.mts

@@ -34,7 +34,7 @@ import { type TRequired, type TRequiredFromMappedResult } from '../required/inde
 import { type TRest } from '../rest/index.mjs';
 import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
 import { type TString, type StringOptions } from '../string/index.mjs';
-import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralKind, type TTemplateLiteralSyntax } from '../template-literal/index.mjs';
 import { TransformDecodeBuilder } from '../transform/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { Union } from '../union/index.mjs';
@@ -157,7 +157,7 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
+    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TTemplateLiteralSyntax<T>;
     /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
     /** `[Json]` Creates a Transform type */

package/build/import/type/union/union-evaluated.d.mts

@@ -3,15 +3,11 @@ import { type TNever } from '../never/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TUnion } from './union-type.mjs';
-type IsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : IsUnionOptional<R> : false);
-declare function IsUnionOptional<T extends TSchema[]>(T: T): IsUnionOptional<T>;
-type RemoveOptionalFromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? [RemoveOptionalFromType<S>, ...RemoveOptionalFromRest<R>] : [L, ...RemoveOptionalFromRest<R>] : []);
-declare function RemoveOptionalFromRest<T extends TSchema[]>(T: T): RemoveOptionalFromRest<T>;
-type RemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<RemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? RemoveOptionalFromType<S> : T);
-declare function RemoveOptionalFromType<T extends TSchema>(T: T): RemoveOptionalFromType<T>;
-type ResolveUnion<T extends TSchema[], R extends TSchema[] = RemoveOptionalFromRest<T>> = (IsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
-declare function ResolveUnion<T extends TSchema[]>(T: T, options: SchemaOptions): ResolveUnion<T>;
-export type UnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveUnion<T>);
+type TIsUnionOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? true : TIsUnionOptional<R> : false);
+type TRemoveOptionalFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromRest<R, [...Acc, TRemoveOptionalFromType<S>]> : TRemoveOptionalFromRest<R, [...Acc, L]> : Acc);
+type TRemoveOptionalFromType<T extends TSchema> = (T extends TReadonly<infer S extends TSchema> ? TReadonly<TRemoveOptionalFromType<S>> : T extends TOptional<infer S extends TSchema> ? TRemoveOptionalFromType<S> : T);
+type TResolveUnion<T extends TSchema[], R extends TSchema[] = TRemoveOptionalFromRest<T>> = (TIsUnionOptional<T> extends true ? TOptional<TUnion<R>> : TUnion<R>);
+export type TUnionEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveUnion<T>);
 /** `[Json]` Creates an evaluated Union type */
-export declare function UnionEvaluated<T extends TSchema[], R = UnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
+export declare function UnionEvaluated<T extends TSchema[], R = TUnionEvaluated<T>>(T: [...T], options?: SchemaOptions): R;
 export {};

package/build/import/type/union/union-evaluated.mjs

@@ -19,8 +19,13 @@ function IsUnionOptional(T) {
         : false);
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return (T.map(T => RemoveOptionalFromType(T)));
+function RemoveOptionalFromRest(T, Acc = []) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptional(L)
+            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
+            : RemoveOptionalFromRest(R, [...Acc, L])
+        : Acc);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

package/build/import/value/cast/cast.mjs

@@ -94,7 +94,7 @@ function Default(schema, references, value) {
 // ------------------------------------------------------------------
 // Cast
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (Check(schema, references, value))
         return Clone(value);
     const created = IsArray(value) ? Clone(value) : Create(schema, references);
@@ -108,7 +108,7 @@ function TArray(schema, references, value) {
         throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
     return unique;
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     if (Check(schema, references, value))
         return Create(schema, references);
     const required = new Set(schema.returns.required || []);
@@ -120,15 +120,15 @@ function TConstructor(schema, references, value) {
     }
     return result;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const created = Create(schema, references);
     const mapped = IsPlainObject(created) && IsPlainObject(value) ? { ...created, ...value } : value;
     return Check(schema, references, mapped) ? mapped : Create(schema, references);
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     throw new ValueCastNeverTypeError(schema);
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (Check(schema, references, value))
         return value;
     if (value === null || typeof value !== 'object')
@@ -151,7 +151,7 @@ function TObject(schema, references, value) {
     }
     return result;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (Check(schema, references, value))
         return Clone(value);
     if (value === null || typeof value !== 'object' || Array.isArray(value) || value instanceof Date)
@@ -164,13 +164,13 @@ function TRecord(schema, references, value) {
     }
     return result;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (Check(schema, references, value))
         return Clone(value);
     if (!IsArray(value))
@@ -179,7 +179,7 @@ function TTuple(schema, references, value) {
         return [];
     return schema.items.map((schema, index) => Visit(schema, references, value[index]));
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value);
 }
 function Visit(schema, references, value) {
@@ -190,25 +190,25 @@ function Visit(schema, references, value) {
         // Structural
         // --------------------------------------------------------------
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         // --------------------------------------------------------------
         // DefaultClone
         // --------------------------------------------------------------