@sinclair/typebox 0.32.35 → 0.33.1

package/build/cjs/type/union/union-create.d.ts

@@ -1,3 +1,3 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import { TUnion } from './union-type';
-export declare function UnionCreate<T extends TSchema[]>(T: [...T], options: SchemaOptions): TUnion<T>;
+export declare function UnionCreate<T extends TSchema[]>(T: [...T], options?: SchemaOptions): TUnion<T>;

package/build/cjs/type/union/union-create.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionCreate = UnionCreate;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 function UnionCreate(T, options) {
-    return { ...options, [index_1.Kind]: 'Union', anyOf: (0, type_1.CloneRest)(T) };
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Union', anyOf: T }, options);
 }

package/build/cjs/type/union/union-evaluated.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnionEvaluated = UnionEvaluated;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
 const index_3 = require("../never/index");
 const index_4 = require("../optional/index");
@@ -31,9 +31,9 @@ function ResolveUnion(T, options) {
         : (0, union_create_1.UnionCreate)(RemoveOptionalFromRest(T), options));
 }
 /** `[Json]` Creates an evaluated Union type */
-function UnionEvaluated(T, options = {}) {
+function UnionEvaluated(T, options) {
     // prettier-ignore
     return (T.length === 0 ? (0, index_3.Never)(options) :
-        T.length === 1 ? (0, type_1.CloneType)(T[0], options) :
+        T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
             ResolveUnion(T, options));
 }

package/build/cjs/type/union/union.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Union = Union;
 const index_1 = require("../never/index");
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 const union_create_1 = require("./union-create");
 /** `[Json]` Creates a Union type */
-function Union(T, options = {}) {
+function Union(T, options) {
     // prettier-ignore
     return (T.length === 0 ? (0, index_1.Never)(options) :
-        T.length === 1 ? (0, type_1.CloneType)(T[0], options) :
+        T.length === 1 ? (0, type_1.CreateType)(T[0], options) :
             (0, union_create_1.UnionCreate)(T, options));
 }

package/build/cjs/type/unknown/unknown.js

@@ -2,11 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unknown = Unknown;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates an Unknown type */
-function Unknown(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Unknown',
-    };
+function Unknown(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Unknown' }, options);
 }

package/build/cjs/type/unsafe/unsafe.js

@@ -2,11 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Unsafe = Unsafe;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
 function Unsafe(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: options[index_1.Kind] ?? 'Unsafe',
-    };
+    return (0, type_1.CreateType)({ [index_1.Kind]: options[index_1.Kind] ?? 'Unsafe' }, options);
 }

package/build/cjs/type/void/void.js

@@ -2,12 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Void = Void;
+const type_1 = require("../create/type");
 const index_1 = require("../symbols/index");
 /** `[JavaScript]` Creates a Void type */
-function Void(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Void',
-        type: 'void',
-    };
+function Void(options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Void', type: 'void' }, options);
 }

package/build/esm/index.d.mts

@@ -1,4 +1,5 @@
 export * from './type/clone/index.mjs';
+export * from './type/create/index.mjs';
 export * from './type/error/index.mjs';
 export * from './type/guard/index.mjs';
 export * from './type/helpers/index.mjs';

package/build/esm/index.mjs

@@ -2,6 +2,7 @@
 // Infrastructure
 // ------------------------------------------------------------------
 export * from './type/clone/index.mjs';
+export * from './type/create/index.mjs';
 export * from './type/error/index.mjs';
 export * from './type/guard/index.mjs';
 export * from './type/helpers/index.mjs';

package/build/esm/system/policy.d.mts

@@ -1,5 +1,13 @@
 export declare namespace TypeSystemPolicy {
-    /** Shared assertion routines used by the value and errors modules */
+    /**
+     * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+     * references for embedded types, which may cause side effects if type properties are explicitly updated
+     * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+     * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+     * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+     * fastest way to instantiate types. The default setting is `default`.
+     */
+    let InstanceMode: 'default' | 'clone' | 'freeze';
     /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     let ExactOptionalPropertyTypes: boolean;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */

package/build/esm/system/policy.mjs

@@ -2,9 +2,20 @@ import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index.m
 export var TypeSystemPolicy;
 (function (TypeSystemPolicy) {
     // ------------------------------------------------------------------
-    // TypeSystemPolicy
+    // TypeSystemPolicy: Instancing
+    // ------------------------------------------------------------------
+    /**
+     * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+     * references for embedded types, which may cause side effects if type properties are explicitly updated
+     * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+     * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+     * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+     * fastest way to instantiate types. The default setting is `default`.
+     */
+    TypeSystemPolicy.InstanceMode = 'default';
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy: Checking
     // ------------------------------------------------------------------
-    /** Shared assertion routines used by the value and errors modules */
     /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     TypeSystemPolicy.ExactOptionalPropertyTypes = false;
     /** Sets whether arrays should be treated as a kind of objects. The default is `false` */

package/build/esm/type/any/any.mjs

@@ -1,5 +1,6 @@
+import { CreateType } from '../create/index.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Any type */
-export function Any(options = {}) {
-    return { ...options, [Kind]: 'Any' };
+export function Any(options) {
+    return CreateType({ [Kind]: 'Any' }, options);
 }

package/build/esm/type/array/array.d.mts

@@ -24,5 +24,5 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     items: T;
 }
 /** `[Json]` Creates an Array type */
-export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
+export declare function Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
 export {};

package/build/esm/type/array/array.mjs

@@ -1,11 +1,6 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Array type */
-export function Array(schema, options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Array',
-        type: 'array',
-        items: CloneType(schema),
-    };
+export function Array(items, options) {
+    return CreateType({ [Kind]: 'Array', type: 'array', items }, options);
 }

package/build/esm/type/async-iterator/async-iterator.mjs

@@ -1,11 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 /** `[JavaScript]` Creates a AsyncIterator type */
-export function AsyncIterator(items, options = {}) {
-    return {
-        ...options,
-        [Kind]: 'AsyncIterator',
-        type: 'AsyncIterator',
-        items: CloneType(items),
-    };
+export function AsyncIterator(items, options) {
+    return CreateType({ [Kind]: 'AsyncIterator', type: 'AsyncIterator', items }, options);
 }

package/build/esm/type/awaited/awaited.mjs

@@ -1,6 +1,6 @@
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -32,6 +32,6 @@ function AwaitedResolve(T) {
                 T);
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export function Awaited(T, options = {}) {
-    return CloneType(AwaitedResolve(T), options);
+export function Awaited(T, options) {
+    return CreateType(AwaitedResolve(T), options);
 }

package/build/esm/type/bigint/bigint.mjs

@@ -1,9 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
 /** `[JavaScript]` Creates a BigInt type */
-export function BigInt(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'BigInt',
-        type: 'bigint',
-    };
+export function BigInt(options) {
+    return CreateType({ [Kind]: 'BigInt', type: 'bigint' }, options);
 }

package/build/esm/type/boolean/boolean.mjs

@@ -1,9 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
 /** `[Json]` Creates a Boolean type */
-export function Boolean(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Boolean',
-        type: 'boolean',
-    };
+export function Boolean(options) {
+    return CreateType({ [Kind]: 'Boolean', type: 'boolean' }, options);
 }

package/build/esm/type/clone/type.d.mts

@@ -1,4 +1,4 @@
-import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { TSchema, SchemaOptions } from '../schema/index.mjs';
 /** Clones a Rest */
 export declare function CloneRest<T extends TSchema[]>(schemas: T): T;
 /** Clones a Type */

package/build/esm/type/clone/type.mjs

@@ -4,6 +4,6 @@ export function CloneRest(schemas) {
     return schemas.map((schema) => CloneType(schema));
 }
 /** Clones a Type */
-export function CloneType(schema, options = {}) {
-    return { ...Clone(schema), ...options };
+export function CloneType(schema, options) {
+    return options === undefined ? Clone(schema) : Clone({ ...options, ...schema });
 }

package/build/esm/type/composite/composite.mjs

@@ -34,7 +34,7 @@ function CompositeProperties(T, K) {
     return Acc;
 }
 // prettier-ignore
-export function Composite(T, options = {}) {
+export function Composite(T, options) {
     const K = CompositeKeys(T);
     const P = CompositeProperties(T, K);
     const R = Object(P, options);

package/build/esm/type/const/const.mjs

@@ -11,7 +11,7 @@ import { Readonly } from '../readonly/index.mjs';
 import { Undefined } from '../undefined/index.mjs';
 import { Uint8Array } from '../uint8array/index.mjs';
 import { Unknown } from '../unknown/index.mjs';
-import { CloneType } from '../clone/index.mjs';
+import { CreateType } from '../create/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -49,6 +49,6 @@ function FromValue(value, root) {
                                                             Object({}));
 }
 /** `[JavaScript]` Creates a readonly const type from the given value. */
-export function Const(T, options = {}) {
-    return CloneType(FromValue(T, true), options);
+export function Const(T, options) {
+    return CreateType(FromValue(T, true), options);
 }

package/build/esm/type/constructor/constructor.mjs

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

package/build/esm/type/constructor-parameters/constructor-parameters.mjs

@@ -1,6 +1,5 @@
 import { Tuple } from '../tuple/index.mjs';
-import { CloneRest } from '../clone/type.mjs';
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export function ConstructorParameters(schema, options = {}) {
-    return Tuple(CloneRest(schema.parameters), { ...options });
+export function ConstructorParameters(schema, options) {
+    return Tuple(schema.parameters, options);
 }

package/build/esm/type/create/immutable.d.mts

@@ -0,0 +1,2 @@
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+export declare function Immutable<T>(value: T): T;

package/build/esm/type/create/immutable.mjs

@@ -0,0 +1,37 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ImmutableArray(value) {
+    return globalThis.Object.freeze(value).map((value) => Immutable(value));
+}
+function ImmutableDate(value) {
+    return value;
+}
+function ImmutableUint8Array(value) {
+    return value;
+}
+function ImmutableRegExp(value) {
+    return value;
+}
+function ImmutableObject(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    return globalThis.Object.freeze(result);
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+export function Immutable(value) {
+    return ValueGuard.IsArray(value)
+        ? ImmutableArray(value)
+        : ValueGuard.IsDate(value)
+            ? ImmutableDate(value)
+            : ValueGuard.IsUint8Array(value)
+                ? ImmutableUint8Array(value)
+                : ValueGuard.IsRegExp(value)
+                    ? ImmutableRegExp(value)
+                    : ValueGuard.IsObject(value)
+                        ? ImmutableObject(value)
+                        : value;
+}

package/build/esm/type/create/index.d.mts

@@ -0,0 +1 @@
+export * from './type.mjs';

package/build/esm/type/create/index.mjs

@@ -0,0 +1 @@
+export * from './type.mjs';

package/build/esm/type/create/type.d.mts

@@ -0,0 +1,3 @@
+import { SchemaOptions } from '../schema/schema.mjs';
+/** Creates TypeBox schematics using the configured InstanceMode */
+export declare function CreateType(schema: Record<any, unknown>, options?: SchemaOptions): unknown;

package/build/esm/type/create/type.mjs

@@ -0,0 +1,15 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
+import { Immutable } from './immutable.mjs';
+import { Clone } from '../clone/value.mjs';
+/** Creates TypeBox schematics using the configured InstanceMode */
+export function CreateType(schema, options) {
+    const result = options !== undefined ? { ...options, ...schema } : schema;
+    switch (TypeSystemPolicy.InstanceMode) {
+        case 'freeze':
+            return Immutable(result);
+        case 'clone':
+            return Clone(result);
+        default:
+            return result;
+    }
+}

package/build/esm/type/date/date.mjs

@@ -1,9 +1,6 @@
 import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/type.mjs';
 /** `[JavaScript]` Creates a Date type */
-export function Date(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Date',
-        type: 'Date',
-    };
+export function Date(options) {
+    return CreateType({ [Kind]: 'Date', type: 'Date' }, options);
 }

package/build/esm/type/discard/discard.d.mts

@@ -1 +1,2 @@
+/** Discards property keys from the given value. This function returns a shallow Clone. */
 export declare function Discard(value: Record<PropertyKey, any>, keys: PropertyKey[]): Record<PropertyKey, any>;

package/build/esm/type/discard/discard.mjs

@@ -2,6 +2,7 @@ function DiscardKey(value, key) {
     const { [key]: _, ...rest } = value;
     return rest;
 }
+/** Discards property keys from the given value. This function returns a shallow Clone. */
 export function Discard(value, keys) {
     return keys.reduce((acc, key) => DiscardKey(acc, key), value);
 }

package/build/esm/type/enum/enum.mjs

@@ -6,7 +6,7 @@ import { Union } from '../union/index.mjs';
 // ------------------------------------------------------------------
 import { IsUndefined } from '../guard/value.mjs';
 /** `[Json]` Creates a Enum type */
-export function Enum(item, options = {}) {
+export function Enum(item, options) {
     if (IsUndefined(item))
         throw new Error('Enum undefined or empty');
     const values1 = globalThis.Object.getOwnPropertyNames(item)

package/build/esm/type/exclude/exclude.mjs

@@ -1,7 +1,7 @@
+import { CreateType } from '../create/type.mjs';
 import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
 import { ExcludeFromTemplateLiteral } from './exclude-from-template-literal.mjs';
 // ------------------------------------------------------------------
@@ -16,10 +16,10 @@ function ExcludeRest(L, R) {
 export function Exclude(L, R, options = {}) {
     // overloads
     if (IsTemplateLiteral(L))
-        return CloneType(ExcludeFromTemplateLiteral(L, R), options);
+        return CreateType(ExcludeFromTemplateLiteral(L, R), options);
     if (IsMappedResult(L))
-        return CloneType(ExcludeFromMappedResult(L, R), options);
+        return CreateType(ExcludeFromMappedResult(L, R), options);
     // prettier-ignore
-    return CloneType(IsUnion(L) ? ExcludeRest(L.anyOf, R) :
+    return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) :
         ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
 }

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

@@ -10,5 +10,5 @@ type TFromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchem
 type TFromPropertyKeys<K extends PropertyKey[], U extends TSchema, L extends TSchema, R extends TSchema, Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<RK, U, L, R, Acc & TFromPropertyKey<LK, U, L, R>> : Acc);
 type TFromMappedKey<K extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromPropertyKeys<K['keys'], U, L, R>);
 export type TExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function ExtendsFromMappedKey<T extends TMappedKey, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedKey<T, U, L, R>>(T: T, U: U, L: L, R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Extends } from './extends.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromPropertyKey(K, U, L, R, options) {
     return {
-        [K]: Extends(Literal(K), U, L, R, options)
+        [K]: Extends(Literal(K), U, L, R, Clone(options))
     };
 }
 // prettier-ignore

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

@@ -7,5 +7,5 @@ type TFromProperties<P extends TProperties, Right extends TSchema, False extends
 });
 type TFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema> = (TFromProperties<Left['properties'], Right, True, False>);
 export type TExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>>(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P>;
+export declare function ExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>>(Left: Left, Right: Right, True: True, False: False, options?: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Extends } from './extends.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromProperties(P, Right, True, False, options) {
     const Acc = {};
     for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = Extends(P[K2], Right, True, False, options);
+        Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
     return Acc;
 }
 // prettier-ignore

package/build/esm/type/extends/extends.mjs

@@ -1,6 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Union } from '../union/index.mjs';
 import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { ExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
 import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -15,9 +15,9 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 /** `[Json]` Creates a Conditional type */
-export function Extends(L, R, T, F, options = {}) {
+export function Extends(L, R, T, F, options) {
     // prettier-ignore
     return (IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
-        IsMappedKey(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
-            CloneType(ExtendsResolve(L, R, T, F), options));
+        IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) :
+            CreateType(ExtendsResolve(L, R, T, F), options));
 }

package/build/esm/type/extract/extract.mjs

@@ -1,7 +1,7 @@
+import { CreateType } from '../create/type.mjs';
 import { Union } from '../union/index.mjs';
 import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
 import { ExtractFromTemplateLiteral } from './extract-from-template-literal.mjs';
 // ------------------------------------------------------------------
@@ -13,13 +13,13 @@ function ExtractRest(L, R) {
     return extracted.length === 1 ? extracted[0] : Union(extracted);
 }
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract(L, R, options = {}) {
+export function Extract(L, R, options) {
     // overloads
     if (IsTemplateLiteral(L))
-        return CloneType(ExtractFromTemplateLiteral(L, R), options);
+        return CreateType(ExtractFromTemplateLiteral(L, R), options);
     if (IsMappedResult(L))
-        return CloneType(ExtractFromMappedResult(L, R), options);
+        return CreateType(ExtractFromMappedResult(L, R), options);
     // prettier-ignore
-    return CloneType(IsUnion(L) ? ExtractRest(L.anyOf, R) :
+    return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) :
         ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
 }

package/build/esm/type/function/function.mjs

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

package/build/esm/type/guard/value.mjs

@@ -1,3 +1,6 @@
+// --------------------------------------------------------------------------
+// Object Instances
+// --------------------------------------------------------------------------
 /** Returns true if this value is an async iterator */
 export function IsAsyncIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;

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

@@ -9,5 +9,5 @@ type TMappedIndexPropertyKey<T extends TSchema, K extends PropertyKey> = {
 type TMappedIndexPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TMappedIndexPropertyKeys<T, R, Acc & TMappedIndexPropertyKey<T, L>> : Acc);
 type TMappedIndexProperties<T extends TSchema, K extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<T, K['keys']>>;
 export type TIndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export declare function IndexFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TMappedIndexProperties<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
 export {};

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

@@ -1,8 +1,9 @@
 import { Index } from './indexed.mjs';
 import { MappedResult } from '../mapped/index.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: Index(T, [K], options) };
+    return { [K]: Index(T, [K], Clone(options)) };
 }
 // prettier-ignore
 function MappedIndexPropertyKeys(T, K, options) {

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

@@ -8,5 +8,5 @@ type TFromProperties<T extends TSchema, P extends TProperties> = ({
 });
 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 declare function IndexFromMappedResult<T extends TSchema, R extends TMappedResult, P extends TProperties = TFromMappedResult<T, R>>(T: T, R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};