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

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

@@ -8,32 +8,22 @@ import { type TMappedKey } from '../mapped/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TTuple } from '../tuple/index.mjs';
 import { type TArray } from '../array/index.mjs';
-import { IntersectEvaluated } from '../intersect/index.mjs';
-import { UnionEvaluated } from '../union/index.mjs';
+import { type TIntersectEvaluated } from '../intersect/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TIndexPropertyKeys } from './indexed-property-keys.mjs';
 import { type TIndexFromMappedKey } from './indexed-from-mapped-key.mjs';
-type FromRest<T extends TSchema[], K extends PropertyKey> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromKey<L, K>, ...FromRest<R, K>] : []);
-declare function FromRest<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromRest<T, K>;
-type FromIntersectRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [...FromIntersectRest<R>] : [L, ...FromIntersectRest<R>] : []);
-declare function FromIntersectRest<T extends TSchema[]>(T: [...T]): FromIntersectRest<T>;
-type FromIntersect<T extends TSchema[], K extends PropertyKey> = (IntersectEvaluated<FromIntersectRest<FromRest<T, K>>>);
-declare function FromIntersect<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromIntersect<T, K>;
-type FromUnionRest<T extends TSchema[], S = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : FromUnionRest<R, S> : S);
-declare function FromUnionRest<T extends TSchema[]>(T: [...T], S?: [...T]): FromUnionRest<T>;
-type FromUnion<T extends TSchema[], K extends PropertyKey> = (UnionEvaluated<FromUnionRest<FromRest<T, K>>>);
-declare function FromUnion<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromUnion<T, K>;
-type FromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? UnionEvaluated<T> : TNever);
-declare function FromTuple<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): FromTuple<T, K>;
-type FromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
-declare function FromArray<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromArray<T, K>;
+type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TFromKey<L, K>, TSchema>]> : Acc);
+type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
+type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
+type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = T> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : TFromUnionRest<R, Acc> : Acc);
+type TFromUnion<T extends TSchema[], K extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>);
+type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? TUnionEvaluated<T> : TNever);
+type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);
 type AssertPropertyKey<T> = Assert<T, string | number>;
-type FromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
-declare function FromProperty<T extends TProperties, K extends PropertyKey>(T: T, K: K): FromProperty<T, K>;
-type FromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? FromKey<S, K> : T extends TIntersect<infer S> ? FromIntersect<S, K> : T extends TUnion<infer S> ? FromUnion<S, K> : T extends TTuple<infer S> ? FromTuple<S, K> : T extends TArray<infer S> ? FromArray<S, K> : T extends TObject<infer S> ? FromProperty<S, K> : TNever);
-declare function FromKey<T extends TSchema, K extends PropertyKey>(T: T, K: K): FromKey<T, K>;
-type FromKeys<T extends TSchema, K extends PropertyKey[]> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? [FromKey<T, L>, ...FromKeys<T, R>] : []);
-declare function FromKeys<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromKeys<T, K>;
-type FromSchema<T extends TSchema, K extends PropertyKey[]> = (UnionEvaluated<FromKeys<T, K>>);
+type TFromProperty<T extends TProperties, K extends PropertyKey> = (K extends keyof T ? T[K] : `${AssertPropertyKey<K>}` extends `${AssertPropertyKey<keyof T>}` ? T[AssertPropertyKey<K>] : TNever);
+type TFromKey<T extends TSchema, K extends PropertyKey> = (T extends TRecursive<infer S> ? TFromKey<S, K> : T extends TIntersect<infer S> ? TFromIntersect<S, K> : T extends TUnion<infer S> ? TFromUnion<S, K> : T extends TTuple<infer S> ? TFromTuple<S, K> : T extends TArray<infer S> ? TFromArray<S, K> : T extends TObject<infer S> ? TFromProperty<S, K> : TNever);
+type TFromKeys<T extends TSchema, K extends PropertyKey[], Acc extends TSchema[] = []> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TFromKeys<T, R, [...Acc, Assert<TFromKey<T, L>, TSchema>]> : Acc);
+type FromSchema<T extends TSchema, K extends PropertyKey[]> = (TUnionEvaluated<TFromKeys<T, K>>);
 declare function FromSchema<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): FromSchema<T, K>;
 export type TIndex<T extends TSchema, K extends PropertyKey[]> = (FromSchema<T, K>);
 /** `[Json]` Returns an Indexed property type for the given keys */

package/build/import/type/indexed/indexed.mjs

@@ -10,33 +10,33 @@ import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 // prettier-ignore
 import { IsArray, IsIntersect, IsObject, IsMappedKey, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
-function FromRest(T, K) {
+function FromRest(T, K, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromKey(L, K), ...FromRest(R, K)]
-        : []);
+        ? FromRest(R, K, [...Acc, FromKey(L, K)])
+        : Acc);
 }
 // prettier-ignore
-function FromIntersectRest(T) {
+function FromIntersectRest(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
         ? IsNever(L)
-            ? [...FromIntersectRest(R)]
-            : [L, ...FromIntersectRest(R)]
-        : []);
+            ? FromIntersectRest(R, [...Acc])
+            : FromIntersectRest(R, [...Acc, L])
+        : Acc);
 }
 // prettier-ignore
 function FromIntersect(T, K) {
     return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
 }
 // prettier-ignore
-function FromUnionRest(T, S = T) {
+function FromUnionRest(T, Acc = T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? IsNever(L)
             ? []
-            : FromUnionRest(R, S)
-        : S);
+            : FromUnionRest(R, Acc)
+        : Acc);
 }
 // prettier-ignore
 function FromUnion(T, K) {
@@ -70,11 +70,11 @@ function FromKey(T, K) {
                         Never());
 }
 // prettier-ignore
-function FromKeys(T, K) {
+function FromKeys(T, K, Acc = []) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? [FromKey(T, L), ...FromKeys(T, R)]
-        : []);
+        ? FromKeys(T, R, [...Acc, FromKey(T, L)])
+        : Acc);
 }
 // prettier-ignore
 function FromSchema(T, K) {

package/build/import/type/intersect/intersect-create.mjs

@@ -3,7 +3,6 @@ import { CloneType, CloneRest } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsObject, IsSchema } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // IntersectCreate

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

@@ -1,17 +1,13 @@
-import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TOptional } from '../optional/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import { TIntersect, IntersectOptions } from './intersect-type.mjs';
-type IsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? IsIntersectOptional<R> : false : true);
-declare function IsIntersectOptional<T extends TSchema[]>(T: T): IsIntersectOptional<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 ResolveIntersect<T extends TSchema[]> = (IsIntersectOptional<T> extends true ? TOptional<TIntersect<RemoveOptionalFromRest<T>>> : TIntersect<RemoveOptionalFromRest<T>>);
-declare function ResolveIntersect<T extends TSchema[]>(T: [...T], options: SchemaOptions): ResolveIntersect<T>;
-export type IntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : ResolveIntersect<T>);
+type TIsIntersectOptional<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TOptional<TSchema> ? TIsIntersectOptional<R> : false : true);
+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 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 TResolveIntersect<T extends TSchema[]> = (TIsIntersectOptional<T> extends true ? TOptional<TIntersect<TRemoveOptionalFromRest<T>>> : TIntersect<TRemoveOptionalFromRest<T>>);
+export type TIntersectEvaluated<T extends TSchema[]> = (T extends [] ? TNever : T extends [TSchema] ? T[0] : TResolveIntersect<T>);
 /** `[Json]` Creates an evaluated Intersect type */
-export declare function IntersectEvaluated<T extends TSchema[], R = IntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
+export declare function IntersectEvaluated<T extends TSchema[], R = TIntersectEvaluated<T>>(T: [...T], options?: IntersectOptions): R;
 export {};

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

@@ -8,25 +8,30 @@ import { IntersectCreate } from './intersect-create.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { IsOptional as IsOptionalType, IsTransform as IsTransformType, } from '../guard/type.mjs';
+import { IsOptional, IsTransform, } from '../guard/type.mjs';
 // prettier-ignore
 function IsIntersectOptional(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? IsOptionalType(L)
+        ? IsOptional(L)
             ? IsIntersectOptional(R)
             : false
         : true);
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T) {
-    return (T.map(T => RemoveOptionalFromType(T)));
-}
-// prettier-ignore
 function RemoveOptionalFromType(T) {
     return (Discard(T, [OptionalKind]));
 }
 // prettier-ignore
+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 ResolveIntersect(T, options) {
     return (IsIntersectOptional(T)
         ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
@@ -38,7 +43,7 @@ export function IntersectEvaluated(T, options = {}) {
         return Never(options);
     if (T.length === 1)
         return CloneType(T[0], options);
-    if (T.some((schema) => IsTransformType(schema)))
+    if (T.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
     return ResolveIntersect(T, options);
 }

package/build/import/type/intersect/intersect-type.d.mts

@@ -1,14 +1,14 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import { Kind } from '../symbols/index.mjs';
-type IntersectStatic<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? Static<L, P> & IntersectStatic<R, P> : unknown;
+type TIntersectStatic<T extends TSchema[], P extends unknown[], Acc extends unknown = unknown> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TIntersectStatic<R, P, Acc & Static<L, P>> : Acc;
 export type TUnevaluatedProperties = undefined | TSchema | boolean;
 export interface IntersectOptions extends SchemaOptions {
     unevaluatedProperties?: TUnevaluatedProperties;
 }
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
     [Kind]: 'Intersect';
-    static: IntersectStatic<T, this['params']>;
+    static: TIntersectStatic<T, this['params']>;
     type?: 'object';
     allOf: [...T];
 }

package/build/import/type/intersect/intersect.mjs

@@ -4,8 +4,7 @@ import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsTransform, } from '../guard/type.mjs';
+import { IsTransform } from '../guard/type.mjs';
 /** `[Json]` Creates an evaluated Intersect type */
 export function Intersect(T, options = {}) {
     if (T.length === 0)

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

@@ -1,16 +1,14 @@
 import type { SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
+import { Assert } from '../helpers/index.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
 import { type TIntrinsic, type IntrinsicMode } from './intrinsic.mjs';
 import { TLiteral, TLiteralValue } from '../literal/index.mjs';
-type MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode, P extends TLiteralValue = K extends TLiteralValue ? K : never> = {
-    [_ in K]: TIntrinsic<TLiteral<P>, M>;
+type TMappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode> = {
+    [_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>;
 };
-declare function MappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode>(K: K, M: M, options: SchemaOptions): MappedIntrinsicPropertyKey<K, M>;
-type MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? MappedIntrinsicPropertyKey<L, M> & MappedIntrinsicPropertyKeys<R, M> : {});
-declare function MappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode>(K: [...K], M: M, options: SchemaOptions): MappedIntrinsicPropertyKeys<K, M>;
-type MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (MappedIntrinsicPropertyKeys<K['keys'], M>);
-declare function MappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode>(T: K, M: M, options: SchemaOptions): MappedIntrinsicProperties<K, M>;
-export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
-export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = MappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
+type TMappedIntrinsicPropertyKeys<K extends PropertyKey[], M extends IntrinsicMode, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIntrinsicPropertyKeys<R, M, Acc & TMappedIntrinsicPropertyKey<L, M>> : Acc);
+type TMappedIntrinsicProperties<K extends TMappedKey, M extends IntrinsicMode> = (TMappedIntrinsicPropertyKeys<K['keys'], M>);
+export type TIntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>> = (TMappedResult<P>);
+export declare function IntrinsicFromMappedKey<K extends TMappedKey, M extends IntrinsicMode, P extends TProperties = TMappedIntrinsicProperties<K, M>>(T: K, M: M, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -8,11 +8,11 @@ function MappedIntrinsicPropertyKey(K, M, options) {
     };
 }
 // prettier-ignore
-function MappedIntrinsicPropertyKeys(K, M, options) {
+function MappedIntrinsicPropertyKeys(K, M, options, Acc = {}) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { ...MappedIntrinsicPropertyKey(L, M, options), ...MappedIntrinsicPropertyKeys(R, M, options) }
-        : {});
+        ? MappedIntrinsicPropertyKeys(R, M, options, { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) })
+        : Acc);
 }
 // prettier-ignore
 function MappedIntrinsicProperties(T, M, options) {

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

@@ -1,17 +1,15 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import { type TTemplateLiteral, type TTemplateLiteralKind } from '../template-literal/index.mjs';
 import { type TIntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
-import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TMappedKey } from '../mapped/index.mjs';
 export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
-type FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...FromTemplateLiteral<R, M>] : T : T;
-declare function FromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode>(schema: TTemplateLiteral, mode: IntrinsicMode, options: SchemaOptions): FromTemplateLiteral<T, M>;
-type FromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
-declare function FromLiteralValue(value: TLiteralValue, mode: IntrinsicMode): string;
-type FromRest<T extends TSchema[], M extends IntrinsicMode> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [TIntrinsic<L, M>, ...FromRest<R, M>] : [];
-declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], mode: M): FromRest<T, M>;
-export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<FromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<FromLiteralValue<S, M>> : T;
+type TFromTemplateLiteral<T extends TTemplateLiteralKind[], M extends IntrinsicMode> = M extends IntrinsicMode ? T extends [infer L extends TTemplateLiteralKind, ...infer R extends TTemplateLiteralKind[]] ? [TIntrinsic<L, M>, ...TFromTemplateLiteral<R, M>] : T : T;
+type TFromLiteralValue<T, M extends IntrinsicMode> = (T extends string ? M extends 'Uncapitalize' ? Uncapitalize<T> : M extends 'Capitalize' ? Capitalize<T> : M extends 'Uppercase' ? Uppercase<T> : M extends 'Lowercase' ? Lowercase<T> : string : T);
+type FromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromRest<R, M, [...Acc, TIntrinsic<L, M>]> : Acc;
+declare function FromRest<T extends TSchema[], M extends IntrinsicMode>(T: [...T], M: M, Acc?: TSchema[]): FromRest<T, M>;
+export type TIntrinsic<T extends TSchema, M extends IntrinsicMode> = T extends TMappedKey ? TIntrinsicFromMappedKey<T, M> : T extends TTemplateLiteral<infer S> ? TTemplateLiteral<TFromTemplateLiteral<S, M>> : T extends TUnion<infer S> ? TUnion<FromRest<S, M>> : T extends TLiteral<infer S> ? TLiteral<TFromLiteralValue<S, M>> : T;
 /** Applies an intrinsic string manipulation to the given type. */
 export declare function Intrinsic<T extends TMappedKey, M extends IntrinsicMode>(schema: T, mode: M, options?: SchemaOptions): TIntrinsicFromMappedKey<T, M>;
 /** Applies an intrinsic string manipulation to the given type. */

package/build/import/type/intrinsic/intrinsic.mjs

@@ -1,11 +1,10 @@
-import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
+import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralExpressionFinite, TemplateLiteralExpressionGenerate } from '../template-literal/index.mjs';
 import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Union } from '../union/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // Apply
@@ -28,10 +27,10 @@ function FromTemplateLiteral(schema, mode, options) {
     // note: template literals require special runtime handling as they are encoded in string patterns.
     // This diverges from the mapped type which would otherwise map on the template literal kind.
     const expression = TemplateLiteralParseExact(schema.pattern);
-    const finite = IsTemplateLiteralFinite(expression);
+    const finite = IsTemplateLiteralExpressionFinite(expression);
     if (!finite)
         return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
-    const strings = [...TemplateLiteralGenerate(expression)];
+    const strings = [...TemplateLiteralExpressionGenerate(expression)];
     const literals = strings.map((value) => Literal(value));
     const mapped = FromRest(literals, mode);
     const union = Union(mapped);
@@ -45,9 +44,12 @@ function FromLiteralValue(value, mode) {
                 mode === 'Lowercase' ? ApplyLowercase(value) :
                     value) : value.toString());
 }
-function FromRest(T, mode) {
+// prettier-ignore
+function FromRest(T, M, Acc = []) {
     const [L, ...R] = T;
-    return (T.length > 0 ? [Intrinsic(L, mode), ...FromRest(R, mode)] : []);
+    return (T.length > 0
+        ? FromRest(R, M, [...Acc, Intrinsic(L, M)])
+        : Acc);
 }
 /** Applies an intrinsic string manipulation to the given type. */
 export function Intrinsic(schema, mode, options = {}) {

package/build/import/type/keyof/keyof-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 TKeyOf } from './keyof.mjs';
-type FromProperties<K extends TProperties> = ({
+type TFromProperties<K extends TProperties> = ({
     [K2 in keyof K]: TKeyOf<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 TKeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>> = (TMappedResult<P>);
-export declare function KeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = FromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult> = (TFromProperties<K['properties']>);
+export type TKeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>> = (TMappedResult<P>);
+export declare function KeyOfFromMappedResult<T extends TMappedResult, P extends TProperties = TFromMappedResult<T>>(T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/keyof/keyof-property-keys.d.mts

@@ -7,24 +7,20 @@ import type { TTuple } from '../tuple/index.mjs';
 import type { TArray } from '../array/index.mjs';
 import type { TObject, TProperties } from '../object/index.mjs';
 import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
-type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [KeyOfPropertyKeys<L>, ...FromRest<R>] : []);
-declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
-type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = FromRest<T>> = (OperatorUnionMany<C>);
-declare function FromIntersect<T extends TSchema[]>(T: [...T], C?: FromRest<T>): FromIntersect<T>;
-type FromUnion<T extends TSchema[], C extends PropertyKey[][] = FromRest<T>> = (OperatorIntersectMany<C>);
+type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]> : Acc);
+type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = OperatorUnionMany<C>> = R;
+declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
+type FromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = OperatorIntersectMany<C>> = R;
 declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
-type FromTuple<T extends TSchema[], I extends string = ZeroString> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? [I, ...FromTuple<R, Increment<I>>] : [];
-declare function FromTuple<T extends TSchema[]>(T: [...T], I?: string): FromTuple<T>;
-type FromArray<_ extends TSchema> = ([
+type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, Increment<I>, [...Acc, I]> : Acc;
+type TFromArray<_ extends TSchema> = ([
     '[number]'
 ]);
-declare function FromArray<_ extends TSchema>(_: _): FromArray<_>;
-type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
-declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
-export type KeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
+type TFromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
+export type TKeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? TFromTuple<S> : T extends TArray<infer S> ? TFromArray<S> : T extends TObject<infer S> ? TFromProperties<S> : [
 ]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
-export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): KeyOfPropertyKeys<T>;
+export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T>;
 /** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};

package/build/import/type/keyof/keyof-property-keys.mjs

@@ -6,27 +6,30 @@ import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs
 // prettier-ignore
 import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/type.mjs';
 // prettier-ignore
-function FromRest(T) {
+function FromRest(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [KeyOfPropertyKeys(L), ...FromRest(R)]
-        : []);
+        ? FromRest(R, [...Acc, KeyOfPropertyKeys(L)])
+        : Acc);
 }
 // prettier-ignore
-function FromIntersect(T, C = FromRest(T)) {
-    return OperatorUnionMany(C);
+function FromIntersect(T) {
+    const C = FromRest(T);
+    const R = OperatorUnionMany(C);
+    return R;
 }
 // prettier-ignore
 function FromUnion(T) {
     const C = FromRest(T);
-    return OperatorIntersectMany(C);
+    const R = OperatorIntersectMany(C);
+    return R;
 }
 // prettier-ignore
-function FromTuple(T, I = '0') {
+function FromTuple(T, I = '0', Acc = []) {
     const [_, ...R] = T;
     return (T.length > 0
-        ? [I, ...FromTuple(R, Increment(I))]
-        : []);
+        ? FromTuple(R, Increment(I), [...Acc, I])
+        : Acc);
 }
 // prettier-ignore
 function FromArray(_) {

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

@@ -1,15 +1,14 @@
 import type { TSchema } from '../schema/index.mjs';
-import type { Ensure } from '../helpers/index.mjs';
+import type { Assert, Ensure } from '../helpers/index.mjs';
 import type { TMappedResult } from '../mapped/index.mjs';
-import { type TLiteral, TLiteralValue } from '../literal/index.mjs';
+import type { SchemaOptions } from '../schema/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNumber } from '../number/index.mjs';
-import { type SchemaOptions } from '../schema/index.mjs';
-import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
-import { UnionEvaluated } from '../union/index.mjs';
+import { type TKeyOfPropertyKeys } from './keyof-property-keys.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
-type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
-declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
-export type TKeyOf<T extends TSchema> = (Ensure<UnionEvaluated<FromLiterals<KeyOfPropertyKeys<T>>>>);
+type TFromPropertyKeys<T extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? L extends '[number]' ? TFromPropertyKeys<R, [...Acc, TNumber]> : TFromPropertyKeys<R, [...Acc, TLiteral<Assert<L, TLiteralValue>>]> : Acc);
+export type TKeyOf<T extends TSchema, K extends PropertyKey[] = TKeyOfPropertyKeys<T>, S extends TSchema[] = TFromPropertyKeys<K>, U = TUnionEvaluated<S>> = (Ensure<U>);
 /** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
 /** `[Json]` Creates a KeyOf type */

package/build/import/type/keyof/keyof.mjs

@@ -10,13 +10,13 @@ import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // prettier-ignore
 import { IsMappedResult } from '../guard/type.mjs';
 // prettier-ignore
-function FromLiterals(T) {
+function FromPropertyKeys(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
         ? L === '[number]'
-            ? [Number(), ...FromLiterals(R)]
-            : [Literal(L), ...FromLiterals(R)]
-        : []);
+            ? FromPropertyKeys(R, [...Acc, Number()])
+            : FromPropertyKeys(R, [...Acc, Literal(L)])
+        : Acc);
 }
 /** `[Json]` Creates a KeyOf type */
 export function KeyOf(T, options = {}) {
@@ -24,7 +24,9 @@ export function KeyOf(T, options = {}) {
         return KeyOfFromMappedResult(T, options);
     }
     else {
-        const K = UnionEvaluated(FromLiterals(KeyOfPropertyKeys(T)));
-        return CloneType(K, options);
+        const K = KeyOfPropertyKeys(T);
+        const S = FromPropertyKeys(K);
+        const U = UnionEvaluated(S);
+        return CloneType(U, options);
     }
 }

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

@@ -16,26 +16,22 @@ import { type TTuple } from '../tuple/index.mjs';
 import { type TUnion } from '../union/index.mjs';
 import { type TMappedResult } from './mapped-result.mjs';
 import type { TMappedKey } from './mapped-key.mjs';
-type FromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TMappedResult<P>);
-declare function FromMappedResult<K extends PropertyKey, P extends TProperties>(K: K, P: P): FromMappedResult<K, P>;
-type MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]> = (P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+type TFromMappedResult<K extends PropertyKey, P extends TProperties> = (K extends keyof P ? FromSchemaType<K, P[K]> : TMappedResult<P>);
+type TMappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[], Acc extends TProperties = {}> = (P extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedKeyToMappedResultProperties<K, R, Acc & {
     [_ in L]: TLiteral<Assert<L, TLiteralValue>>;
-} & MappedKeyToMappedResultProperties<K, R> : {});
-declare function MappedKeyToMappedResultProperties<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): MappedKeyToMappedResultProperties<K, P>;
-type FromMappedKey<K extends PropertyKey, P extends PropertyKey[], R extends TProperties = MappedKeyToMappedResultProperties<K, P>> = (FromMappedResult<K, R>);
-declare function FromMappedKey<K extends PropertyKey, P extends PropertyKey[]>(K: K, P: [...P]): FromMappedResult<K, MappedKeyToMappedResultProperties<K, P>>;
-type FromRest<K extends PropertyKey, T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchemaType<K, L>, ...FromRest<K, R>] : [];
-declare function FromRest<K extends PropertyKey, T extends TSchema[]>(K: K, T: [...T]): FromRest<K, T>;
+}> : Acc);
+type TFromMappedKey<K extends PropertyKey, P extends PropertyKey[], R extends TProperties = TMappedKeyToMappedResultProperties<K, P>> = (TFromMappedResult<K, R>);
+type TFromRest<K extends PropertyKey, T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<K, R, [...Acc, FromSchemaType<K, L>]> : Acc);
 type FromProperties<K extends PropertyKey, T extends TProperties, R extends TProperties = Evaluate<{
     [K2 in keyof T]: FromSchemaType<K, T[K2]>;
 }>> = R;
 declare function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T>;
-type FromSchemaType<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S> ? TReadonly<FromSchemaType<K, S>> : T extends TOptional<infer S> ? TOptional<FromSchemaType<K, S>> : T extends TMappedResult<infer P> ? FromMappedResult<K, P> : T extends TMappedKey<infer P> ? FromMappedKey<K, P> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<K, S>, FromSchemaType<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<K, S>, FromSchemaType<K, R>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<FromSchemaType<K, S>> : T extends TIterator<infer S> ? TIterator<FromSchemaType<K, S>> : T extends TIntersect<infer S> ? TIntersect<FromRest<K, S>> : T extends TUnion<infer S> ? TUnion<FromRest<K, S>> : T extends TTuple<infer S> ? TTuple<FromRest<K, S>> : T extends TObject<infer S> ? TObject<FromProperties<K, S>> : T extends TArray<infer S> ? TArray<FromSchemaType<K, S>> : T extends TPromise<infer S> ? TPromise<FromSchemaType<K, S>> : T);
+type FromSchemaType<K extends PropertyKey, T extends TSchema> = (T extends TReadonly<infer S> ? TReadonly<FromSchemaType<K, S>> : T extends TOptional<infer S> ? TOptional<FromSchemaType<K, S>> : T extends TMappedResult<infer P> ? TFromMappedResult<K, P> : T extends TMappedKey<infer P> ? TFromMappedKey<K, P> : T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<K, S>, FromSchemaType<K, R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<K, S>, FromSchemaType<K, R>> : T extends TAsyncIterator<infer S> ? TAsyncIterator<FromSchemaType<K, S>> : T extends TIterator<infer S> ? TIterator<FromSchemaType<K, S>> : T extends TIntersect<infer S> ? TIntersect<TFromRest<K, S>> : T extends TUnion<infer S> ? TUnion<TFromRest<K, S>> : T extends TTuple<infer S> ? TTuple<TFromRest<K, S>> : T extends TObject<infer S> ? TObject<FromProperties<K, S>> : T extends TArray<infer S> ? TArray<FromSchemaType<K, S>> : T extends TPromise<infer S> ? TPromise<FromSchemaType<K, S>> : T);
 declare function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K, T: T): FromSchemaType<K, T>;
-type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? {
+type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? FromMappedFunctionReturnType<R, T, Acc & {
     [_ in L]: FromSchemaType<L, T>;
-} & FromMappedFunctionReturnType<R, T> : {});
-declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedFunctionReturnType<K, T>;
+}> : Acc);
+declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc?: TProperties): FromMappedFunctionReturnType<K, T>;
 export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
 export type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
 /** `[Json]` Creates a Mapped object type */

package/build/import/type/mapped/mapped.mjs

@@ -30,11 +30,11 @@ function FromMappedResult(K, P) {
         : MappedResult(P));
 }
 // prettier-ignore
-function MappedKeyToMappedResultProperties(K, P) {
+function MappedKeyToMappedResultProperties(K, P, Acc = {}) {
     const [L, ...R] = P;
     return (P.length > 0
-        ? { [L]: Literal(L), ...MappedKeyToMappedResultProperties(K, R) }
-        : {});
+        ? MappedKeyToMappedResultProperties(K, R, { ...Acc, [L]: Literal(L) })
+        : Acc);
 }
 // prettier-ignore
 function FromMappedKey(K, P) {
@@ -42,11 +42,11 @@ function FromMappedKey(K, P) {
     return FromMappedResult(K, R);
 }
 // prettier-ignore
-function FromRest(K, T) {
+function FromRest(K, T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromSchemaType(K, L), ...FromRest(K, R)]
-        : []);
+        ? FromRest(K, R, [...Acc, FromSchemaType(K, L)])
+        : Acc);
 }
 // prettier-ignore
 function FromProperties(K, T) {
@@ -77,11 +77,11 @@ function FromSchemaType(K, T) {
                                                             T);
 }
 // prettier-ignore
-function FromMappedFunctionReturnType(K, T) {
+function FromMappedFunctionReturnType(K, T, Acc = {}) {
     const [L, ...R] = K;
     return (K.length > 0
-        ? { [L]: FromSchemaType(L, T), ...FromMappedFunctionReturnType(R, T) }
-        : {});
+        ? FromMappedFunctionReturnType(R, T, { ...Acc, [L]: FromSchemaType(L, T) })
+        : Acc);
 }
 /** `[Json]` Creates a Mapped object type */
 export function Mapped(key, map, options = {}) {