@sinclair/typebox 0.32.34 → 0.33.0

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

@@ -1,9 +1,10 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Omit } from './omit.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
-        [K]: Omit(T, [K], options)
+        [K]: Omit(T, [K], Clone(options))
     };
 }
 // prettier-ignore

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

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
 });
 type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
 export type TOmitFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
+export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
 export {};

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

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

package/build/esm/type/omit/omit.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
 import { OmitFromMappedResult } from './omit-from-mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -41,7 +41,7 @@ function OmitResolve(T, K) {
             IsObject(T) ? Object(FromProperties(T.properties, K)) :
                 Object({}));
 }
-export function Omit(T, K, options = {}) {
+export function Omit(T, K, options) {
     // mapped
     if (IsMappedKey(K))
         return OmitFromMappedKey(T, K, options);
@@ -50,6 +50,6 @@ export function Omit(T, K, options = {}) {
     // non-mapped
     const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
     const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(OmitResolve(T, I), options);
-    return { ...D, ...R };
+    const R = OmitResolve(T, I);
+    return CreateType({ ...D, ...R }, options);
 }

package/build/esm/type/optional/optional.mjs

@@ -1,13 +1,13 @@
+import { CreateType } from '../create/type.mjs';
 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/kind.mjs';
 function RemoveOptional(schema) {
-    return Discard(CloneType(schema), [OptionalKind]);
+    return CreateType(Discard(schema, [OptionalKind]));
 }
 function AddOptional(schema) {
-    return { ...CloneType(schema), [OptionalKind]: 'Optional' };
+    return CreateType({ ...schema, [OptionalKind]: 'Optional' });
 }
 // prettier-ignore
 function OptionalWithFlag(schema, F) {

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

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

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

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties> = ({
 });
 type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
 export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

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

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

package/build/esm/type/partial/partial.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
@@ -32,10 +32,10 @@ function PartialResolve(T) {
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(T, options = {}) {
+export function Partial(T, options) {
     if (IsMappedResult(T))
         return PartialFromMappedResult(T, options);
     const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PartialResolve(T), options);
-    return { ...D, ...R };
+    const R = PartialResolve(T);
+    return CreateType({ ...options, ...D, ...R });
 }

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

@@ -1,6 +1,8 @@
 export declare const PatternBoolean = "(true|false)";
 export declare const PatternNumber = "(0|[1-9][0-9]*)";
 export declare const PatternString = "(.*)";
+export declare const PatternNever = "(?!.*)";
 export declare const PatternBooleanExact = "^(true|false)$";
 export declare const PatternNumberExact = "^(0|[1-9][0-9]*)$";
 export declare const PatternStringExact = "^(.*)$";
+export declare const PatternNeverExact = "^(?!.*)$";

package/build/esm/type/patterns/patterns.mjs

@@ -1,6 +1,8 @@
 export const PatternBoolean = '(true|false)';
 export const PatternNumber = '(0|[1-9][0-9]*)';
 export const PatternString = '(.*)';
+export const PatternNever = '(?!.*)';
 export const PatternBooleanExact = `^${PatternBoolean}$`;
 export const PatternNumberExact = `^${PatternNumber}$`;
 export const PatternStringExact = `^${PatternString}$`;
+export const PatternNeverExact = `^${PatternNever}$`;

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

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

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

@@ -1,9 +1,10 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
-        [K]: Pick(T, [K], options)
+        [K]: Pick(T, [K], Clone(options))
     };
 }
 // prettier-ignore

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

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
 });
 type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
 export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
+export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
 export {};

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

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

package/build/esm/type/pick/pick.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
 import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -36,7 +36,7 @@ function PickResolve(T, K) {
             IsObject(T) ? Object(FromProperties(T.properties, K)) :
                 Object({}));
 }
-export function Pick(T, K, options = {}) {
+export function Pick(T, K, options) {
     // mapped
     if (IsMappedKey(K))
         return PickFromMappedKey(T, K, options);
@@ -45,6 +45,6 @@ export function Pick(T, K, options = {}) {
     // non-mapped
     const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
     const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PickResolve(T, I), options);
-    return { ...D, ...R };
+    const R = PickResolve(T, I);
+    return CreateType({ ...D, ...R }, options);
 }

package/build/esm/type/promise/promise.mjs

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

package/build/esm/type/readonly/readonly.mjs

@@ -1,13 +1,13 @@
+import { CreateType } from '../create/type.mjs';
 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/kind.mjs';
 function RemoveReadonly(schema) {
-    return Discard(CloneType(schema), [ReadonlyKind]);
+    return CreateType(Discard(schema, [ReadonlyKind]));
 }
 function AddReadonly(schema) {
-    return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' };
+    return CreateType({ ...schema, [ReadonlyKind]: 'Readonly' });
 }
 // prettier-ignore
 function ReadonlyWithFlag(schema, F) {

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

@@ -1,6 +1,7 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { Static } from '../static/index.mjs';
 import type { Evaluate, Ensure, Assert } from '../helpers/index.mjs';
+import { type TAny } from '../any/index.mjs';
 import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index.mjs';
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNever } from '../never/index.mjs';
@@ -33,6 +34,8 @@ type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObje
 }>>);
 type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
+type TFromAnyKey<_ extends TAny, T extends TSchema> = (Ensure<TRecord<TAny, T>>);
+type TFromNeverKey<_ extends TNever, T extends TSchema> = (Ensure<TRecord<TNever, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type RecordStatic<K extends TSchema, T extends TSchema, P extends unknown[]> = (Evaluate<{
@@ -47,7 +50,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : K extends TAny ? TFromAnyKey<K, T> : K extends TNever ? TFromNeverKey<K, T> : TNever;
 /** `[Json]` Creates a Record type */
 export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};

package/build/esm/type/record/record.mjs

@@ -1,11 +1,11 @@
+import { CreateType } from '../create/type.mjs';
 import { Object } from '../object/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Union } from '../union/index.mjs';
 import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
-import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
+import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -13,18 +13,17 @@ import { IsUndefined } from '../guard/value.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
+import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
 // ------------------------------------------------------------------
 // RecordCreateFromPattern
 // ------------------------------------------------------------------
 // prettier-ignore
 function RecordCreateFromPattern(pattern, T, options) {
-    return {
-        ...options,
+    return CreateType({
         [Kind]: 'Record',
         type: 'object',
-        patternProperties: { [pattern]: CloneType(T) }
-    };
+        patternProperties: { [pattern]: T }
+    }, options);
 }
 // ------------------------------------------------------------------
 // RecordCreateFromKeys
@@ -33,7 +32,7 @@ function RecordCreateFromPattern(pattern, T, options) {
 function RecordCreateFromKeys(K, T, options) {
     const Acc = {};
     for (const K2 of K)
-        Acc[K2] = CloneType(T);
+        Acc[K2] = T;
     return Object(Acc, { ...options, [Hint]: 'Record' });
 }
 // prettier-ignore
@@ -60,6 +59,14 @@ function FromStringKey(K, T, options) {
     return RecordCreateFromPattern(pattern, T, options);
 }
 // prettier-ignore
+function FromAnyKey(K, T, options) {
+    return RecordCreateFromPattern(PatternStringExact, T, options);
+}
+// prettier-ignore
+function FromNeverKey(K, T, options) {
+    return RecordCreateFromPattern(PatternNeverExact, T, options);
+}
+// prettier-ignore
 function FromIntegerKey(_, T, options) {
     return RecordCreateFromPattern(PatternNumberExact, T, options);
 }
@@ -80,5 +87,7 @@ export function Record(K, T, options = {}) {
                     IsNumber(K) ? FromNumberKey(K, T, options) :
                         IsRegExp(K) ? FromRegExpKey(K, T, options) :
                             IsString(K) ? FromStringKey(K, T, options) :
-                                Never(options));
+                                IsAny(K) ? FromAnyKey(K, T, options) :
+                                    IsNever(K) ? FromNeverKey(K, T, options) :
+                                        Never(options));
 }

package/build/esm/type/recursive/recursive.mjs

@@ -1,4 +1,5 @@
 import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { IsUndefined } from '../guard/value.mjs';
 import { Kind, Hint } from '../symbols/index.mjs';
 // Auto Tracked For Recursive Types without ID's
@@ -7,8 +8,8 @@ let Ordinal = 0;
 export function Recursive(callback, options = {}) {
     if (IsUndefined(options.$id))
         options.$id = `T${Ordinal++}`;
-    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
+    const thisType = CloneType(callback({ [Kind]: 'This', $ref: `${options.$id}` }));
     thisType.$id = options.$id;
     // prettier-ignore
-    return CloneType({ ...options, [Hint]: 'Recursive', ...thisType });
+    return CreateType({ [Hint]: 'Recursive', ...thisType }, options);
 }

package/build/esm/type/ref/ref.mjs

@@ -1,17 +1,14 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 import { IsString, IsUndefined } from '../guard/value.mjs';
 /** `[Json]` Creates a Ref type. */
-export function Ref(unresolved, options = {}) {
+export function Ref(unresolved, options) {
     if (IsString(unresolved))
-        return { ...options, [Kind]: 'Ref', $ref: unresolved };
+        return CreateType({ [Kind]: 'Ref', $ref: unresolved }, options);
     if (IsUndefined(unresolved.$id))
         throw new Error('Reference target type must specify an $id');
-    return {
-        ...options,
-        [Kind]: 'Ref',
-        $ref: unresolved.$id,
-    };
+    return CreateType({ [Kind]: 'Ref', $ref: unresolved.$id }, options);
 }

package/build/esm/type/regexp/regexp.mjs

@@ -1,7 +1,8 @@
+import { CreateType } from '../create/type.mjs';
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates a RegExp type */
-export function RegExp(unresolved, options = {}) {
+export function RegExp(unresolved, options) {
     const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-    return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
+    return CreateType({ [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options);
 }

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

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties> = ({
 });
 type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
 export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/required/required.mjs

@@ -1,8 +1,8 @@
+import { CreateType } from '../create/type.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { OptionalKind, TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -31,13 +31,13 @@ function RequiredResolve(T) {
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are required */
-export function Required(T, options = {}) {
+export function Required(T, options) {
     if (IsMappedResult(T)) {
         return RequiredFromMappedResult(T, options);
     }
     else {
         const D = Discard(T, [TransformKind, '$id', 'required']);
-        const R = CloneType(RequiredResolve(T), options);
-        return { ...D, ...R };
+        const R = RequiredResolve(T);
+        return CreateType({ ...D, ...R }, options);
     }
 }

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

@@ -2,7 +2,7 @@ import type { TSchema } from '../schema/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TUnion } from '../union/index.mjs';
 import type { TTuple } from '../tuple/index.mjs';
-type TRestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+type TRestResolve<T extends TSchema> = T extends TIntersect<infer S extends TSchema[]> ? S : T extends TUnion<infer S extends TSchema[]> ? S : T extends TTuple<infer S extends TSchema[]> ? S : [
 ];
 export type TRest<T extends TSchema> = TRestResolve<T>;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */

package/build/esm/type/rest/rest.mjs

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

package/build/esm/type/return-type/return-type.mjs

@@ -1,5 +1,5 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-export function ReturnType(schema, options = {}) {
-    return CloneType(schema.returns, options);
+export function ReturnType(schema, options) {
+    return CreateType(schema.returns, options);
 }

package/build/esm/type/string/string.mjs

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

package/build/esm/type/symbol/symbol.mjs

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

package/build/esm/type/template-literal/template-literal.mjs

@@ -1,12 +1,13 @@
+import { CreateType } from '../create/type.mjs';
 import { TemplateLiteralSyntax } from './syntax.mjs';
 import { TemplateLiteralPattern } from './pattern.mjs';
 import { IsString } from '../guard/value.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a TemplateLiteral type */
 // prettier-ignore
-export function TemplateLiteral(unresolved, options = {}) {
+export function TemplateLiteral(unresolved, options) {
     const pattern = IsString(unresolved)
         ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved))
         : TemplateLiteralPattern(unresolved);
-    return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern };
+    return CreateType({ [Kind]: 'TemplateLiteral', type: 'string', pattern }, options);
 }

package/build/esm/type/transform/transform.mjs

@@ -1,5 +1,4 @@
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -32,8 +31,7 @@ export class TransformEncodeBuilder {
         return { ...schema, [TransformKind]: Codec };
     }
     Encode(encode) {
-        const schema = CloneType(this.schema);
-        return (IsTransform(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+        return (IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema));
     }
 }
 /** `[Json]` Creates a Transform type */

package/build/esm/type/tuple/tuple.mjs

@@ -1,11 +1,9 @@
-import { CloneRest } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Tuple type */
-export function Tuple(items, options = {}) {
-    // return TupleResolver.Resolve(T)
-    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+export function Tuple(items, options) {
     // prettier-ignore
-    return (items.length > 0 ?
-        { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
-        { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems });
+    return CreateType(items.length > 0 ?
+        { [Kind]: 'Tuple', type: 'array', items, additionalItems: false, minItems: items.length, maxItems: items.length } :
+        { [Kind]: 'Tuple', type: 'array', minItems: items.length, maxItems: items.length }, options);
 }