@sinclair/typebox 0.32.34 → 0.33.0

package/build/cjs/errors/function.js

@@ -100,7 +100,7 @@ function DefaultErrorFunction(error) {
         case errors_1.ValueErrorType.ObjectMinProperties:
             return `Expected object to have at least ${error.schema.minProperties} properties`;
         case errors_1.ValueErrorType.ObjectRequiredProperty:
-            return 'Required property';
+            return 'Expected required property';
         case errors_1.ValueErrorType.Promise:
             return 'Expected Promise';
         case errors_1.ValueErrorType.RegExp:

package/build/cjs/index.d.ts

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

package/build/cjs/index.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // Infrastructure
 // ------------------------------------------------------------------
 __exportStar(require("./type/clone/index"), exports);
+__exportStar(require("./type/create/index"), exports);
 __exportStar(require("./type/error/index"), exports);
 __exportStar(require("./type/guard/index"), exports);
 __exportStar(require("./type/helpers/index"), exports);

package/build/cjs/system/policy.d.ts

@@ -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/cjs/system/policy.js

@@ -6,9 +6,20 @@ const index_1 = require("../value/guard/index");
 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/cjs/type/any/any.js

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

package/build/cjs/type/array/array.d.ts

@@ -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/cjs/type/array/array.js

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

package/build/cjs/type/async-iterator/async-iterator.js

@@ -3,13 +3,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncIterator = AsyncIterator;
 const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 /** `[JavaScript]` Creates a AsyncIterator type */
-function AsyncIterator(items, options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'AsyncIterator',
-        type: 'AsyncIterator',
-        items: (0, type_1.CloneType)(items),
-    };
+function AsyncIterator(items, options) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'AsyncIterator', type: 'AsyncIterator', items }, options);
 }

package/build/cjs/type/awaited/awaited.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Awaited = Awaited;
 const index_1 = require("../intersect/index");
 const index_2 = require("../union/index");
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -36,6 +36,6 @@ function AwaitedResolve(T) {
                 T);
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-function Awaited(T, options = {}) {
-    return (0, type_1.CloneType)(AwaitedResolve(T), options);
+function Awaited(T, options) {
+    return (0, type_1.CreateType)(AwaitedResolve(T), options);
 }

package/build/cjs/type/bigint/bigint.js

@@ -3,11 +3,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BigInt = BigInt;
 const index_1 = require("../symbols/index");
+const index_2 = require("../create/index");
 /** `[JavaScript]` Creates a BigInt type */
-function BigInt(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'BigInt',
-        type: 'bigint',
-    };
+function BigInt(options) {
+    return (0, index_2.CreateType)({ [index_1.Kind]: 'BigInt', type: 'bigint' }, options);
 }

package/build/cjs/type/boolean/boolean.js

@@ -3,11 +3,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Boolean = Boolean;
 const index_1 = require("../symbols/index");
+const index_2 = require("../create/index");
 /** `[Json]` Creates a Boolean type */
-function Boolean(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Boolean',
-        type: 'boolean',
-    };
+function Boolean(options) {
+    return (0, index_2.CreateType)({ [index_1.Kind]: 'Boolean', type: 'boolean' }, options);
 }

package/build/cjs/type/clone/type.d.ts

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

package/build/cjs/type/clone/type.js

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

package/build/cjs/type/composite/composite.js

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

package/build/cjs/type/const/const.js

@@ -15,7 +15,7 @@ const index_10 = require("../readonly/index");
 const index_11 = require("../undefined/index");
 const index_12 = require("../uint8array/index");
 const index_13 = require("../unknown/index");
-const index_14 = require("../clone/index");
+const index_14 = require("../create/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -53,6 +53,6 @@ function FromValue(value, root) {
                                                             (0, index_7.Object)({}));
 }
 /** `[JavaScript]` Creates a readonly const type from the given value. */
-function Const(T, options = {}) {
-    return (0, index_14.CloneType)(FromValue(T, true), options);
+function Const(T, options) {
+    return (0, index_14.CreateType)(FromValue(T, true), options);
 }

package/build/cjs/type/constructor/constructor.js

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

package/build/cjs/type/constructor-parameters/constructor-parameters.js

@@ -3,8 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorParameters = ConstructorParameters;
 const index_1 = require("../tuple/index");
-const type_1 = require("../clone/type");
 /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-function ConstructorParameters(schema, options = {}) {
-    return (0, index_1.Tuple)((0, type_1.CloneRest)(schema.parameters), { ...options });
+function ConstructorParameters(schema, options) {
+    return (0, index_1.Tuple)(schema.parameters, options);
 }

package/build/cjs/type/create/immutable.d.ts

@@ -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/cjs/type/create/immutable.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Immutable = Immutable;
+const ValueGuard = require("../guard/value");
+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 */
+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/cjs/type/create/index.d.ts

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

package/build/cjs/type/create/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./type"), exports);

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateType = CreateType;
+const policy_1 = require("../../system/policy");
+const immutable_1 = require("./immutable");
+const value_1 = require("../clone/value");
+/** Creates TypeBox schematics using the configured InstanceMode */
+function CreateType(schema, options) {
+    const result = options !== undefined ? Object.assign(options, schema) : schema;
+    switch (policy_1.TypeSystemPolicy.InstanceMode) {
+        case 'freeze':
+            return (0, immutable_1.Immutable)(result);
+        case 'clone':
+            return (0, value_1.Clone)(result);
+        default:
+            return result;
+    }
+}

package/build/cjs/type/date/date.js

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

package/build/cjs/type/discard/discard.d.ts

@@ -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/cjs/type/discard/discard.js

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

package/build/cjs/type/enum/enum.js

@@ -10,7 +10,7 @@ const index_3 = require("../union/index");
 // ------------------------------------------------------------------
 const value_1 = require("../guard/value");
 /** `[Json]` Creates a Enum type */
-function Enum(item, options = {}) {
+function Enum(item, options) {
     if ((0, value_1.IsUndefined)(item))
         throw new Error('Enum undefined or empty');
     const values1 = globalThis.Object.getOwnPropertyNames(item)

package/build/cjs/type/exclude/exclude.js

@@ -2,10 +2,10 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Exclude = Exclude;
+const type_1 = require("../create/type");
 const index_1 = require("../union/index");
 const index_2 = require("../never/index");
 const index_3 = require("../extends/index");
-const type_1 = require("../clone/type");
 const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
 const exclude_from_template_literal_1 = require("./exclude-from-template-literal");
 // ------------------------------------------------------------------
@@ -20,10 +20,10 @@ function ExcludeRest(L, R) {
 function Exclude(L, R, options = {}) {
     // overloads
     if ((0, kind_1.IsTemplateLiteral)(L))
-        return (0, type_1.CloneType)((0, exclude_from_template_literal_1.ExcludeFromTemplateLiteral)(L, R), options);
+        return (0, type_1.CreateType)((0, exclude_from_template_literal_1.ExcludeFromTemplateLiteral)(L, R), options);
     if ((0, kind_1.IsMappedResult)(L))
-        return (0, type_1.CloneType)((0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(L, R), options);
+        return (0, type_1.CreateType)((0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(L, R), options);
     // prettier-ignore
-    return (0, type_1.CloneType)((0, kind_1.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
+    return (0, type_1.CreateType)((0, kind_1.IsUnion)(L) ? ExcludeRest(L.anyOf, R) :
         (0, index_3.ExtendsCheck)(L, R) !== index_3.ExtendsResult.False ? (0, index_2.Never)() : L, options);
 }

package/build/cjs/type/extends/extends-from-mapped-key.d.ts

@@ -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/cjs/type/extends/extends-from-mapped-key.js

@@ -5,10 +5,11 @@ exports.ExtendsFromMappedKey = ExtendsFromMappedKey;
 const index_1 = require("../mapped/index");
 const index_2 = require("../literal/index");
 const extends_1 = require("./extends");
+const value_1 = require("../clone/value");
 // prettier-ignore
 function FromPropertyKey(K, U, L, R, options) {
     return {
-        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R, options)
+        [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R, (0, value_1.Clone)(options))
     };
 }
 // prettier-ignore

package/build/cjs/type/extends/extends-from-mapped-result.d.ts

@@ -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/cjs/type/extends/extends-from-mapped-result.js

@@ -4,11 +4,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendsFromMappedResult = ExtendsFromMappedResult;
 const index_1 = require("../mapped/index");
 const extends_1 = require("./extends");
+const value_1 = require("../clone/value");
 // prettier-ignore
 function FromProperties(P, Right, True, False, options) {
     const Acc = {};
     for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = (0, extends_1.Extends)(P[K2], Right, True, False, options);
+        Acc[K2] = (0, extends_1.Extends)(P[K2], Right, True, False, (0, value_1.Clone)(options));
     return Acc;
 }
 // prettier-ignore

package/build/cjs/type/extends/extends.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extends = Extends;
+const type_1 = require("../create/type");
 const index_1 = require("../union/index");
 const extends_check_1 = require("./extends-check");
-const type_1 = require("../clone/type");
 const extends_from_mapped_key_1 = require("./extends-from-mapped-key");
 const extends_from_mapped_result_1 = require("./extends-from-mapped-result");
 // ------------------------------------------------------------------
@@ -19,9 +19,9 @@ function ExtendsResolve(left, right, trueType, falseType) {
             falseType);
 }
 /** `[Json]` Creates a Conditional type */
-function Extends(L, R, T, F, options = {}) {
+function Extends(L, R, T, F, options) {
     // prettier-ignore
     return ((0, kind_1.IsMappedResult)(L) ? (0, extends_from_mapped_result_1.ExtendsFromMappedResult)(L, R, T, F, options) :
-        (0, kind_1.IsMappedKey)(L) ? (0, type_1.CloneType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
-            (0, type_1.CloneType)(ExtendsResolve(L, R, T, F), options));
+        (0, kind_1.IsMappedKey)(L) ? (0, type_1.CreateType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
+            (0, type_1.CreateType)(ExtendsResolve(L, R, T, F), options));
 }

package/build/cjs/type/extract/extract.js

@@ -2,10 +2,10 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extract = Extract;
+const type_1 = require("../create/type");
 const index_1 = require("../union/index");
 const index_2 = require("../never/index");
 const index_3 = require("../extends/index");
-const type_1 = require("../clone/type");
 const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
 const extract_from_template_literal_1 = require("./extract-from-template-literal");
 // ------------------------------------------------------------------
@@ -17,13 +17,13 @@ function ExtractRest(L, R) {
     return extracted.length === 1 ? extracted[0] : (0, index_1.Union)(extracted);
 }
 /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-function Extract(L, R, options = {}) {
+function Extract(L, R, options) {
     // overloads
     if ((0, kind_1.IsTemplateLiteral)(L))
-        return (0, type_1.CloneType)((0, extract_from_template_literal_1.ExtractFromTemplateLiteral)(L, R), options);
+        return (0, type_1.CreateType)((0, extract_from_template_literal_1.ExtractFromTemplateLiteral)(L, R), options);
     if ((0, kind_1.IsMappedResult)(L))
-        return (0, type_1.CloneType)((0, extract_from_mapped_result_1.ExtractFromMappedResult)(L, R), options);
+        return (0, type_1.CreateType)((0, extract_from_mapped_result_1.ExtractFromMappedResult)(L, R), options);
     // prettier-ignore
-    return (0, type_1.CloneType)((0, kind_1.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
+    return (0, type_1.CreateType)((0, kind_1.IsUnion)(L) ? ExtractRest(L.anyOf, R) :
         (0, index_3.ExtendsCheck)(L, R) !== index_3.ExtendsResult.False ? L : (0, index_2.Never)(), options);
 }

package/build/cjs/type/function/function.js

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

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

@@ -16,6 +16,9 @@ exports.IsString = IsString;
 exports.IsSymbol = IsSymbol;
 exports.IsUint8Array = IsUint8Array;
 exports.IsUndefined = IsUndefined;
+// --------------------------------------------------------------------------
+// Object Instances
+// --------------------------------------------------------------------------
 /** Returns true if this value is an async iterator */
 function IsAsyncIterator(value) {
     return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;

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

@@ -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/cjs/type/indexed/indexed-from-mapped-key.js

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromMappedKey = IndexFromMappedKey;
 const indexed_1 = require("./indexed");
 const index_1 = require("../mapped/index");
+const value_1 = require("../clone/value");
 // prettier-ignore
 function MappedIndexPropertyKey(T, K, options) {
-    return { [K]: (0, indexed_1.Index)(T, [K], options) };
+    return { [K]: (0, indexed_1.Index)(T, [K], (0, value_1.Clone)(options)) };
 }
 // prettier-ignore
 function MappedIndexPropertyKeys(T, K, options) {

package/build/cjs/type/indexed/indexed-from-mapped-result.d.ts

@@ -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 {};

package/build/cjs/type/indexed/indexed.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFromPropertyKey = IndexFromPropertyKey;
 exports.IndexFromPropertyKeys = IndexFromPropertyKeys;
 exports.Index = Index;
+const type_1 = require("../create/type");
 const index_1 = require("../never/index");
 const index_2 = require("../intersect/index");
 const index_3 = require("../union/index");
-const type_1 = require("../clone/type");
 const indexed_property_keys_1 = require("./indexed-property-keys");
 const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
 const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
@@ -71,10 +71,14 @@ function FromSchema(T, K) {
     return ((0, index_3.UnionEvaluated)(IndexFromPropertyKeys(T, K)));
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-function Index(T, K, options = {}) {
+function Index(T, K, options) {
+    // mapped-types
+    if ((0, kind_1.IsMappedResult)(K))
+        return (0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options);
+    if ((0, kind_1.IsMappedKey)(K))
+        return (0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options);
     // prettier-ignore
-    return ((0, kind_1.IsMappedResult)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_result_1.IndexFromMappedResult)(T, K, options)) :
-        (0, kind_1.IsMappedKey)(K) ? (0, type_1.CloneType)((0, indexed_from_mapped_key_1.IndexFromMappedKey)(T, K, options)) :
-            (0, kind_1.IsSchema)(K) ? (0, type_1.CloneType)(FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K)), options) :
-                (0, type_1.CloneType)(FromSchema(T, K), options));
+    return (0, type_1.CreateType)((0, kind_1.IsSchema)(K)
+        ? FromSchema(T, (0, indexed_property_keys_1.IndexPropertyKeys)(K))
+        : FromSchema(T, K), options);
 }

package/build/cjs/type/instance-type/instance-type.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceType = InstanceType;
-const type_1 = require("../clone/type");
+const type_1 = require("../create/type");
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-function InstanceType(schema, options = {}) {
-    return (0, type_1.CloneType)(schema.returns, options);
+function InstanceType(schema, options) {
+    return (0, type_1.CreateType)(schema.returns, options);
 }