@sinclair/typebox 0.32.0-dev-26 → 0.32.0-dev-27

package/build/import/index.d.mts

@@ -36,11 +36,11 @@ export { Not, type TNot } from './type/not/index.mjs';
 export { Null, type TNull } from './type/null/index.mjs';
 export { Number, type TNumber, type NumberOptions } from './type/number/index.mjs';
 export { Object, type TObject, type TProperties, type ObjectOptions } from './type/object/index.mjs';
-export { Omit, type TOmit, type TOmitFromMappedKey } from './type/omit/index.mjs';
+export { Omit, type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from './type/omit/index.mjs';
 export { Optional, OptionalFromMappedResult, type TOptional, type TOptionalWithFlag, type TOptionalFromMappedResult } from './type/optional/index.mjs';
 export { Parameters, type TParameters } from './type/parameters/index.mjs';
 export { Partial, PartialFromMappedResult, type TPartial, type TPartialFromMappedResult } from './type/partial/index.mjs';
-export { Pick, type TPick, type TPickFromMappedKey } from './type/pick/index.mjs';
+export { Pick, type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from './type/pick/index.mjs';
 export { Promise, type TPromise } from './type/promise/index.mjs';
 export { Readonly, ReadonlyFromMappedResult, type TReadonly, type TReadonlyWithFlag, type TReadonlyFromMappedResult } from './type/readonly/index.mjs';
 export { ReadonlyOptional, type TReadonlyOptional } from './type/readonly-optional/index.mjs';

package/build/import/type/awaited/awaited.mjs

@@ -4,14 +4,10 @@ import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsIntersect, IsUnion, IsPromise } from '../guard/type.mjs';
 // prettier-ignore
-function FromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, [...Acc, FromSchema(L)])
-        : Acc);
+function FromRest(T) {
+    return T.map(L => FromSchema(L));
 }
 // prettier-ignore
 function FromIntersect(T) {

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

@@ -7,8 +7,7 @@ type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc ex
     [_ in L]: TIndex<T, [L]>;
 }> : Acc;
 type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
-export declare function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T>;
+type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
 export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;

package/build/import/type/composite/composite.mjs

@@ -1,9 +1,9 @@
 import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
-import { KeyOfPropertyKeys } from '../keyof/index.mjs';
 import { Index } from '../indexed/index.mjs';
+import { KeyOfPropertyKeys } from '../keyof/index.mjs';
 import { CloneType } from '../clone/type.mjs';
-export function CompositeResolve(T) {
+function CompositeResolve(T) {
     const intersect = Intersect(T, {});
     const keys = KeyOfPropertyKeys(intersect);
     const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {});

package/build/import/type/const/const.mjs

@@ -1,4 +1,3 @@
-import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
 import { Any } from '../any/index.mjs';
 import { BigInt } from '../bigint/index.mjs';
 import { Date } from '../date/index.mjs';
@@ -13,12 +12,13 @@ import { Undefined } from '../undefined/index.mjs';
 import { Uint8Array } from '../uint8array/index.mjs';
 import { Unknown } from '../unknown/index.mjs';
 import { TypeClone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
 // prettier-ignore
 function FromArray(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [FromValue(L, false), ...FromArray(R)]
-        : []);
+    return T.map(L => FromValue(L, false));
 }
 // prettier-ignore
 function FromProperties(value) {
@@ -33,7 +33,7 @@ function ConditionalReadonly(T, root) {
 function FromValue(value, root) {
     return (IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
         IsIterator(value) ? ConditionalReadonly(Any(), root) :
-            IsArray(value) ? Readonly(Tuple(FromArray(value))) : // Always Readonly
+            IsArray(value) ? Readonly(Tuple(FromArray(value))) :
                 IsUint8Array(value) ? Uint8Array() :
                     IsDate(value) ? Date() :
                         IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :

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

@@ -4,7 +4,7 @@ import type { Ensure } from '../helpers/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
 type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
-export type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
+type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
     static: ConstructorStatic<T, U, this['params']>;

package/build/import/type/constructor/constructor.mjs

@@ -1,5 +1,5 @@
-import { Kind } from '../symbols/index.mjs';
 import { CloneType, CloneRest } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a Constructor type */
 export function Constructor(parameters, returns, options) {
     return {

package/build/import/type/deref/deref.mjs

@@ -4,8 +4,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef, } from '../guard/type.mjs';
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef } from '../guard/type.mjs';
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));
 }

package/build/import/type/discard/discard.mjs

@@ -1,7 +1,7 @@
-function Key(value, key) {
+function DiscardKey(value, key) {
     const { [key]: _, ...rest } = value;
     return rest;
 }
 export function Discard(value, keys) {
-    return keys.reduce((acc, key) => Key(acc, key), value);
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
 }

package/build/import/type/enum/enum.mjs

@@ -1,6 +1,9 @@
 import { Literal } from '../literal/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 import { Union } from '../union/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
 import { IsUndefined } from '../guard/value.mjs';
 /** `[Json]` Creates a Enum type */
 export function Enum(item, options = {}) {

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

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExclude } from './exclude.mjs';
-type TFromProperties<K extends TProperties, U extends TSchema> = ({
-    [K2 in keyof K]: TExclude<K[K2], U>;
+type TFromProperties<K extends TProperties, T extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], T>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
-export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/exclude/exclude-from-mapped-result.mjs

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Exclude } from './exclude.mjs';
 // prettier-ignore
-function FromProperties(K, U, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Exclude(K[K2], U, options) };
+function FromProperties(P, U, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Exclude(P[K2], U, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, options) {
-    return FromProperties(K.properties, U, options);
+function FromMappedResult(R, T, options) {
+    return FromProperties(R.properties, T, options);
 }
 // prettier-ignore
-export function ExcludeFromMappedResult(T, U, options) {
-    const P = FromMappedResult(T, U, options);
+export function ExcludeFromMappedResult(R, T, options) {
+    const P = FromMappedResult(R, T, options);
     return MappedResult(P);
 }

package/build/import/type/exclude/exclude.mjs

@@ -7,7 +7,6 @@ import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
 function ExcludeResolve(L, R) {

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

@@ -2,7 +2,7 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import type { Assert } from '../helpers/index.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-import { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TExtends } from './extends.mjs';
 type TFromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
     [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;

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

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

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

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExtends } from './extends.mjs';
-type TFromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+type TFromProperties<P extends TProperties, Right extends TSchema, False extends TSchema, True extends TSchema> = ({
+    [K2 in keyof P]: TExtends<P[K2], Right, False, True>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromProperties<K['properties'], U, L, R>);
-export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema> = (TFromProperties<Left['properties'], Right, True, False>);
+export type TExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>>(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/extends/extends-from-mapped-result.mjs

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Extends } from './extends.mjs';
 // prettier-ignore
-function FromProperties(K, U, L, R, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extends(K[K2], U, L, R, options) };
+function FromProperties(P, Right, True, False, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extends(P[K2], Right, True, False, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, L, R, options) {
-    return FromProperties(K.properties, U, L, R, options);
+function FromMappedResult(Left, Right, True, False, options) {
+    return FromProperties(Left.properties, Right, True, False, options);
 }
 // prettier-ignore
-export function ExtendsFromMappedResult(T, U, L, R, options) {
-    const P = FromMappedResult(T, U, L, R, options);
+export function ExtendsFromMappedResult(Left, Right, True, False, options) {
+    const P = FromMappedResult(Left, Right, True, False, options);
     return MappedResult(P);
 }

package/build/import/type/extends/extends.mjs

@@ -6,7 +6,6 @@ import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedKey, IsMappedResult } from '../guard/type.mjs';
 // prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {

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

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExtract } from './extract.mjs';
-type TFromProperties<K extends TProperties, U extends TSchema> = ({
-    [K2 in keyof K]: TExtract<K[K2], U>;
+type TFromProperties<P extends TProperties, T extends TSchema> = ({
+    [K2 in keyof P]: TExtract<P[K2], T>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
-export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/extract/extract-from-mapped-result.mjs

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Extract } from './extract.mjs';
 // prettier-ignore
-function FromProperties(K, U, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extract(K[K2], U, options) };
+function FromProperties(P, T, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extract(P[K2], T, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, options) {
-    return FromProperties(K.properties, U, options);
+function FromMappedResult(R, T, options) {
+    return FromProperties(R.properties, T, options);
 }
 // prettier-ignore
-export function ExtractFromMappedResult(T, U, options) {
-    const P = FromMappedResult(T, U, options);
+export function ExtractFromMappedResult(R, T, options) {
+    const P = FromMappedResult(R, T, options);
     return MappedResult(P);
 }

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

@@ -14,8 +14,7 @@ type TFromTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extra
 type TFromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
     [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
 }[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
-export type TExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> : T extends TUnion<infer S> ? TFromArray<S, U> : T extends U ? T : T);
-export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): TExtractResolve<L, R>;
+type TExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T, U> : T extends TUnion<infer S> ? TFromArray<S, U> : T);
 export type TExtract<T extends TSchema, U extends TSchema> = TExtractResolve<T, U>;
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;

package/build/import/type/extract/extract.mjs

@@ -4,10 +4,12 @@ import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
-// prettier-ignore
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
 import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
-export function ExtractResolve(L, R) {
+function ExtractResolve(L, R) {
     return (IsTemplateLiteral(L) ? ExtractResolve(TemplateLiteralToUnion(L), R) :
         IsTemplateLiteral(R) ? ExtractResolve(L, TemplateLiteralToUnion(R)) :
             IsUnion(L) ? (() => {

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

@@ -35,7 +35,6 @@ export * from './null/index.mjs';
 export * from './number/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './operators/index.mjs';
 export * from './optional/index.mjs';
 export * from './parameters/index.mjs';
 export * from './partial/index.mjs';
@@ -53,6 +52,7 @@ export * from './required/index.mjs';
 export * from './rest/index.mjs';
 export * from './return-type/index.mjs';
 export * from './schema/index.mjs';
+export * from './sets/index.mjs';
 export * from './static/index.mjs';
 export * from './strict/index.mjs';
 export * from './string/index.mjs';

package/build/import/type/index.mjs

@@ -35,7 +35,6 @@ export * from './null/index.mjs';
 export * from './number/index.mjs';
 export * from './object/index.mjs';
 export * from './omit/index.mjs';
-export * from './operators/index.mjs';
 export * from './optional/index.mjs';
 export * from './parameters/index.mjs';
 export * from './partial/index.mjs';
@@ -53,6 +52,7 @@ export * from './required/index.mjs';
 export * from './rest/index.mjs';
 export * from './return-type/index.mjs';
 export * from './schema/index.mjs';
+export * from './sets/index.mjs';
 export * from './static/index.mjs';
 export * from './strict/index.mjs';
 export * from './string/index.mjs';

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

@@ -1,8 +1,8 @@
 import type { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { type TProperties } from '../object/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import type { TProperties } from '../object/index.mjs';
 import { type TIndex } from './indexed.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-import { Evaluate } from '../helpers/index.mjs';
 type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TIndex<T, [K]>;
 };

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

@@ -5,11 +5,10 @@ function MappedIndexPropertyKey(T, K, options) {
     return { [K]: Index(T, [K], options) };
 }
 // prettier-ignore
-function MappedIndexPropertyKeys(T, K, options, Acc = {}) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? MappedIndexPropertyKeys(T, R, options, { ...Acc, ...MappedIndexPropertyKey(T, L, options) })
-        : Acc);
+function MappedIndexPropertyKeys(T, K, options) {
+    return K.reduce((Acc, L) => {
+        return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+    }, {});
 }
 // prettier-ignore
 function MappedIndexProperties(T, K, options) {

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

@@ -6,7 +6,7 @@ import { type TIndex } from './index.mjs';
 type TFromProperties<T extends TSchema, P extends TProperties> = ({
     [K2 in keyof P]: TIndex<T, TIndexPropertyKeys<P[K2]>>;
 });
-type TFromMappedResult<T extends TSchema, K extends TMappedResult> = (TFromProperties<T, K['properties']>);
+type TFromMappedResult<T extends TSchema, R extends TMappedResult> = (TFromProperties<T, R['properties']>);
 export type TIndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>> = (TMappedResult<P>);
 export declare function IndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>>(T: T, R: R, options: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -1,9 +1,9 @@
-import { type TTemplateLiteral, TTemplateLiteralGenerate } from '../template-literal/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TInteger } from '../integer/index.mjs';
-import { type TNumber } from '../number/index.mjs';
-import { type TSchema } from '../schema/index.mjs';
-import { type TUnion } from '../union/index.mjs';
+import { type TTemplateLiteralGenerate, type TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import type { TInteger } from '../integer/index.mjs';
+import type { TNumber } from '../number/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { TUnion } from '../union/index.mjs';
 type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
 type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...TIndexPropertyKeys<L>, ...Acc]> : Acc);
 type TFromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);

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

@@ -2,7 +2,6 @@ import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type.mjs';
 // prettier-ignore
 function FromTemplateLiteral(T) {
@@ -11,10 +10,9 @@ function FromTemplateLiteral(T) {
 }
 // prettier-ignore
 function FromUnion(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? [...IndexPropertyKeys(L), ...FromUnion(R)]
-        : []);
+    return T.reduce((Acc, L) => {
+        return [...Acc, ...IndexPropertyKeys(L)];
+    }, []);
 }
 // prettier-ignore
 function FromLiteral(T) {

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

@@ -16,7 +16,7 @@ import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 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 TFromUnionRest<T extends TSchema[]> = T;
 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);

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

@@ -10,33 +10,20 @@ import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 import { IsArray, IsIntersect, IsObject, IsMappedKey, IsMappedResult, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
-function FromRest(T, K, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, K, [...Acc, FromKey(L, K)])
-        : Acc);
+function FromRest(T, K) {
+    return T.map(L => FromKey(L, K));
 }
 // prettier-ignore
-function FromIntersectRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsNever(L)
-            ? FromIntersectRest(R, [...Acc])
-            : FromIntersectRest(R, [...Acc, L])
-        : Acc);
+function FromIntersectRest(T) {
+    return T.filter(L => !IsNever(L));
 }
 // prettier-ignore
 function FromIntersect(T, K) {
     return (IntersectEvaluated(FromIntersectRest(FromRest(T, K))));
 }
 // prettier-ignore
-function FromUnionRest(T, Acc = T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsNever(L)
-            ? []
-            : FromUnionRest(R, Acc)
-        : Acc);
+function FromUnionRest(T) {
+    return T; // review this
 }
 // prettier-ignore
 function FromUnion(T, K) {
@@ -56,9 +43,7 @@ function FromArray(T, K) {
 }
 // prettier-ignore
 function FromProperty(T, K) {
-    return (K in T
-        ? T[K]
-        : Never());
+    return (K in T ? T[K] : Never());
 }
 // prettier-ignore
 function FromKey(T, K) {
@@ -70,11 +55,8 @@ function FromKey(T, K) {
                         Never());
 }
 // prettier-ignore
-function FromKeys(T, K, Acc = []) {
-    const [L, ...R] = K;
-    return (K.length > 0
-        ? FromKeys(T, R, [...Acc, FromKey(T, L)])
-        : Acc);
+function FromKeys(T, K) {
+    return K.map(L => FromKey(T, L));
 }
 // prettier-ignore
 function FromSchema(T, K) {

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

@@ -11,25 +11,15 @@ import { IntersectCreate } from './intersect-create.mjs';
 import { IsOptional, IsTransform, } from '../guard/type.mjs';
 // prettier-ignore
 function IsIntersectOptional(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? IsOptional(L)
-            ? IsIntersectOptional(R)
-            : false
-        : true);
+    return T.every(L => IsOptional(L));
 }
 // 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);
+function RemoveOptionalFromRest(T) {
+    return T.map(L => IsOptional(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function ResolveIntersect(T, options) {

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

@@ -1,5 +1,5 @@
-import { TSchema, SchemaOptions } from '../schema/index.mjs';
-import { TIntrinsic } from './intrinsic.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TIntrinsic } from './intrinsic.mjs';
 export type TCapitalize<T extends TSchema> = TIntrinsic<T, 'Capitalize'>;
 /** `[Json]` Intrinsic function to Capitalize LiteralString types */
 export declare function Capitalize<T extends TSchema>(T: T, options?: SchemaOptions): TCapitalize<T>;

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

@@ -3,7 +3,7 @@ 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';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 type TMappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode> = {
     [_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>;
 };

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

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