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

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

@@ -1,24 +1,24 @@
-export type OperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : OperatorIncludes<R, S> : false);
+export type TOperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TOperatorIncludes<R, S> : false);
 /** Returns true if element S is in the set of T */
-export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): OperatorIncludes<T, S>;
-export type OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? OperatorSubset<R, S> : false : true;
+export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TOperatorIncludes<T, S>;
+export type TOperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? TOperatorSubset<R, S> : false : true);
 /** Returns true if T is a subset of S */
-export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorSubset<T, S>;
-export type OperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<Acc, L> extends false ? OperatorDistinct<R, [...Acc, L]> : OperatorDistinct<R, [...Acc]> : Acc;
+export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TOperatorSubset<T, S>;
+export type TOperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<Acc, L> extends false ? TOperatorDistinct<R, [...Acc, L]> : TOperatorDistinct<R, [...Acc]> : Acc;
 /** Returns a distinct set of elements */
-export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): OperatorDistinct<T>;
-export type OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [L, ...OperatorIntersect<R, S>] : [...OperatorIntersect<R, S>] : []);
+export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): TOperatorDistinct<T>;
+export type TOperatorIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? TOperatorIntersect<R, S, [L, ...Acc]> : TOperatorIntersect<R, S, [...Acc]> : Acc);
 /** Returns the Intersect of the given sets */
-export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorIntersect<T, S>;
-export type OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorUnion<R, S>] : [L, ...OperatorUnion<R, S>] : S);
+export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TOperatorIntersect<T, S>;
+export type TOperatorUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorUnion<R, S, [...Acc, L]> : Acc);
 /** Returns the Union of the given sets */
-export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorUnion<T, S>;
-export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorComplement<R, S>] : [L, ...OperatorComplement<R, S>] : []);
+export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S], Acc?: PropertyKey[]): TOperatorUnion<T, S>;
+export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? OperatorComplement<R, S, [...Acc]> : OperatorComplement<R, S, [L, ...Acc]> : Acc);
 /** Returns the Complement by omitting elements in T that are in S */
-export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorComplement<T, S>;
-export type OperatorIntersectMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersect<L, OperatorIntersectMany<R>> : []);
+export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S], Acc?: PropertyKey[]): OperatorComplement<T, S>;
+export type OperatorIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersectMany<R, TOperatorIntersect<Acc, L>> : Acc);
 /** Returns the Intersect of multiple sets */
-export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T]): OperatorIntersectMany<T>;
-export type OperatorUnionMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnion<L, OperatorUnionMany<R>> : []);
+export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T], Acc?: PropertyKey[]): OperatorIntersectMany<T>;
+export type OperatorUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnionMany<R, TOperatorUnion<Acc, L>> : Acc);
 /** Returns the Union of multiple sets */
-export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T]): OperatorUnionMany<T>;
+export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T], Acc?: PropertyKey[]): OperatorUnionMany<T>;

package/build/import/type/operators/operators.mjs

@@ -9,9 +9,9 @@ export function OperatorIncludes(T, S) {
         : false);
 }
 /** Returns true if T is a subset of S */
-// prettier-ignore
 export function OperatorSubset(T, S) {
     const [L, ...R] = T;
+    // prettier-ignore
     return (T.length > 0
         ? OperatorIncludes(S, L) === true
             ? OperatorSubset(R, S)
@@ -19,19 +19,18 @@ export function OperatorSubset(T, S) {
         : true);
 }
 /** Returns a distinct set of elements */
-// prettier-ignore
 export function OperatorDistinct(T, Acc = []) {
     const [L, ...R] = T;
-    return (T.length > 0
-        ? OperatorIncludes(Acc, L) === false
+    // prettier-ignore
+    return (T.length > 0 ?
+        (OperatorIncludes(Acc, L) === false
             ? OperatorDistinct(R, [...Acc, L])
-            : OperatorDistinct(R, [...Acc])
-        : Acc);
+            : OperatorDistinct(R, [...Acc])) : Acc);
 }
 /** Returns the Intersect of the given sets */
-// prettier-ignore
 export function OperatorIntersect(T, S) {
     const [L, ...R] = T;
+    // prettier-ignore
     return (T.length > 0
         ? OperatorIncludes(S, L) === true
             ? [L, ...OperatorIntersect(R, S)]
@@ -39,28 +38,26 @@ export function OperatorIntersect(T, S) {
         : []);
 }
 /** Returns the Union of the given sets */
-// prettier-ignore
-export function OperatorUnion(T, S) {
+export function OperatorUnion(T, S, Acc = S) {
     const [L, ...R] = T;
+    // prettier-ignore
     return (T.length > 0
-        ? OperatorIncludes(S, L) === true
-            ? [...OperatorUnion(R, S)]
-            : [L, ...OperatorUnion(R, S)]
-        : S);
+        ? OperatorUnion(R, S, [...Acc, L])
+        : Acc);
 }
 /** Returns the Complement by omitting elements in T that are in S */
 // prettier-ignore
-export function OperatorComplement(T, S) {
+export function OperatorComplement(T, S, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
         ? OperatorIncludes(S, L) === true
-            ? [...OperatorComplement(R, S)]
-            : [L, ...OperatorComplement(R, S)]
-        : []);
+            ? OperatorComplement(R, S, [...Acc])
+            : OperatorComplement(R, S, [L, ...Acc])
+        : Acc);
 }
 /** Returns the Intersect of multiple sets */
 // prettier-ignore
-export function OperatorIntersectMany(T) {
+export function OperatorIntersectMany(T, Acc = []) {
     return (T.length === 1
         ? T[0]
         : (() => {
@@ -71,11 +68,10 @@ export function OperatorIntersectMany(T) {
         })());
 }
 /** Returns the Union of multiple sets */
-export function OperatorUnionMany(T) {
-    return (T.length === 1
-        ? T[0]
-        : (() => {
-            const [L, ...R] = T;
-            return T.length > 0 ? OperatorUnion(L, OperatorUnionMany(R)) : [];
-        })());
+export function OperatorUnionMany(T, Acc = []) {
+    const [L, ...R] = T;
+    // prettier-ignore
+    return (T.length > 0
+        ? OperatorUnionMany(R, OperatorUnion(Acc, L))
+        : Acc);
 }

package/build/import/type/optional/optional-from-mapped-result.d.mts

@@ -1,12 +1,10 @@
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TOptionalWithFlag } from './optional.mjs';
-type FromProperties<K extends TProperties, F extends boolean> = ({
+type TFromProperties<K extends TProperties, F extends boolean> = ({
     [K2 in keyof K]: TOptionalWithFlag<K[K2], F>;
 });
-declare function FromProperties<K extends TProperties, F extends boolean>(K: K, F: F): FromProperties<K, F>;
-type FromMappedResult<K extends TMappedResult, F extends boolean> = (FromProperties<K['properties'], F>);
-declare function FromMappedResult<K extends TMappedResult, F extends boolean>(K: K, F: F): FromMappedResult<K, F>;
-export type TOptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>> = (TMappedResult<P>);
-export declare function OptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult, F extends boolean> = (TFromProperties<K['properties'], F>);
+export type TOptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>> = (TMappedResult<P>);
+export declare function OptionalFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
 export {};

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

@@ -3,13 +3,9 @@ import type { Ensure } from '../helpers/index.mjs';
 import { OptionalKind } from '../symbols/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TOptionalFromMappedResult } from './optional-from-mapped-result.mjs';
-type RemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
-declare function RemoveOptional<T extends TSchema>(schema: T): Record<PropertyKey, any>;
-type AddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
-declare function AddOptional<T extends TSchema>(schema: T): T & {
-    [OptionalKind]: string;
-};
-export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? RemoveOptional<T> : AddOptional<T>;
+type TRemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
+type TAddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveOptional<T> : TAddOptional<T>;
 export type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };

package/build/import/type/partial/partial-from-mapped-result.d.mts

@@ -2,12 +2,10 @@ import type { SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TPartial } from './partial.mjs';
-type FromProperties<K extends TProperties> = ({
+type TFromProperties<K extends TProperties> = ({
     [K2 in keyof K]: TPartial<K[K2]>;
 });
-declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
-type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
-declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
-export type TPartialFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
-export declare function PartialFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult> = (TFromProperties<K['properties']>);
+export type TPartialFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>> = (TMappedResult<P>);
+export declare function PartialFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -9,15 +9,12 @@ import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result.mjs';
-type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromIntersect<R>] : []);
-declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
-type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<L>, ...FromUnion<R>] : []);
-declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
-type FromProperties<T extends TProperties> = Evaluate<{
+type TFromIntersect<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, [...Acc, PartialResolve<L>]> : Acc);
+type TFromUnion<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, PartialResolve<L>]> : Acc);
+type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
 }>;
-declare function FromProperties<T extends TProperties>(T: T): TProperties;
-type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
 declare function PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
 export type TPartial<T extends TSchema> = PartialResolve<T>;
 /** `[Json]` Constructs a type where all properties are optional */

package/build/import/type/partial/partial.mjs

@@ -9,21 +9,20 @@ import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
 // prettier-ignore
-function FromIntersect(T) {
+function FromIntersect(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [PartialResolve(L), ...FromIntersect(R)]
-        : []);
+        ? FromIntersect(R, [...Acc, PartialResolve(L)])
+        : Acc);
 }
 // prettier-ignore
-function FromUnion(T) {
+function FromUnion(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [PartialResolve(L), ...FromUnion(R)]
-        : []);
+        ? FromUnion(R, [...Acc, PartialResolve(L)])
+        : Acc);
 }
 // prettier-ignore
 function FromProperties(T) {

package/build/import/type/pick/pick-from-mapped-key.d.mts

@@ -2,14 +2,11 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
 import { type TPick } from './pick.mjs';
-type FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+type TFromPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TPick<T, [K]>;
 };
-declare function FromPropertyKey<T extends TSchema, K extends PropertyKey>(T: T, K: K, options: SchemaOptions): FromPropertyKey<T, K>;
-type FromPropertyKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? FromPropertyKey<T, LK> & FromPropertyKeys<T, RK> : {});
-declare function FromPropertyKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K], options: SchemaOptions): FromPropertyKeys<T, K>;
-type FromMappedKey<T extends TSchema, K extends TMappedKey> = (FromPropertyKeys<T, K['keys']>);
-declare function FromMappedKey<T extends TSchema, K extends TMappedKey>(T: T, K: K, options: SchemaOptions): FromMappedKey<T, K>;
-export type TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+type TFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>> : Acc);
+type TFromMappedKey<T extends TSchema, K extends TMappedKey> = (TFromPropertyKeys<T, K['keys']>);
+export type TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/pick/pick-from-mapped-key.mjs

@@ -7,11 +7,11 @@ function FromPropertyKey(T, K, options) {
     };
 }
 // prettier-ignore
-function FromPropertyKeys(T, K, options) {
+function FromPropertyKeys(T, K, options, Acc = {}) {
     const [LK, ...RK] = K;
     return (K.length > 0
-        ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
-        : {});
+        ? FromPropertyKeys(T, RK, options, { ...Acc, ...FromPropertyKey(T, LK, options) })
+        : Acc);
 }
 // prettier-ignore
 function FromMappedKey(T, K, options) {

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

@@ -7,10 +7,10 @@ import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TIndexPropertyKeys } from '../indexed/index.mjs';
 import { TMappedKey } from '../mapped/index.mjs';
 import { type TPickFromMappedKey } from './pick-from-mapped-key.mjs';
-type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromIntersect<R, K>] : [];
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
-type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromUnion<R, K>] : [];
-declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
+type FromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromIntersect<R, K, [...Acc, PickResolve<L, K>]> : Acc;
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K, []>;
+type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, PickResolve<L, K>]> : Acc;
+declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K, []>;
 type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
 declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): {};
 export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;

package/build/import/type/readonly/readonly-from-mapped-result.d.mts

@@ -1,12 +1,10 @@
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyWithFlag } from './readonly.mjs';
-type FromProperties<K extends TProperties, F extends boolean> = ({
+type TFromProperties<K extends TProperties, F extends boolean> = ({
     [K2 in keyof K]: TReadonlyWithFlag<K[K2], F>;
 });
-declare function FromProperties<K extends TProperties, F extends boolean>(K: K, F: F): FromProperties<K, F>;
-type FromMappedResult<K extends TMappedResult, F extends boolean> = (FromProperties<K['properties'], F>);
-declare function FromMappedResult<K extends TMappedResult, F extends boolean>(K: K, F: F): FromMappedResult<K, F>;
-export type TReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>> = (TMappedResult<P>);
-export declare function ReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = FromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult, F extends boolean> = (TFromProperties<K['properties'], F>);
+export type TReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>> = (TMappedResult<P>);
+export declare function ReadonlyFromMappedResult<T extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<T, F>>(T: T, F: F): TMappedResult<P>;
 export {};

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

@@ -3,13 +3,9 @@ import type { Ensure } from '../helpers/index.mjs';
 import { ReadonlyKind } from '../symbols/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
 import { type TReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
-type RemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
-declare function RemoveReadonly<T extends TSchema>(schema: T): Record<PropertyKey, any>;
-type AddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
-declare function AddReadonly<T extends TSchema>(schema: T): T & {
-    [ReadonlyKind]: string;
-};
-export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? RemoveReadonly<T> : AddReadonly<T>;
+type TRemoveReadonly<T extends TSchema> = T extends TReadonly<infer S> ? S : T;
+type TAddReadonly<T extends TSchema> = T extends TReadonly<infer S> ? TReadonly<S> : Ensure<TReadonly<T>>;
+export type TReadonlyWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveReadonly<T> : TAddReadonly<T>;
 export type TReadonly<T extends TSchema> = T & {
     [ReadonlyKind]: 'Readonly';
 };

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

@@ -11,34 +11,28 @@ import { type TNumber } from '../number/index.mjs';
 import { type TEnum } from '../enum/index.mjs';
 import { TTemplateLiteral, TIsTemplateLiteralFinite } from '../template-literal/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type FromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
-type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
+type TFromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
+type TFromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
     [_ in I]: T;
 }>>>);
-type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
-declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromTemplateLiteralKey<K, T>;
-type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
+type TFromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = TIsTemplateLiteralFinite<K> extends false ? TFromTemplateLiteralKeyInfinite<K, T> : TFromTemplateLiteralKeyFinite<K, T>;
+type TFromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
     [_ in K[keyof K]]: T;
 }>>;
-type FromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = {
+type TFromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = {
     [_ in K['const']]: T;
 };
-type FromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = {
+type TFromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = {
     [_ in K['const']]: T;
 };
-type FromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? FromUnionKeyRest<S, T> & FromUnionKeyRest<R, T> : L extends TLiteral<string> ? FromUnionKeyLiteralString<L, T> & FromUnionKeyRest<R, T> : L extends TLiteral<number> ? FromUnionKeyLiteralNumber<L, T> & FromUnionKeyRest<R, T> : {}) : {};
-type FromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = FromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
-declare function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T, options: ObjectOptions): FromUnionKey<K, T>;
-type FromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
+type TFromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? TFromUnionKeyRest<S, T> & TFromUnionKeyRest<R, T> : L extends TLiteral<string> ? TFromUnionKeyLiteralString<L, T> & TFromUnionKeyRest<R, T> : L extends TLiteral<number> ? TFromUnionKeyLiteralNumber<L, T> & TFromUnionKeyRest<R, T> : {}) : {};
+type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = TFromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
+type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);
-declare function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromLiteralKey<K, T>;
-type FromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
-declare function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T, options: ObjectOptions): FromStringKey<K, T>;
-type FromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T, options: ObjectOptions): FromIntegerKey<K, T>;
-type FromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
-declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T, options: ObjectOptions): FromIntegerKey<K, T>;
+type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
+type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
+type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Record<Assert<Static<K>, PropertyKey>, Static<T, P>>);
 export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
@@ -49,7 +43,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
 /** `[Json]` Creates a Record type */
 export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};

package/build/import/type/record/record.mjs

@@ -10,7 +10,6 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsInteger, IsLiteral, IsNumber, IsString, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern

package/build/import/type/ref/ref.mjs

@@ -1,4 +1,7 @@
 import { Kind } from '../symbols/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
 import { IsString, IsUndefined } from '../guard/value.mjs';
 /** `[Json]` Creates a Ref type. */
 export function Ref(unresolved, options = {}) {

package/build/import/type/required/required-from-mapped-result.d.mts

@@ -2,12 +2,10 @@ import type { SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TRequired } from './required.mjs';
-type FromProperties<K extends TProperties> = ({
+type TFromProperties<K extends TProperties> = ({
     [K2 in keyof K]: TRequired<K[K2]>;
 });
-declare function FromProperties<K extends TProperties>(K: K, options: SchemaOptions): FromProperties<K>;
-type FromMappedResult<K extends TMappedResult> = (FromProperties<K['properties']>);
-declare function FromMappedResult<K extends TMappedResult>(K: K, options: SchemaOptions): FromMappedResult<K>;
-export type TRequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
-export declare function RequiredFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult> = (TFromProperties<K['properties']>);
+export type TRequiredFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>> = (TMappedResult<P>);
+export declare function RequiredFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -9,17 +9,13 @@ import { type TIntersect } from '../intersect/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TObject, type TProperties } from '../object/index.mjs';
 import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
-type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromIntersect<R>] : []);
-declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
-type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromUnion<R>] : []);
-declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
-type FromProperties<T extends TProperties> = Evaluate<{
+type TFromIntersect<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, [...Acc, TRequiredResolve<L>]> : Acc);
+type TFromUnion<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, TRequiredResolve<L>]> : Acc);
+type TFromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
 }>;
-declare function FromProperties<T extends TProperties>(T: T): TProperties;
-type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
-declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
-export type TRequired<T extends TSchema> = RequiredResolve<T>;
+type TRequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<TRequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S>> : T extends TObject<infer S> ? TObject<TFromProperties<S>> : TObject<{}>);
+export type TRequired<T extends TSchema> = TRequiredResolve<T>;
 /** `[Json]` Constructs a type where all properties are required */
 export declare function Required<T extends TMappedResult>(T: T, options?: SchemaOptions): TRequiredFromMappedResult<T>;
 /** `[Json]` Constructs a type where all properties are required */

package/build/import/type/required/required.mjs

@@ -8,21 +8,20 @@ import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
 // prettier-ignore
-function FromIntersect(T) {
+function FromIntersect(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [RequiredResolve(L), ...FromIntersect(R)]
-        : []);
+        ? FromIntersect(R, [...Acc, RequiredResolve(L)])
+        : Acc);
 }
 // prettier-ignore
-function FromUnion(T) {
+function FromUnion(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [RequiredResolve(L), ...FromUnion(R)]
-        : []);
+        ? FromUnion(R, [...Acc, RequiredResolve(L)])
+        : Acc);
 }
 // prettier-ignore
 function FromProperties(T) {

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/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/template-literal/finite.d.mts

@@ -9,10 +9,10 @@ import type { TLiteral } from '../literal/index.mjs';
 import type { Expression } from './parse.mjs';
 export declare class TemplateLiteralFiniteError extends Error {
 }
-type FromTemplateLiteralKind<T> = T extends TTemplateLiteral<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<U> : T extends TUnion<infer U extends TTemplateLiteralKind[]> ? FromTemplateLiteralKinds<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 FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? FromTemplateLiteralKind<L> extends false ? false : FromTemplateLiteralKinds<R> : true;
+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> ? FromTemplateLiteralKinds<U> : false;
+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/generate.d.mts

@@ -7,15 +7,14 @@ import type { Expression } from './parse.mjs';
 import type { TUnion } from '../union/index.mjs';
 export declare class TemplateLiteralGenerateError extends Error {
 }
-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 ? Assert<O[0], string[]> : [];
-type FromTemplateLiteralUnionKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TLiteral, ...infer R extends TLiteral[]] ? [L['const'], ...FromTemplateLiteralUnionKinds<R>] : [];
-type FromTemplateLiteralKinds<T extends TTemplateLiteralKind[]> = T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? (L extends TLiteral<infer S extends TLiteralValue> ? [[S], ...FromTemplateLiteralKinds<R>] : L extends TUnion<infer S extends TTemplateLiteralKind[]> ? [FromTemplateLiteralUnionKinds<S>, ...FromTemplateLiteralKinds<R>] : L extends TBoolean ? [['true', 'false'], ...FromTemplateLiteralKinds<R>] : [
-]) : [];
+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[]> ? FromTemplateLiteralKinds<S> extends infer R extends string[][] ? StringReduce<R> : [] : []) : [];
+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/syntax.d.mts

@@ -5,12 +5,12 @@ 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>] : [
 ];