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

package/build/require/type/intrinsic/intrinsic.js

@@ -9,7 +9,6 @@ const index_3 = require("../union/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_1 = require("../guard/type");
 // ------------------------------------------------------------------
 // Apply
@@ -32,10 +31,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 = (0, index_1.TemplateLiteralParseExact)(schema.pattern);
-    const finite = (0, index_1.IsTemplateLiteralFinite)(expression);
+    const finite = (0, index_1.IsTemplateLiteralExpressionFinite)(expression);
     if (!finite)
         return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
-    const strings = [...(0, index_1.TemplateLiteralGenerate)(expression)];
+    const strings = [...(0, index_1.TemplateLiteralExpressionGenerate)(expression)];
     const literals = strings.map((value) => (0, index_2.Literal)(value));
     const mapped = FromRest(literals, mode);
     const union = (0, index_3.Union)(mapped);
@@ -49,9 +48,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. */
 function Intrinsic(schema, mode, options = {}) {

package/build/require/type/keyof/keyof-from-mapped-result.d.ts

@@ -2,12 +2,10 @@ import type { SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TKeyOf } from './keyof';
-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/require/type/keyof/keyof-property-keys.d.ts

@@ -7,24 +7,20 @@ import type { TTuple } from '../tuple/index';
 import type { TArray } from '../array/index';
 import type { TObject, TProperties } from '../object/index';
 import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index';
-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/require/type/keyof/keyof-property-keys.js

@@ -10,27 +10,30 @@ const index_2 = require("../operators/index");
 // prettier-ignore
 const type_1 = require("../guard/type");
 // 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 (0, index_2.OperatorUnionMany)(C);
+function FromIntersect(T) {
+    const C = FromRest(T);
+    const R = (0, index_2.OperatorUnionMany)(C);
+    return R;
 }
 // prettier-ignore
 function FromUnion(T) {
     const C = FromRest(T);
-    return (0, index_2.OperatorIntersectMany)(C);
+    const R = (0, index_2.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, (0, index_1.Increment)(I))]
-        : []);
+        ? FromTuple(R, (0, index_1.Increment)(I), [...Acc, I])
+        : Acc);
 }
 // prettier-ignore
 function FromArray(_) {

package/build/require/type/keyof/keyof.d.ts

@@ -1,15 +1,14 @@
 import type { TSchema } from '../schema/index';
-import type { Ensure } from '../helpers/index';
+import type { Assert, Ensure } from '../helpers/index';
 import type { TMappedResult } from '../mapped/index';
-import { type TLiteral, TLiteralValue } from '../literal/index';
+import type { SchemaOptions } from '../schema/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
 import { type TNumber } from '../number/index';
-import { type SchemaOptions } from '../schema/index';
-import { KeyOfPropertyKeys } from './keyof-property-keys';
-import { UnionEvaluated } from '../union/index';
+import { type TKeyOfPropertyKeys } from './keyof-property-keys';
+import { type TUnionEvaluated } from '../union/index';
 import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
-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/require/type/keyof/keyof.js

@@ -14,13 +14,13 @@ const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
 // prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromLiterals(T) {
+function FromPropertyKeys(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
         ? L === '[number]'
-            ? [(0, index_2.Number)(), ...FromLiterals(R)]
-            : [(0, index_1.Literal)(L), ...FromLiterals(R)]
-        : []);
+            ? FromPropertyKeys(R, [...Acc, (0, index_2.Number)()])
+            : FromPropertyKeys(R, [...Acc, (0, index_1.Literal)(L)])
+        : Acc);
 }
 /** `[Json]` Creates a KeyOf type */
 function KeyOf(T, options = {}) {
@@ -28,8 +28,10 @@ function KeyOf(T, options = {}) {
         return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
     }
     else {
-        const K = (0, index_3.UnionEvaluated)(FromLiterals((0, keyof_property_keys_1.KeyOfPropertyKeys)(T)));
-        return (0, type_1.CloneType)(K, options);
+        const K = (0, keyof_property_keys_1.KeyOfPropertyKeys)(T);
+        const S = FromPropertyKeys(K);
+        const U = (0, index_3.UnionEvaluated)(S);
+        return (0, type_1.CloneType)(U, options);
     }
 }
 exports.KeyOf = KeyOf;

package/build/require/type/mapped/mapped.d.ts

@@ -16,26 +16,22 @@ import { type TTuple } from '../tuple/index';
 import { type TUnion } from '../union/index';
 import { type TMappedResult } from './mapped-result';
 import type { TMappedKey } from './mapped-key';
-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/require/type/mapped/mapped.js

@@ -34,11 +34,11 @@ function FromMappedResult(K, P) {
         : (0, mapped_result_1.MappedResult)(P));
 }
 // prettier-ignore
-function MappedKeyToMappedResultProperties(K, P) {
+function MappedKeyToMappedResultProperties(K, P, Acc = {}) {
     const [L, ...R] = P;
     return (P.length > 0
-        ? { [L]: (0, index_10.Literal)(L), ...MappedKeyToMappedResultProperties(K, R) }
-        : {});
+        ? MappedKeyToMappedResultProperties(K, R, { ...Acc, [L]: (0, index_10.Literal)(L) })
+        : Acc);
 }
 // prettier-ignore
 function FromMappedKey(K, P) {
@@ -46,11 +46,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) {
@@ -81,11 +81,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 */
 function Mapped(key, map, options = {}) {

package/build/require/type/omit/omit-from-mapped-key.d.ts

@@ -2,14 +2,11 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TOmit } from './omit';
-type FromPropertyKey<T extends TSchema, K extends PropertyKey> = {
+type TFromPropertyKey<T extends TSchema, K extends PropertyKey> = {
     [_ in K]: TOmit<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 TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = FromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function OmitFromMappedKey<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 TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
+export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/require/type/omit/omit-from-mapped-key.js

@@ -11,11 +11,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/require/type/omit/omit.d.ts

@@ -7,15 +7,12 @@ import { type TObject, type TProperties } from '../object/index';
 import { type TIndexPropertyKeys } from '../indexed/index';
 import { TMappedKey } from '../mapped/index';
 import { type TOmitFromMappedKey } from './omit-from-mapped-key';
-type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<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[]] ? [OmitResolve<L, K>, ...FromUnion<R, K>] : [];
-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<Omit<T, I>>;
-declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): TProperties;
-export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<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<{}>;
-export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
-export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
+type TFromIntersect<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, K, [...Acc, TOmitResolve<L, K>]> : Acc);
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Acc, TOmitResolve<L, K>]> : Acc);
+type TFromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
+export type TOmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TOmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<TFromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<TFromUnion<S, K>> : T extends TObject<infer S> ? TObject<TFromProperties<S, K>> : TObject<{}>;
+export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): TOmitResolve<T, K>;
+export type TOmit<T extends TSchema, K extends PropertyKey[]> = TOmitResolve<T, K>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
 /** `[Json]` Constructs a type whose keys are omitted from the given type */

package/build/require/type/omit/omit.js

@@ -13,7 +13,6 @@ const omit_from_mapped_key_1 = require("./omit-from-mapped-key");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function FromIntersect(T, K) {

package/build/require/type/operators/operators.d.ts

@@ -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/require/type/operators/operators.js

@@ -14,9 +14,9 @@ function OperatorIncludes(T, S) {
 }
 exports.OperatorIncludes = OperatorIncludes;
 /** Returns true if T is a subset of S */
-// prettier-ignore
 function OperatorSubset(T, S) {
     const [L, ...R] = T;
+    // prettier-ignore
     return (T.length > 0
         ? OperatorIncludes(S, L) === true
             ? OperatorSubset(R, S)
@@ -25,20 +25,19 @@ function OperatorSubset(T, S) {
 }
 exports.OperatorSubset = OperatorSubset;
 /** Returns a distinct set of elements */
-// prettier-ignore
 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);
 }
 exports.OperatorDistinct = OperatorDistinct;
 /** Returns the Intersect of the given sets */
-// prettier-ignore
 function OperatorIntersect(T, S) {
     const [L, ...R] = T;
+    // prettier-ignore
     return (T.length > 0
         ? OperatorIncludes(S, L) === true
             ? [L, ...OperatorIntersect(R, S)]
@@ -47,30 +46,28 @@ function OperatorIntersect(T, S) {
 }
 exports.OperatorIntersect = OperatorIntersect;
 /** Returns the Union of the given sets */
-// prettier-ignore
-function OperatorUnion(T, S) {
+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);
 }
 exports.OperatorUnion = OperatorUnion;
 /** Returns the Complement by omitting elements in T that are in S */
 // prettier-ignore
-function OperatorComplement(T, S) {
+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);
 }
 exports.OperatorComplement = OperatorComplement;
 /** Returns the Intersect of multiple sets */
 // prettier-ignore
-function OperatorIntersectMany(T) {
+function OperatorIntersectMany(T, Acc = []) {
     return (T.length === 1
         ? T[0]
         : (() => {
@@ -82,12 +79,11 @@ function OperatorIntersectMany(T) {
 }
 exports.OperatorIntersectMany = OperatorIntersectMany;
 /** Returns the Union of multiple sets */
-function OperatorUnionMany(T) {
-    return (T.length === 1
-        ? T[0]
-        : (() => {
-            const [L, ...R] = T;
-            return T.length > 0 ? OperatorUnion(L, OperatorUnionMany(R)) : [];
-        })());
+function OperatorUnionMany(T, Acc = []) {
+    const [L, ...R] = T;
+    // prettier-ignore
+    return (T.length > 0
+        ? OperatorUnionMany(R, OperatorUnion(Acc, L))
+        : Acc);
 }
 exports.OperatorUnionMany = OperatorUnionMany;

package/build/require/type/optional/optional-from-mapped-result.d.ts

@@ -1,12 +1,10 @@
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TOptionalWithFlag } from './optional';
-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/require/type/optional/optional.d.ts

@@ -3,13 +3,9 @@ import type { Ensure } from '../helpers/index';
 import { OptionalKind } from '../symbols/index';
 import type { TMappedResult } from '../mapped/index';
 import { type TOptionalFromMappedResult } from './optional-from-mapped-result';
-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/require/type/partial/partial-from-mapped-result.d.ts

@@ -2,12 +2,10 @@ import type { SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TPartial } from './partial';
-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/require/type/partial/partial.d.ts

@@ -9,15 +9,12 @@ import { type TObject, type TProperties } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPartialFromMappedResult } from './partial-from-mapped-result';
-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 */