@sinclair/typebox 0.32.24 → 0.32.25

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

@@ -7,8 +7,7 @@ import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsOptional, IsTransform, } from '../guard/type.mjs';
+import { IsOptional, IsTransform } from '../guard/kind.mjs';
 // prettier-ignore
 function IsIntersectOptional(T) {
     return T.every(L => IsOptional(L));

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

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

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

@@ -5,7 +5,7 @@ import { Union } from '../union/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/type.mjs';
+import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // Apply
 // ------------------------------------------------------------------

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { KeyOf } from './keyof.mjs';
 // prettier-ignore
 function FromProperties(K, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: KeyOf(K[K2], options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = KeyOf(K[K2], options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, options) {

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

@@ -2,12 +2,13 @@ import { SetUnionMany, SetIntersectMany } from '../sets/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/type.mjs';
+import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from '../guard/kind.mjs';
 // 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) {

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

@@ -7,7 +7,7 @@ import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult } from '../guard/type.mjs';
+import { IsMappedResult } from '../guard/kind.mjs';
 // prettier-ignore
 export function KeyOfPropertyKeysToRest(T) {
     return T.map(L => L === '[number]' ? Number() : Literal(L));

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

@@ -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/import/type/mapped/mapped.mjs

@@ -23,8 +23,7 @@ import { MappedResult } from './mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsArray, IsAsyncIterator, IsConstructor, IsFunction, IsIntersect, IsIterator, IsReadonly, IsMappedResult, IsMappedKey, IsObject, IsOptional, IsPromise, IsSchema, IsTuple, IsUnion, } from '../guard/type.mjs';
+import { IsArray, IsAsyncIterator, IsConstructor, IsFunction, IsIntersect, IsIterator, IsReadonly, IsMappedResult, IsMappedKey, IsObject, IsOptional, IsPromise, IsSchema, IsTuple, IsUnion } from '../guard/kind.mjs';
 // prettier-ignore
 function FromMappedResult(K, P) {
     return (K in P
@@ -37,9 +36,10 @@ function MappedKeyToKnownMappedResultProperties(K) {
 }
 // prettier-ignore
 function MappedKeyToUnknownMappedResultProperties(P) {
-    return P.reduce((Acc, L) => {
-        return { ...Acc, [L]: Literal(L) };
-    }, {});
+    const Acc = {};
+    for (const L of P)
+        Acc[L] = Literal(L);
+    return Acc;
 }
 // prettier-ignore
 function MappedKeyToMappedResultProperties(K, P) {
@@ -58,9 +58,10 @@ 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) {
@@ -85,10 +86,11 @@ function FromSchemaType(K, T) {
                                                             T);
 }
 // prettier-ignore
-export function MappedFunctionReturnType(K, T, Acc = {}) {
-    return K.reduce((Acc, L) => {
-        return { ...Acc, [L]: FromSchemaType(L, T) };
-    }, {});
+export function MappedFunctionReturnType(K, T) {
+    const Acc = {};
+    for (const L of K)
+        Acc[L] = FromSchemaType(L, T);
+    return Acc;
 }
 /** `[Json]` Creates a Mapped object type */
 export function Mapped(key, map, options = {}) {

package/build/import/type/object/object.mjs

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

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Omit } from './omit.mjs';
 // prettier-ignore
 function FromProperties(P, K, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Omit(P[K2], K, options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Omit(P[K2], K, options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, K, options) {

package/build/import/type/omit/omit.mjs

@@ -10,7 +10,7 @@ import { OmitFromMappedResult } from './omit-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/type.mjs';
+import { IsMappedKey, IsIntersect, IsUnion, IsObject, IsSchema, IsMappedResult } from '../guard/kind.mjs';
 // prettier-ignore
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
@@ -29,9 +29,7 @@ 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

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Optional } from './optional.mjs';
 // prettier-ignore
 function FromProperties(P, F) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Optional(P[K2], F) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Optional(P[K2], F);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, F) {

package/build/import/type/optional/optional.mjs

@@ -2,7 +2,7 @@ import { OptionalKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { OptionalFromMappedResult } from './optional-from-mapped-result.mjs';
-import { IsMappedResult } from '../guard/type.mjs';
+import { IsMappedResult } from '../guard/kind.mjs';
 function RemoveOptional(schema) {
     return Discard(CloneType(schema), [OptionalKind]);
 }

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Partial } from './partial.mjs';
 // prettier-ignore
 function FromProperties(K, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Partial(K[K2], options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Partial(K[K2], options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, options) {

package/build/import/type/partial/partial.mjs

@@ -9,16 +9,17 @@ import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind.mjs';
 // 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]: Optional(T[K]) };
-    }, {});
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = Optional(T[K]);
+    return Acc;
 }
 // ------------------------------------------------------------------
 // PartialResolve

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
 // prettier-ignore
 function FromProperties(P, K, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Pick(P[K2], K, options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Pick(P[K2], K, options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, K, options) {

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

@@ -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/import/type/pick/pick.mjs

@@ -10,7 +10,7 @@ import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/type.mjs';
+import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema } from '../guard/kind.mjs';
 function FromIntersect(T, K) {
     return T.map((T) => PickResolve(T, K));
 }
@@ -20,9 +20,11 @@ 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

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Readonly } from './readonly.mjs';
 // prettier-ignore
 function FromProperties(K, F) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Readonly(K[K2], F) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Readonly(K[K2], F);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, F) {

package/build/import/type/readonly/readonly.mjs

@@ -2,7 +2,7 @@ import { ReadonlyKind } from '../symbols/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { ReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
-import { IsMappedResult } from '../guard/type.mjs';
+import { IsMappedResult } from '../guard/kind.mjs';
 function RemoveReadonly(schema) {
     return Discard(CloneType(schema), [ReadonlyKind]);
 }

package/build/import/type/record/record.mjs

@@ -13,7 +13,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
+import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
@@ -31,8 +31,10 @@ function RecordCreateFromPattern(pattern, T, options) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromKeys(K, T, options) {
-    const P = K.reduce((Acc, K) => ({ ...Acc, [K]: CloneType(T) }), {});
-    return Object(P, { ...options, [Hint]: 'Record' });
+    const Acc = {};
+    for (const K2 of K)
+        Acc[K2] = CloneType(T);
+    return Object(Acc, { ...options, [Hint]: 'Record' });
 }
 // prettier-ignore
 function FromTemplateLiteralKey(K, T, options) {

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

@@ -2,9 +2,10 @@ import { MappedResult } from '../mapped/index.mjs';
 import { Required } from './required.mjs';
 // prettier-ignore
 function FromProperties(P, options) {
-    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Required(P[K2], options) };
-    }, {});
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Required(P[K2], options);
+    return Acc;
 }
 // prettier-ignore
 function FromMappedResult(R, options) {

package/build/import/type/required/required.mjs

@@ -8,16 +8,17 @@ import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/type.mjs';
+import { IsMappedResult, IsIntersect, IsUnion, IsObject } from '../guard/kind.mjs';
 // 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]: Discard(T[K], [OptionalKind]) };
-    }, {});
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = Discard(T[K], [OptionalKind]);
+    return Acc;
 }
 // ------------------------------------------------------------------
 // RequiredResolve

package/build/import/type/rest/rest.mjs

@@ -2,12 +2,12 @@ import { CloneRest } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsTuple } from '../guard/type.mjs';
+import { IsIntersect, IsUnion, IsTuple } from '../guard/kind.mjs';
 // prettier-ignore
 function RestResolve(T) {
-    return (IsIntersect(T) ? [...T.allOf] :
-        IsUnion(T) ? [...T.anyOf] :
-            IsTuple(T) ? [...(T.items ?? [])] :
+    return (IsIntersect(T) ? CloneRest(T.allOf) :
+        IsUnion(T) ? CloneRest(T.anyOf) :
+            IsTuple(T) ? CloneRest(T.items ?? []) :
                 []);
 }
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */

package/build/import/type/sets/set.mjs

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

package/build/import/type/template-literal/pattern.mjs

@@ -4,8 +4,7 @@ import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from '../guard/type.mjs';
+import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // TemplateLiteralPatternError
 // ------------------------------------------------------------------

package/build/import/type/transform/transform.mjs

@@ -3,7 +3,7 @@ import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsTransform } from '../guard/type.mjs';
+import { IsTransform } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // TransformBuilders
 // ------------------------------------------------------------------

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

@@ -7,7 +7,7 @@ import { UnionCreate } from './union-create.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsOptional } from '../guard/type.mjs';
+import { IsOptional } from '../guard/kind.mjs';
 // prettier-ignore
 function IsUnionOptional(T) {
     return T.some(L => IsOptional(L));

package/build/import/value/clean/clean.mjs

@@ -64,7 +64,7 @@ function FromRecord(schema, references, value) {
     if (!IsObject(value))
         return value;
     const additionalProperties = schema.additionalProperties;
-    const propertyKeys = Object.keys(value);
+    const propertyKeys = Object.getOwnPropertyNames(value);
     const [propertyKey, propertySchema] = Object.entries(schema.patternProperties)[0];
     const propertyKeyTest = new RegExp(propertyKey);
     for (const key of propertyKeys) {

package/build/import/value/clone/clone.mjs

@@ -6,8 +6,14 @@ import { IsArray, IsDate, IsStandardObject, IsTypedArray, IsValueType } from '..
 // Clonable
 // ------------------------------------------------------------------
 function ObjectType(value) {
-    const keys = [...Object.getOwnPropertyNames(value), ...Object.getOwnPropertySymbols(value)];
-    return keys.reduce((acc, key) => ({ ...acc, [key]: Clone(value[key]) }), {});
+    const Acc = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        Acc[key] = Clone(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        Acc[key] = Clone(value[key]);
+    }
+    return Acc;
 }
 function ArrayType(value) {
     return value.map((element) => Clone(element));

package/build/import/value/create/create.mjs

@@ -207,10 +207,13 @@ function FromObject(schema, references) {
     }
     else {
         const required = new Set(schema.required);
-        return (FromDefault(schema.default) ||
-            Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc };
-            }, {}));
+        const Acc = {};
+        for (const [key, subschema] of Object.entries(schema.properties)) {
+            if (!required.has(key))
+                continue;
+            Acc[key] = Visit(subschema, references);
+        }
+        return Acc;
     }
 }
 function FromPromise(schema, references) {
@@ -228,9 +231,10 @@ function FromRecord(schema, references) {
     }
     else if (!(keyPattern === PatternStringExact || keyPattern === PatternNumberExact)) {
         const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
-        return propertyKeys.reduce((acc, key) => {
-            return { ...acc, [key]: Visit(valueSchema, references) };
-        }, {});
+        const Acc = {};
+        for (const key of propertyKeys)
+            Acc[key] = Visit(valueSchema, references);
+        return Acc;
     }
     else {
         return {};

package/build/import/value/hash/hash.mjs

@@ -81,7 +81,7 @@ function NumberType(value) {
 }
 function ObjectType(value) {
     FNV1A64(ByteMarker.Object);
-    for (const key of globalThis.Object.keys(value).sort()) {
+    for (const key of globalThis.Object.getOwnPropertyNames(value).sort()) {
         Visit(key);
         Visit(value[key]);
     }

package/build/import/value/mutate/mutate.mjs

@@ -15,8 +15,8 @@ function ObjectType(root, path, current, next) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
-        const currentKeys = Object.keys(current);
-        const nextKeys = Object.keys(next);
+        const currentKeys = Object.getOwnPropertyNames(current);
+        const nextKeys = Object.getOwnPropertyNames(next);
         for (const currentKey of currentKeys) {
             if (!nextKeys.includes(currentKey)) {
                 delete current[currentKey];