@sinclair/typebox 0.32.24 → 0.32.25

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

@@ -6,12 +6,13 @@ const index_1 = require("../sets/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_1 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromRest(T) {
-    return T.reduce((Acc, L) => {
-        return [...Acc, KeyOfPropertyKeys(L)];
-    }, []);
+    const Acc = [];
+    for (const L of T)
+        Acc.push(KeyOfPropertyKeys(L));
+    return Acc;
 }
 // prettier-ignore
 function FromIntersect(T) {
@@ -54,12 +55,12 @@ function FromPatternProperties(patternProperties) {
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 // prettier-ignore
 function KeyOfPropertyKeys(T) {
-    return ((0, type_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, type_1.IsUnion)(T) ? FromUnion(T.anyOf) :
-            (0, type_1.IsTuple)(T) ? FromTuple(T.items ?? []) :
-                (0, type_1.IsArray)(T) ? FromArray(T.items) :
-                    (0, type_1.IsObject)(T) ? FromProperties(T.properties) :
-                        (0, type_1.IsRecord)(T) ? FromPatternProperties(T.patternProperties) :
+    return ((0, kind_1.IsIntersect)(T) ? FromIntersect(T.allOf) :
+        (0, kind_1.IsUnion)(T) ? FromUnion(T.anyOf) :
+            (0, kind_1.IsTuple)(T) ? FromTuple(T.items ?? []) :
+                (0, kind_1.IsArray)(T) ? FromArray(T.items) :
+                    (0, kind_1.IsObject)(T) ? FromProperties(T.properties) :
+                        (0, kind_1.IsRecord)(T) ? FromPatternProperties(T.patternProperties) :
                             []);
 }
 exports.KeyOfPropertyKeys = KeyOfPropertyKeys;

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

@@ -11,7 +11,7 @@ const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function KeyOfPropertyKeysToRest(T) {
     return T.map(L => L === '[number]' ? (0, index_2.Number)() : (0, index_1.Literal)(L));
@@ -19,7 +19,7 @@ function KeyOfPropertyKeysToRest(T) {
 exports.KeyOfPropertyKeysToRest = KeyOfPropertyKeysToRest;
 /** `[Json]` Creates a KeyOf type */
 function KeyOf(T, options = {}) {
-    if ((0, type_2.IsMappedResult)(T)) {
+    if ((0, kind_1.IsMappedResult)(T)) {
         return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);
     }
     else {

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

@@ -36,7 +36,7 @@ declare function FromSchemaType<K extends PropertyKey, T extends TSchema>(K: K,
 export type TMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema, Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedFunctionReturnType<R, T, Acc & {
     [_ in L]: FromSchemaType<L, T>;
 }> : Acc);
-export declare function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc?: TProperties): TMappedFunctionReturnType<K, T>;
+export declare function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): TMappedFunctionReturnType<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<TMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
 /** `[Json]` Creates a Mapped object type */

package/build/require/type/mapped/mapped.js

@@ -27,8 +27,7 @@ const mapped_result_1 = require("./mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromMappedResult(K, P) {
     return (K in P
@@ -41,9 +40,10 @@ function MappedKeyToKnownMappedResultProperties(K) {
 }
 // prettier-ignore
 function MappedKeyToUnknownMappedResultProperties(P) {
-    return P.reduce((Acc, L) => {
-        return { ...Acc, [L]: (0, index_10.Literal)(L) };
-    }, {});
+    const Acc = {};
+    for (const L of P)
+        Acc[L] = (0, index_10.Literal)(L);
+    return Acc;
 }
 // prettier-ignore
 function MappedKeyToMappedResultProperties(K, P) {
@@ -62,42 +62,44 @@ function FromRest(K, T) {
 }
 // prettier-ignore
 function FromProperties(K, T) {
-    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: FromSchemaType(K, T[K2]) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K2] = FromSchemaType(K, T[K2]);
+    return Acc;
 }
 // prettier-ignore
 function FromSchemaType(K, T) {
     return (
     // unevaluated modifier types
-    (0, type_2.IsOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
-        (0, type_2.IsReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
+    (0, kind_1.IsOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+        (0, kind_1.IsReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
             // unevaluated mapped types
-            (0, type_2.IsMappedResult)(T) ? FromMappedResult(K, T.properties) :
-                (0, type_2.IsMappedKey)(T) ? FromMappedKey(K, T.keys) :
+            (0, kind_1.IsMappedResult)(T) ? FromMappedResult(K, T.properties) :
+                (0, kind_1.IsMappedKey)(T) ? FromMappedKey(K, T.keys) :
                     // unevaluated types
-                    (0, type_2.IsConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-                        (0, type_2.IsFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
-                            (0, type_2.IsAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
-                                (0, type_2.IsIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
-                                    (0, type_2.IsIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
-                                        (0, type_2.IsUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
-                                            (0, type_2.IsTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
-                                                (0, type_2.IsObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties)) :
-                                                    (0, type_2.IsArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
-                                                        (0, type_2.IsPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
+                    (0, kind_1.IsConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        (0, kind_1.IsFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            (0, kind_1.IsAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
+                                (0, kind_1.IsIterator)(T) ? (0, index_9.Iterator)(FromSchemaType(K, T.items)) :
+                                    (0, kind_1.IsIntersect)(T) ? (0, index_8.Intersect)(FromRest(K, T.allOf)) :
+                                        (0, kind_1.IsUnion)(T) ? (0, index_16.Union)(FromRest(K, T.anyOf)) :
+                                            (0, kind_1.IsTuple)(T) ? (0, index_15.Tuple)(FromRest(K, T.items ?? [])) :
+                                                (0, kind_1.IsObject)(T) ? (0, index_11.Object)(FromProperties(K, T.properties)) :
+                                                    (0, kind_1.IsArray)(T) ? (0, index_3.Array)(FromSchemaType(K, T.items)) :
+                                                        (0, kind_1.IsPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
                                                             T);
 }
 // prettier-ignore
-function MappedFunctionReturnType(K, T, Acc = {}) {
-    return K.reduce((Acc, L) => {
-        return { ...Acc, [L]: FromSchemaType(L, T) };
-    }, {});
+function MappedFunctionReturnType(K, T) {
+    const Acc = {};
+    for (const L of K)
+        Acc[L] = FromSchemaType(L, T);
+    return Acc;
 }
 exports.MappedFunctionReturnType = MappedFunctionReturnType;
 /** `[Json]` Creates a Mapped object type */
 function Mapped(key, map, options = {}) {
-    const K = (0, type_2.IsSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
+    const K = (0, kind_1.IsSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
     const RT = map({ [index_1.Kind]: 'MappedKey', keys: K });
     const R = MappedFunctionReturnType(K, RT);
     return (0, type_1.CloneType)((0, index_11.Object)(R), options);

package/build/require/type/object/object.js

@@ -7,14 +7,16 @@ const index_1 = require("../symbols/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 /** `[Json]` Creates an Object type */
 function _Object(properties, options = {}) {
     const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-    const optionalKeys = propertyKeys.filter((key) => (0, type_2.IsOptional)(properties[key]));
+    const optionalKeys = propertyKeys.filter((key) => (0, kind_1.IsOptional)(properties[key]));
     const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-    const clonedAdditionalProperties = (0, type_2.IsSchema)(options.additionalProperties) ? { additionalProperties: (0, type_1.CloneType)(options.additionalProperties) } : {};
-    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: (0, type_1.CloneType)(properties[key]) }), {});
+    const clonedAdditionalProperties = (0, kind_1.IsSchema)(options.additionalProperties) ? { additionalProperties: (0, type_1.CloneType)(options.additionalProperties) } : {};
+    const clonedProperties = {};
+    for (const key of propertyKeys)
+        clonedProperties[key] = (0, type_1.CloneType)(properties[key]);
     return (requiredKeys.length > 0
         ? { ...options, ...clonedAdditionalProperties, [index_1.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
         : { ...options, ...clonedAdditionalProperties, [index_1.Kind]: 'Object', type: 'object', properties: clonedProperties });

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const omit_1 = require("./omit");
 // prettier-ignore
 function FromProperties(P, K, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, omit_1.Omit)(P[K2], K, options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, omit_1.Omit)(P[K2], K, options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, K, options) {

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

@@ -14,7 +14,7 @@ const omit_from_mapped_result_1 = require("./omit-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
@@ -33,28 +33,26 @@ function FromProperty(T, K) {
 }
 // prettier-ignore
 function FromProperties(T, K) {
-    return K.reduce((T, K2) => {
-        return FromProperty(T, K2);
-    }, T);
+    return K.reduce((T, K2) => FromProperty(T, K2), T);
 }
 // ------------------------------------------------------------------
 // OmitResolve
 // ------------------------------------------------------------------
 // prettier-ignore
 function OmitResolve(T, K) {
-    return ((0, type_2.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
-        (0, type_2.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
-            (0, type_2.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
+    return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
+        (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
+            (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
                 (0, index_3.Object)({}));
 }
 function Omit(T, K, options = {}) {
     // mapped
-    if ((0, type_2.IsMappedKey)(K))
+    if ((0, kind_1.IsMappedKey)(K))
         return (0, omit_from_mapped_key_1.OmitFromMappedKey)(T, K, options);
-    if ((0, type_2.IsMappedResult)(T))
+    if ((0, kind_1.IsMappedResult)(T))
         return (0, omit_from_mapped_result_1.OmitFromMappedResult)(T, K, options);
     // non-mapped
-    const I = (0, type_2.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
+    const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
     const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
     const R = (0, type_1.CloneType)(OmitResolve(T, I), options);
     return { ...D, ...R };

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const optional_1 = require("./optional");
 // prettier-ignore
 function FromProperties(P, F) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, optional_1.Optional)(P[K2], F) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, optional_1.Optional)(P[K2], F);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, F) {

package/build/require/type/optional/optional.js

@@ -6,7 +6,7 @@ const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const optional_from_mapped_result_1 = require("./optional-from-mapped-result");
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 function RemoveOptional(schema) {
     return (0, index_2.Discard)((0, type_1.CloneType)(schema), [index_1.OptionalKind]);
 }
@@ -22,6 +22,6 @@ function OptionalWithFlag(schema, F) {
 /** `[Json]` Creates a Optional property */
 function Optional(schema, enable) {
     const F = enable ?? true;
-    return (0, type_2.IsMappedResult)(schema) ? (0, optional_from_mapped_result_1.OptionalFromMappedResult)(schema, F) : OptionalWithFlag(schema, F);
+    return (0, kind_1.IsMappedResult)(schema) ? (0, optional_from_mapped_result_1.OptionalFromMappedResult)(schema, F) : OptionalWithFlag(schema, F);
 }
 exports.Optional = Optional;

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const partial_1 = require("./partial");
 // prettier-ignore
 function FromProperties(K, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, partial_1.Partial)(K[K2], options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = (0, partial_1.Partial)(K[K2], options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, options) {

package/build/require/type/partial/partial.js

@@ -13,30 +13,31 @@ const partial_from_mapped_result_1 = require("./partial-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromRest(T) {
     return T.map(L => PartialResolve(L));
 }
 // prettier-ignore
 function FromProperties(T) {
-    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
-        return { ...Acc, [K]: (0, index_1.Optional)(T[K]) };
-    }, {});
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = (0, index_1.Optional)(T[K]);
+    return Acc;
 }
 // ------------------------------------------------------------------
 // PartialResolve
 // ------------------------------------------------------------------
 // prettier-ignore
 function PartialResolve(T) {
-    return ((0, type_2.IsIntersect)(T) ? (0, index_3.Intersect)(FromRest(T.allOf)) :
-        (0, type_2.IsUnion)(T) ? (0, index_4.Union)(FromRest(T.anyOf)) :
-            (0, type_2.IsObject)(T) ? (0, index_2.Object)(FromProperties(T.properties)) :
+    return ((0, kind_1.IsIntersect)(T) ? (0, index_3.Intersect)(FromRest(T.allOf)) :
+        (0, kind_1.IsUnion)(T) ? (0, index_4.Union)(FromRest(T.anyOf)) :
+            (0, kind_1.IsObject)(T) ? (0, index_2.Object)(FromProperties(T.properties)) :
                 (0, index_2.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
 function Partial(T, options = {}) {
-    if ((0, type_2.IsMappedResult)(T))
+    if ((0, kind_1.IsMappedResult)(T))
         return (0, partial_from_mapped_result_1.PartialFromMappedResult)(T, options);
     const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
     const R = (0, type_1.CloneType)(PartialResolve(T), options);

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const pick_1 = require("./pick");
 // prettier-ignore
 function FromProperties(P, K, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, pick_1.Pick)(P[K2], K, options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, pick_1.Pick)(P[K2], K, options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, K, options) {

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

@@ -13,7 +13,7 @@ declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T:
 type FromUnion<T extends TSchema[], K extends PropertyKey[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? FromUnion<R, K, [...Acc, TPick<L, K>]> : Acc;
 declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K, []>;
 type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
-declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): {};
+declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): never;
 export type TPick<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<TPick<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<{}>;
 /** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TPickFromMappedResult<T, K>;

package/build/require/type/pick/pick.js

@@ -14,7 +14,7 @@ const pick_from_mapped_result_1 = require("./pick-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
@@ -24,28 +24,30 @@ function FromUnion(T, K) {
 }
 // prettier-ignore
 function FromProperties(T, K) {
-    return K.reduce((Acc, K) => {
-        return K in T ? { ...Acc, [K]: T[K] } : Acc;
-    }, {});
+    const Acc = {};
+    for (const K2 of K)
+        if (K2 in T)
+            Acc[K2] = T[K2];
+    return Acc;
 }
 // ------------------------------------------------------------------
 // PickResolve
 // ------------------------------------------------------------------
 // prettier-ignore
 function PickResolve(T, K) {
-    return ((0, type_2.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
-        (0, type_2.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
-            (0, type_2.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
+    return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
+        (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
+            (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
                 (0, index_3.Object)({}));
 }
 function Pick(T, K, options = {}) {
     // mapped
-    if ((0, type_2.IsMappedKey)(K))
+    if ((0, kind_1.IsMappedKey)(K))
         return (0, pick_from_mapped_key_1.PickFromMappedKey)(T, K, options);
-    if ((0, type_2.IsMappedResult)(T))
+    if ((0, kind_1.IsMappedResult)(T))
         return (0, pick_from_mapped_result_1.PickFromMappedResult)(T, K, options);
     // non-mapped
-    const I = (0, type_2.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
+    const I = (0, kind_1.IsSchema)(K) ? (0, index_4.IndexPropertyKeys)(K) : K;
     const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
     const R = (0, type_1.CloneType)(PickResolve(T, I), options);
     return { ...D, ...R };

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const readonly_1 = require("./readonly");
 // prettier-ignore
 function FromProperties(K, F) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, readonly_1.Readonly)(K[K2], F) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = (0, readonly_1.Readonly)(K[K2], F);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, F) {

package/build/require/type/readonly/readonly.js

@@ -6,7 +6,7 @@ const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const readonly_from_mapped_result_1 = require("./readonly-from-mapped-result");
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 function RemoveReadonly(schema) {
     return (0, index_2.Discard)((0, type_1.CloneType)(schema), [index_1.ReadonlyKind]);
 }
@@ -22,6 +22,6 @@ function ReadonlyWithFlag(schema, F) {
 /** `[Json]` Creates a Readonly property */
 function Readonly(schema, enable) {
     const F = enable ?? true;
-    return (0, type_2.IsMappedResult)(schema) ? (0, readonly_from_mapped_result_1.ReadonlyFromMappedResult)(schema, F) : ReadonlyWithFlag(schema, F);
+    return (0, kind_1.IsMappedResult)(schema) ? (0, readonly_from_mapped_result_1.ReadonlyFromMappedResult)(schema, F) : ReadonlyWithFlag(schema, F);
 }
 exports.Readonly = Readonly;

package/build/require/type/record/record.js

@@ -17,7 +17,7 @@ const value_1 = require("../guard/value");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -35,8 +35,10 @@ function RecordCreateFromPattern(pattern, T, options) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromKeys(K, T, options) {
-    const P = K.reduce((Acc, K) => ({ ...Acc, [K]: (0, type_1.CloneType)(T) }), {});
-    return (0, index_1.Object)(P, { ...options, [index_7.Hint]: 'Record' });
+    const Acc = {};
+    for (const K2 of K)
+        Acc[K2] = (0, type_1.CloneType)(T);
+    return (0, index_1.Object)(Acc, { ...options, [index_7.Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {
@@ -75,13 +77,13 @@ function FromNumberKey(_, T, options) {
 /** `[Json]` Creates a Record type */
 function Record(K, T, options = {}) {
     // prettier-ignore
-    return ((0, type_2.IsUnion)(K) ? FromUnionKey(K.anyOf, T, options) :
-        (0, type_2.IsTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T, options) :
-            (0, type_2.IsLiteral)(K) ? FromLiteralKey(K.const, T, options) :
-                (0, type_2.IsInteger)(K) ? FromIntegerKey(K, T, options) :
-                    (0, type_2.IsNumber)(K) ? FromNumberKey(K, T, options) :
-                        (0, type_2.IsRegExp)(K) ? FromRegExpKey(K, T, options) :
-                            (0, type_2.IsString)(K) ? FromStringKey(K, T, options) :
+    return ((0, kind_1.IsUnion)(K) ? FromUnionKey(K.anyOf, T, options) :
+        (0, kind_1.IsTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T, options) :
+            (0, kind_1.IsLiteral)(K) ? FromLiteralKey(K.const, T, options) :
+                (0, kind_1.IsInteger)(K) ? FromIntegerKey(K, T, options) :
+                    (0, kind_1.IsNumber)(K) ? FromNumberKey(K, T, options) :
+                        (0, kind_1.IsRegExp)(K) ? FromRegExpKey(K, T, options) :
+                            (0, kind_1.IsString)(K) ? FromStringKey(K, T, options) :
                                 (0, index_2.Never)(options));
 }
 exports.Record = Record;

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

@@ -6,9 +6,10 @@ const index_1 = require("../mapped/index");
 const required_1 = require("./required");
 // prettier-ignore
 function FromProperties(P, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: (0, required_1.Required)(P[K2], options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, required_1.Required)(P[K2], options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, options) {

package/build/require/type/required/required.js

@@ -12,30 +12,31 @@ const required_from_mapped_result_1 = require("./required-from-mapped-result");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function FromRest(T) {
     return T.map(L => RequiredResolve(L));
 }
 // prettier-ignore
 function FromProperties(T) {
-    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
-        return { ...Acc, [K]: (0, index_5.Discard)(T[K], [index_4.OptionalKind]) };
-    }, {});
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = (0, index_5.Discard)(T[K], [index_4.OptionalKind]);
+    return Acc;
 }
 // ------------------------------------------------------------------
 // RequiredResolve
 // ------------------------------------------------------------------
 // prettier-ignore
 function RequiredResolve(T) {
-    return ((0, type_2.IsIntersect)(T) ? (0, index_1.Intersect)(FromRest(T.allOf)) :
-        (0, type_2.IsUnion)(T) ? (0, index_2.Union)(FromRest(T.anyOf)) :
-            (0, type_2.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
+    return ((0, kind_1.IsIntersect)(T) ? (0, index_1.Intersect)(FromRest(T.allOf)) :
+        (0, kind_1.IsUnion)(T) ? (0, index_2.Union)(FromRest(T.anyOf)) :
+            (0, kind_1.IsObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
                 (0, index_3.Object)({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
 function Required(T, options = {}) {
-    if ((0, type_2.IsMappedResult)(T)) {
+    if ((0, kind_1.IsMappedResult)(T)) {
         return (0, required_from_mapped_result_1.RequiredFromMappedResult)(T, options);
     }
     else {

package/build/require/type/rest/rest.js

@@ -6,12 +6,12 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // prettier-ignore
 function RestResolve(T) {
-    return ((0, type_2.IsIntersect)(T) ? [...T.allOf] :
-        (0, type_2.IsUnion)(T) ? [...T.anyOf] :
-            (0, type_2.IsTuple)(T) ? [...(T.items ?? [])] :
+    return ((0, kind_1.IsIntersect)(T) ? (0, type_1.CloneRest)(T.allOf) :
+        (0, kind_1.IsUnion)(T) ? (0, type_1.CloneRest)(T.anyOf) :
+            (0, kind_1.IsTuple)(T) ? (0, type_1.CloneRest)(T.items ?? []) :
                 []);
 }
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */

package/build/require/type/sets/set.js

@@ -52,6 +52,9 @@ function SetIntersectMany(T) {
 exports.SetIntersectMany = SetIntersectMany;
 /** Returns the Union of multiple sets */
 function SetUnionMany(T) {
-    return T.reduce((Acc, L) => [...Acc, ...L], []);
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...L);
+    return Acc;
 }
 exports.SetUnionMany = SetUnionMany;

package/build/require/type/template-literal/pattern.js

@@ -8,8 +8,7 @@ const index_3 = require("../error/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-const type_1 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
 // ------------------------------------------------------------------
@@ -24,14 +23,14 @@ function Escape(value) {
 }
 // prettier-ignore
 function Visit(schema, acc) {
-    return ((0, type_1.IsTemplateLiteral)(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
-        (0, type_1.IsUnion)(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
-            (0, type_1.IsNumber)(schema) ? `${acc}${index_1.PatternNumber}` :
-                (0, type_1.IsInteger)(schema) ? `${acc}${index_1.PatternNumber}` :
-                    (0, type_1.IsBigInt)(schema) ? `${acc}${index_1.PatternNumber}` :
-                        (0, type_1.IsString)(schema) ? `${acc}${index_1.PatternString}` :
-                            (0, type_1.IsLiteral)(schema) ? `${acc}${Escape(schema.const.toString())}` :
-                                (0, type_1.IsBoolean)(schema) ? `${acc}${index_1.PatternBoolean}` :
+    return ((0, kind_1.IsTemplateLiteral)(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+        (0, kind_1.IsUnion)(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
+            (0, kind_1.IsNumber)(schema) ? `${acc}${index_1.PatternNumber}` :
+                (0, kind_1.IsInteger)(schema) ? `${acc}${index_1.PatternNumber}` :
+                    (0, kind_1.IsBigInt)(schema) ? `${acc}${index_1.PatternNumber}` :
+                        (0, kind_1.IsString)(schema) ? `${acc}${index_1.PatternString}` :
+                            (0, kind_1.IsLiteral)(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                (0, kind_1.IsBoolean)(schema) ? `${acc}${index_1.PatternBoolean}` :
                                     (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[index_2.Kind]}'`); })());
 }
 function TemplateLiteralPattern(kinds) {

package/build/require/type/transform/transform.js

@@ -7,7 +7,7 @@ const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_2 = require("../guard/type");
+const kind_1 = require("../guard/kind");
 // ------------------------------------------------------------------
 // TransformBuilders
 // ------------------------------------------------------------------
@@ -38,7 +38,7 @@ class TransformEncodeBuilder {
     }
     Encode(encode) {
         const schema = (0, type_1.CloneType)(this.schema);
-        return ((0, type_2.IsTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+        return ((0, kind_1.IsTransform)(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
     }
 }
 exports.TransformEncodeBuilder = TransformEncodeBuilder;