@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/system/policy.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystemPolicy = void 0;
+const index_1 = require("../value/guard/index");
+var TypeSystemPolicy;
+(function (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
+    // ------------------------------------------------------------------
+    /** 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` */
+    TypeSystemPolicy.AllowArrayObject = false;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+    TypeSystemPolicy.AllowNaN = false;
+    /** Sets whether `null` should validate for void types. The default is `false` */
+    TypeSystemPolicy.AllowNullVoid = false;
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
+    function IsExactOptionalProperty(value, key) {
+        return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    /** Checks this value using the AllowArrayObjects policy */
+    function IsObjectLike(value) {
+        const isObject = (0, index_1.IsObject)(value);
+        return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !(0, index_1.IsArray)(value);
+    }
+    TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    /** Checks this value as a record using the AllowArrayObjects policy */
+    function IsRecordLike(value) {
+        return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+    }
+    TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    /** Checks this value using the AllowNaN policy */
+    function IsNumberLike(value) {
+        return TypeSystemPolicy.AllowNaN ? (0, index_1.IsNumber)(value) : Number.isFinite(value);
+    }
+    TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    /** Checks this value using the AllowVoidNull policy */
+    function IsVoidLike(value) {
+        const isUndefined = (0, index_1.IsUndefined)(value);
+        return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+    }
+    TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (exports.TypeSystemPolicy = TypeSystemPolicy = {}));

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

@@ -0,0 +1,16 @@
+import { type TUnsafe } from '../type/unsafe/index';
+import { TypeBoxError } from '../type/error/index';
+export declare class TypeSystemDuplicateTypeKind extends TypeBoxError {
+    constructor(kind: string);
+}
+export declare class TypeSystemDuplicateFormat extends TypeBoxError {
+    constructor(kind: string);
+}
+export type TypeFactoryFunction<Type, Options = Record<PropertyKey, unknown>> = (options?: Partial<Options>) => TUnsafe<Type>;
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
+export declare namespace TypeSystem {
+    /** Creates a new type */
+    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): TypeFactoryFunction<Type, Options>;
+    /** Creates a new string format */
+    function Format<F extends string>(format: F, check: (value: string) => boolean): F;
+}

package/build/cjs/system/system.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystem = exports.TypeSystemDuplicateFormat = exports.TypeSystemDuplicateTypeKind = void 0;
+const index_1 = require("../type/registry/index");
+const index_2 = require("../type/unsafe/index");
+const index_3 = require("../type/symbols/index");
+const index_4 = require("../type/error/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+class TypeSystemDuplicateTypeKind extends index_4.TypeBoxError {
+    constructor(kind) {
+        super(`Duplicate type kind '${kind}' detected`);
+    }
+}
+exports.TypeSystemDuplicateTypeKind = TypeSystemDuplicateTypeKind;
+class TypeSystemDuplicateFormat extends index_4.TypeBoxError {
+    constructor(kind) {
+        super(`Duplicate string format '${kind}' detected`);
+    }
+}
+exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
+var TypeSystem;
+(function (TypeSystem) {
+    /** Creates a new type */
+    function Type(kind, check) {
+        if (index_1.TypeRegistry.Has(kind))
+            throw new TypeSystemDuplicateTypeKind(kind);
+        index_1.TypeRegistry.Set(kind, check);
+        return (options = {}) => (0, index_2.Unsafe)({ ...options, [index_3.Kind]: kind });
+    }
+    TypeSystem.Type = Type;
+    /** Creates a new string format */
+    function Format(format, check) {
+        if (index_1.FormatRegistry.Has(format))
+            throw new TypeSystemDuplicateFormat(format);
+        index_1.FormatRegistry.Set(format, check);
+        return format;
+    }
+    TypeSystem.Format = Format;
+})(TypeSystem || (exports.TypeSystem = TypeSystem = {}));

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

@@ -0,0 +1,8 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TAny extends TSchema {
+    [Kind]: 'Any';
+    static: any;
+}
+/** `[Json]` Creates an Any type */
+export declare function Any(options?: SchemaOptions): TAny;

package/build/cjs/type/any/any.js

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

package/build/cjs/type/any/index.d.ts

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

package/build/cjs/type/any/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("./any"), exports);

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

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TArgument<Index extends number = number> extends TSchema {
+    [Kind]: 'Argument';
+    static: unknown;
+    index: Index;
+}
+/** `[JavaScript]` Creates an Argument Type. */
+export declare function Argument<Index extends number>(index: Index): TArgument<Index>;

package/build/cjs/type/argument/argument.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Argument = Argument;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+/** `[JavaScript]` Creates an Argument Type. */
+function Argument(index) {
+    return (0, type_1.CreateType)({ [index_1.Kind]: 'Argument', index });
+}

package/build/cjs/type/argument/index.d.ts

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

package/build/cjs/type/argument/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("./argument"), exports);

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

@@ -0,0 +1,28 @@
+import { Ensure } from '../helpers/index';
+import type { SchemaOptions, TSchema } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export interface ArrayOptions extends SchemaOptions {
+    /** The minimum number of items in this array */
+    minItems?: number;
+    /** The maximum number of items in this array */
+    maxItems?: number;
+    /** Should this schema contain unique items */
+    uniqueItems?: boolean;
+    /** A schema for which some elements should match */
+    contains?: TSchema;
+    /** A minimum number of contains schema matches */
+    minContains?: number;
+    /** A maximum number of contains schema matches */
+    maxContains?: number;
+}
+type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>;
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: ArrayStatic<T, this['params']>;
+    type: 'array';
+    items: T;
+}
+/** `[Json]` Creates an Array type */
+export declare function Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
+export {};

package/build/cjs/type/array/array.js

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

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

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

package/build/cjs/type/array/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("./array"), exports);

package/build/cjs/type/async-iterator/async-iterator.d.ts

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'AsyncIterator';
+    static: AsyncIterableIterator<Static<T, this['params']>>;
+    type: 'AsyncIterator';
+    items: T;
+}
+/** `[JavaScript]` Creates a AsyncIterator type */
+export declare function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;

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

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

package/build/cjs/type/async-iterator/index.d.ts

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

package/build/cjs/type/async-iterator/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("./async-iterator"), exports);

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

@@ -0,0 +1,14 @@
+import { Ensure } from '../helpers/index';
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TComputed } from '../computed/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TPromise } from '../promise/index';
+import { type TRef } from '../ref/index';
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<(TComputed<'Awaited', [TComputed<Target, Parameters>]>)>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Awaited', [TRef<Ref>]>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, [...Result, TAwaited<Left>]> : Result);
+export type TAwaited<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TPromise<infer Type extends TSchema> ? TAwaited<Type> : Type);
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+export declare function Awaited<T extends TSchema>(type: T, options?: SchemaOptions): TAwaited<T>;
+export {};

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Awaited = Awaited;
+const type_1 = require("../create/type");
+const index_1 = require("../computed/index");
+const index_2 = require("../intersect/index");
+const index_3 = require("../union/index");
+const index_4 = require("../ref/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return (0, index_1.Computed)('Awaited', [(0, index_1.Computed)(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return (0, index_1.Computed)('Awaited', [(0, index_4.Ref)($ref)]);
+}
+// prettier-ignore
+function FromIntersect(types) {
+    return (0, index_2.Intersect)(FromRest(types));
+}
+// prettier-ignore
+function FromUnion(types) {
+    return (0, index_3.Union)(FromRest(types));
+}
+// prettier-ignore
+function FromPromise(type) {
+    return Awaited(type);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => Awaited(type));
+}
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+function Awaited(type, options) {
+    return (0, type_1.CreateType)((0, kind_1.IsComputed)(type) ? FromComputed(type.target, type.parameters) : (0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf) : (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) : (0, kind_1.IsPromise)(type) ? FromPromise(type.item) : (0, kind_1.IsRef)(type) ? FromRef(type.$ref) : type, options);
+}

package/build/cjs/type/awaited/index.d.ts

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

package/build/cjs/type/awaited/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("./awaited"), exports);

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

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface BigIntOptions extends SchemaOptions {
+    exclusiveMaximum?: bigint;
+    exclusiveMinimum?: bigint;
+    maximum?: bigint;
+    minimum?: bigint;
+    multipleOf?: bigint;
+}
+export interface TBigInt extends TSchema, BigIntOptions {
+    [Kind]: 'BigInt';
+    static: bigint;
+    type: 'bigint';
+}
+/** `[JavaScript]` Creates a BigInt type */
+export declare function BigInt(options?: BigIntOptions): TBigInt;

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

@@ -0,0 +1,10 @@
+"use strict";
+
+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 (0, index_2.CreateType)({ [index_1.Kind]: 'BigInt', type: 'bigint' }, options);
+}

package/build/cjs/type/bigint/index.d.ts

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

package/build/cjs/type/bigint/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("./bigint"), exports);

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+/** `[Json]` Creates a Boolean type */
+export declare function Boolean(options?: SchemaOptions): TBoolean;

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

@@ -0,0 +1,10 @@
+"use strict";
+
+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 (0, index_2.CreateType)({ [index_1.Kind]: 'Boolean', type: 'boolean' }, options);
+}

package/build/cjs/type/boolean/index.d.ts

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

package/build/cjs/type/boolean/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("./boolean"), exports);

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

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

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

@@ -0,0 +1,19 @@
+"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);
+__exportStar(require("./value"), exports);

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloneRest = CloneRest;
+exports.CloneType = CloneType;
+const value_1 = require("./value");
+/** Clones a Rest */
+function CloneRest(schemas) {
+    return schemas.map((schema) => CloneType(schema));
+}
+/** Clones a Type */
+function CloneType(schema, options) {
+    return options === undefined ? (0, value_1.Clone)(schema) : (0, value_1.Clone)({ ...options, ...schema });
+}

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

@@ -0,0 +1,2 @@
+/** Clones a value */
+export declare function Clone<T>(value: T): T;

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

@@ -0,0 +1,73 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clone = Clone;
+const ValueGuard = __importStar(require("../guard/value"));
+function ArrayType(value) {
+    return value.map((value) => Visit(value));
+}
+function DateType(value) {
+    return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+    return new Uint8Array(value);
+}
+function RegExpType(value) {
+    return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Visit(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Visit(value[key]);
+    }
+    return result;
+}
+// prettier-ignore
+function Visit(value) {
+    return (ValueGuard.IsArray(value) ? ArrayType(value) :
+        ValueGuard.IsDate(value) ? DateType(value) :
+            ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
+                ValueGuard.IsRegExp(value) ? RegExpType(value) :
+                    ValueGuard.IsObject(value) ? ObjectType(value) :
+                        value);
+}
+/** Clones a value */
+function Clone(value) {
+    return Visit(value);
+}