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

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

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExtract } from './extract';
-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/require/type/extract/extract-from-mapped-result.js

@@ -5,18 +5,18 @@ exports.ExtractFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const extract_1 = require("./extract");
 // prettier-ignore
-function FromProperties(K, U, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, extract_1.Extract)(K[K2], U, options) };
+function FromProperties(P, T, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, extract_1.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
-function ExtractFromMappedResult(T, U, options) {
-    const P = FromMappedResult(T, U, options);
+function ExtractFromMappedResult(R, T, options) {
+    const P = FromMappedResult(R, T, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.ExtractFromMappedResult = ExtractFromMappedResult;

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

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

@@ -1,14 +1,16 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Extract = exports.ExtractResolve = void 0;
+exports.Extract = void 0;
 const index_1 = require("../template-literal/index");
 const index_2 = require("../union/index");
 const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
 const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
-// prettier-ignore
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
 const type_2 = require("../guard/type");
 // prettier-ignore
 function ExtractResolve(L, R) {
@@ -21,7 +23,6 @@ function ExtractResolve(L, R) {
                 (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? L :
                     (0, index_3.Never)());
 }
-exports.ExtractResolve = ExtractResolve;
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
 function Extract(type, union, options = {}) {
     if ((0, type_2.IsMappedResult)(type)) {

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

@@ -26,6 +26,7 @@ import type { TOptional } from '../optional/index';
 import type { TPromise } from '../promise/index';
 import type { TReadonly } from '../readonly/index';
 import type { TRef } from '../ref/index';
+import type { TRegExp } from '../regexp/index';
 import type { TSchema } from '../schema/index';
 import type { TSymbol } from '../symbol/index';
 import type { TTuple } from '../tuple/index';
@@ -104,6 +105,8 @@ export declare function IsRecursive(value: unknown): value is {
 };
 /** Returns true if the given value is TRef */
 export declare function IsRef(value: unknown): value is TRef;
+/** Returns true if the given value is TRegExp */
+export declare function IsRegExp(value: unknown): value is TRegExp;
 /** Returns true if the given value is TString */
 export declare function IsString(value: unknown): value is TString;
 /** Returns true if the given value is TSymbol */

package/build/require/type/guard/type.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsSchema = exports.IsKind = exports.IsVoid = exports.IsUnsafe = exports.IsUnknown = exports.IsUint8Array = exports.IsUnion = exports.IsUnionLiteral = exports.IsUndefined = exports.IsTuple = exports.IsTransform = exports.IsThis = exports.IsTemplateLiteral = exports.IsSymbol = exports.IsString = exports.IsRef = exports.IsRecursive = exports.IsRecord = exports.IsPromise = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsNot = exports.IsNever = exports.IsMappedResult = exports.IsMappedKey = exports.IsLiteralValue = exports.IsLiteral = exports.IsLiteralBoolean = exports.IsLiteralNumber = exports.IsLiteralString = exports.IsKindOf = exports.IsIterator = exports.IsIntersect = exports.IsProperties = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsConstructor = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.IsAny = exports.IsOptional = exports.IsReadonly = exports.TypeGuardUnknownTypeError = void 0;
+exports.IsSchema = exports.IsKind = exports.IsVoid = exports.IsUnsafe = exports.IsUnknown = exports.IsUint8Array = exports.IsUnion = exports.IsUnionLiteral = exports.IsUndefined = exports.IsTuple = exports.IsTransform = exports.IsThis = exports.IsTemplateLiteral = exports.IsSymbol = exports.IsString = exports.IsRegExp = exports.IsRef = exports.IsRecursive = exports.IsRecord = exports.IsPromise = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsNot = exports.IsNever = exports.IsMappedResult = exports.IsMappedKey = exports.IsLiteralValue = exports.IsLiteral = exports.IsLiteralBoolean = exports.IsLiteralNumber = exports.IsLiteralString = exports.IsKindOf = exports.IsIterator = exports.IsIntersect = exports.IsProperties = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsConstructor = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.IsAny = exports.IsOptional = exports.IsReadonly = exports.TypeGuardUnknownTypeError = void 0;
 const ValueGuard = require("./value");
 const index_1 = require("../symbols/index");
 const index_2 = require("../error/index");
@@ -31,6 +31,7 @@ const KnownTypes = [
     'Promise',
     'Record',
     'Ref',
+    'RegExp',
     'String',
     'Symbol',
     'TemplateLiteral',
@@ -360,6 +361,15 @@ function IsRef(value) {
         ValueGuard.IsString(value.$ref));
 }
 exports.IsRef = IsRef;
+/** Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'RegExp') &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsString(value.source) &&
+        ValueGuard.IsString(value.flags));
+}
+exports.IsRegExp = IsRegExp;
 /** Returns true if the given value is TString */
 function IsString(value) {
     // prettier-ignore
@@ -502,6 +512,7 @@ function IsSchema(value) {
         IsPromise(value) ||
         IsRecord(value) ||
         IsRef(value) ||
+        IsRegExp(value) ||
         IsString(value) ||
         IsSymbol(value) ||
         IsTemplateLiteral(value) ||

package/build/require/type/guard/value.d.ts

@@ -18,6 +18,8 @@ export declare function IsNull(value: unknown): value is null;
 export declare function IsNumber(value: unknown): value is number;
 /** Returns true if this value is an object */
 export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is RegExp */
+export declare function IsRegExp(value: unknown): value is RegExp;
 /** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
 /** Returns true if this value is symbol */

package/build/require/type/guard/value.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUndefined = exports.IsUint8Array = exports.IsSymbol = exports.IsString = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsArray = exports.IsAsyncIterator = void 0;
+exports.IsUndefined = exports.IsUint8Array = exports.IsSymbol = exports.IsString = exports.IsRegExp = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsArray = exports.IsAsyncIterator = void 0;
 /** Returns true if this value is an async iterator */
 function IsAsyncIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
@@ -52,6 +52,11 @@ function IsObject(value) {
     return typeof value === 'object' && value !== null;
 }
 exports.IsObject = IsObject;
+/** Returns true if this value is RegExp */
+function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+exports.IsRegExp = IsRegExp;
 /** Returns true if this value is string */
 function IsString(value) {
     return typeof value === 'string';

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

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

package/build/require/type/index.js

@@ -52,7 +52,6 @@ __exportStar(require("./null/index"), exports);
 __exportStar(require("./number/index"), exports);
 __exportStar(require("./object/index"), exports);
 __exportStar(require("./omit/index"), exports);
-__exportStar(require("./operators/index"), exports);
 __exportStar(require("./optional/index"), exports);
 __exportStar(require("./parameters/index"), exports);
 __exportStar(require("./partial/index"), exports);
@@ -70,6 +69,7 @@ __exportStar(require("./required/index"), exports);
 __exportStar(require("./rest/index"), exports);
 __exportStar(require("./return-type/index"), exports);
 __exportStar(require("./schema/index"), exports);
+__exportStar(require("./sets/index"), exports);
 __exportStar(require("./static/index"), exports);
 __exportStar(require("./strict/index"), exports);
 __exportStar(require("./string/index"), exports);

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

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

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

@@ -9,11 +9,10 @@ function MappedIndexPropertyKey(T, K, options) {
     return { [K]: (0, indexed_1.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/require/type/indexed/indexed-from-mapped-result.d.ts

@@ -6,7 +6,7 @@ import { type TIndex } from './index';
 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/require/type/indexed/indexed-property-keys.d.ts

@@ -1,9 +1,9 @@
-import { type TTemplateLiteral, TTemplateLiteralGenerate } from '../template-literal/index';
-import { type TLiteral, type TLiteralValue } from '../literal/index';
-import { type TInteger } from '../integer/index';
-import { type TNumber } from '../number/index';
-import { type TSchema } from '../schema/index';
-import { type TUnion } from '../union/index';
+import { type TTemplateLiteralGenerate, type TTemplateLiteral } from '../template-literal/index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
+import type { TInteger } from '../integer/index';
+import type { TNumber } from '../number/index';
+import type { TSchema } from '../schema/index';
+import type { TUnion } from '../union/index';
 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/require/type/indexed/indexed-property-keys.js

@@ -6,7 +6,6 @@ const index_1 = require("../template-literal/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_1 = require("../guard/type");
 // prettier-ignore
 function FromTemplateLiteral(T) {
@@ -15,10 +14,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/require/type/indexed/indexed.d.ts

@@ -16,7 +16,7 @@ import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
 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/require/type/indexed/indexed.js

@@ -14,33 +14,20 @@ const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
 // ------------------------------------------------------------------
 const type_2 = require("../guard/type");
 // 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
-        ? (0, type_2.IsNever)(L)
-            ? FromIntersectRest(R, [...Acc])
-            : FromIntersectRest(R, [...Acc, L])
-        : Acc);
+function FromIntersectRest(T) {
+    return T.filter(L => !(0, type_2.IsNever)(L));
 }
 // prettier-ignore
 function FromIntersect(T, K) {
     return ((0, index_2.IntersectEvaluated)(FromIntersectRest(FromRest(T, K))));
 }
 // prettier-ignore
-function FromUnionRest(T, Acc = T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsNever)(L)
-            ? []
-            : FromUnionRest(R, Acc)
-        : Acc);
+function FromUnionRest(T) {
+    return T; // review this
 }
 // prettier-ignore
 function FromUnion(T, K) {
@@ -60,9 +47,7 @@ function FromArray(T, K) {
 }
 // prettier-ignore
 function FromProperty(T, K) {
-    return (K in T
-        ? T[K]
-        : (0, index_1.Never)());
+    return (K in T ? T[K] : (0, index_1.Never)());
 }
 // prettier-ignore
 function FromKey(T, K) {
@@ -74,11 +59,8 @@ function FromKey(T, K) {
                         (0, index_1.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/require/type/intersect/intersect-evaluated.js

@@ -15,25 +15,15 @@ const intersect_create_1 = require("./intersect-create");
 const type_2 = require("../guard/type");
 // prettier-ignore
 function IsIntersectOptional(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsOptional)(L)
-            ? IsIntersectOptional(R)
-            : false
-        : true);
+    return T.every(L => (0, type_2.IsOptional)(L));
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {
     return ((0, index_2.Discard)(T, [index_1.OptionalKind]));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsOptional)(L)
-            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
-            : RemoveOptionalFromRest(R, [...Acc, L])
-        : Acc);
+function RemoveOptionalFromRest(T) {
+    return T.map(L => (0, type_2.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function ResolveIntersect(T, options) {

package/build/require/type/intrinsic/capitalize.d.ts

@@ -1,5 +1,5 @@
-import { TSchema, SchemaOptions } from '../schema/index';
-import { TIntrinsic } from './intrinsic';
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TIntrinsic } from './intrinsic';
 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/require/type/intrinsic/intrinsic-from-mapped-key.d.ts

@@ -3,7 +3,7 @@ import type { TProperties } from '../object/index';
 import { Assert } from '../helpers/index';
 import { type TMappedResult, type TMappedKey } from '../mapped/index';
 import { type TIntrinsic, type IntrinsicMode } from './intrinsic';
-import { TLiteral, TLiteralValue } from '../literal/index';
+import { type TLiteral, type TLiteralValue } from '../literal/index';
 type TMappedIntrinsicPropertyKey<K extends PropertyKey, M extends IntrinsicMode> = {
     [_ in K]: TIntrinsic<TLiteral<Assert<K, TLiteralValue>>, M>;
 };

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

@@ -12,11 +12,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) {

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

@@ -7,9 +7,8 @@ import { type TMappedKey } from '../mapped/index';
 export type IntrinsicMode = 'Uppercase' | 'Lowercase' | 'Capitalize' | 'Uncapitalize';
 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;
+type TFromRest<T extends TSchema[], M extends IntrinsicMode, Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, M, [...Acc, TIntrinsic<L, M>]> : Acc;
+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<TFromRest<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/require/type/intrinsic/intrinsic.js

@@ -49,11 +49,8 @@ function FromLiteralValue(value, mode) {
                     value) : value.toString());
 }
 // prettier-ignore
-function FromRest(T, M, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, M, [...Acc, Intrinsic(L, M)])
-        : Acc);
+function FromRest(T, M) {
+    return T.map(L => Intrinsic(L, M));
 }
 /** Applies an intrinsic string manipulation to the given type. */
 function Intrinsic(schema, mode, options = {}) {

package/build/require/type/intrinsic/lowercase.d.ts

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

package/build/require/type/intrinsic/uncapitalize.d.ts

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

package/build/require/type/intrinsic/uppercase.d.ts

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

package/build/require/type/iterator/iterator.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Iterator = void 0;
-const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates an Iterator type */
 function Iterator(items, options = {}) {
     return {

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

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

package/build/require/type/keyof/keyof-from-mapped-result.js

@@ -11,12 +11,12 @@ function FromProperties(K, options) {
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, options) {
-    return FromProperties(K.properties, options);
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
 }
 // prettier-ignore
-function KeyOfFromMappedResult(T, options) {
-    const P = FromMappedResult(T, options);
+function KeyOfFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
     return (0, index_1.MappedResult)(P);
 }
 exports.KeyOfFromMappedResult = KeyOfFromMappedResult;

package/build/require/type/keyof/keyof-property-keys.d.ts

@@ -6,11 +6,11 @@ import type { TUnion } from '../union/index';
 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';
+import { type TSetUnionMany, type TSetIntersectMany } from '../sets/index';
 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;
+type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<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;
+type FromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
 declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
 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> = ([

package/build/require/type/keyof/keyof-property-keys.js

@@ -2,38 +2,32 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyOfPattern = exports.KeyOfPropertyKeys = void 0;
-const index_1 = require("../helpers/index");
-const index_2 = require("../operators/index");
+const index_1 = require("../sets/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_1 = require("../guard/type");
 // prettier-ignore
-function FromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? FromRest(R, [...Acc, KeyOfPropertyKeys(L)])
-        : Acc);
+function FromRest(T) {
+    return T.reduce((Acc, L) => {
+        return [...Acc, KeyOfPropertyKeys(L)];
+    }, []);
 }
 // prettier-ignore
 function FromIntersect(T) {
     const C = FromRest(T);
-    const R = (0, index_2.OperatorUnionMany)(C);
+    const R = (0, index_1.SetUnionMany)(C);
     return R;
 }
 // prettier-ignore
 function FromUnion(T) {
     const C = FromRest(T);
-    const R = (0, index_2.OperatorIntersectMany)(C);
+    const R = (0, index_1.SetIntersectMany)(C);
     return R;
 }
 // prettier-ignore
-function FromTuple(T, I = '0', Acc = []) {
-    const [_, ...R] = T;
-    return (T.length > 0
-        ? FromTuple(R, (0, index_1.Increment)(I), [...Acc, I])
-        : Acc);
+function FromTuple(T) {
+    return T.map((_, I) => I.toString());
 }
 // prettier-ignore
 function FromArray(_) {

package/build/require/type/keyof/keyof.js

@@ -11,16 +11,10 @@ const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromPropertyKeys(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? L === '[number]'
-            ? FromPropertyKeys(R, [...Acc, (0, index_2.Number)()])
-            : FromPropertyKeys(R, [...Acc, (0, index_1.Literal)(L)])
-        : Acc);
+function FromPropertyKeys(T) {
+    return T.map(L => L === '[number]' ? (0, index_2.Number)() : (0, index_1.Literal)(L));
 }
 /** `[Json]` Creates a KeyOf type */
 function KeyOf(T, options = {}) {