@sinclair/typebox 0.32.34 → 0.33.0

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 ? Object.assign(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 {};

package/build/esm/type/indexed/indexed.mjs

@@ -1,7 +1,7 @@
+import { CreateType } from '../create/type.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectEvaluated } from '../intersect/index.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
@@ -65,10 +65,14 @@ function FromSchema(T, K) {
     return (UnionEvaluated(IndexFromPropertyKeys(T, K)));
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index(T, K, options = {}) {
+export function Index(T, K, options) {
+    // mapped-types
+    if (IsMappedResult(K))
+        return IndexFromMappedResult(T, K, options);
+    if (IsMappedKey(K))
+        return IndexFromMappedKey(T, K, options);
     // prettier-ignore
-    return (IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
-        IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
-            IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
-                CloneType(FromSchema(T, K), options));
+    return CreateType(IsSchema(K)
+        ? FromSchema(T, IndexPropertyKeys(K))
+        : FromSchema(T, K), options);
 }

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

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

package/build/esm/type/integer/integer.mjs

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

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

@@ -1,3 +1,3 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { TIntersect, IntersectOptions } from './intersect-type.mjs';
-export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions): TIntersect<T>;
+export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options?: IntersectOptions): TIntersect<T>;

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

@@ -1,5 +1,5 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
-import { CloneType, CloneRest } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -8,12 +8,12 @@ import { IsObject, IsSchema } from '../guard/kind.mjs';
 // IntersectCreate
 // ------------------------------------------------------------------
 // prettier-ignore
-export function IntersectCreate(T, options) {
+export function IntersectCreate(T, options = {}) {
     const allObjects = T.every((schema) => IsObject(schema));
     const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties)
-        ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
+        ? { unevaluatedProperties: options.unevaluatedProperties }
         : {};
-    return ((options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
-        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
-        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
+    return CreateType((options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
+        ? { ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: T }
+        : { ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: T }), options);
 }

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

@@ -1,5 +1,5 @@
 import { OptionalKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Optional } from '../optional/index.mjs';
@@ -31,7 +31,7 @@ export function IntersectEvaluated(T, options = {}) {
     if (T.length === 0)
         return Never(options);
     if (T.length === 1)
-        return CloneType(T[0], options);
+        return CreateType(T[0], options);
     if (T.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
     return ResolveIntersect(T, options);

package/build/esm/type/intersect/intersect.mjs

@@ -1,4 +1,4 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
@@ -6,11 +6,11 @@ import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
 import { IsTransform } from '../guard/kind.mjs';
 /** `[Json]` Creates an evaluated Intersect type */
-export function Intersect(T, options = {}) {
+export function Intersect(T, options) {
     if (T.length === 0)
         return Never(options);
     if (T.length === 1)
-        return CloneType(T[0], options);
+        return CreateType(T[0], options);
     if (T.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
     return IntersectCreate(T, options);

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

@@ -1,17 +1,19 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Intrinsic } from './intrinsic.mjs';
 import { Literal } from '../literal/index.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function MappedIntrinsicPropertyKey(K, M, options) {
     return {
-        [K]: Intrinsic(Literal(K), M, options)
+        [K]: Intrinsic(Literal(K), M, Clone(options))
     };
 }
 // prettier-ignore
 function MappedIntrinsicPropertyKeys(K, M, options) {
-    return K.reduce((Acc, L) => {
+    const result = K.reduce((Acc, L) => {
         return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
     }, {});
+    return result;
 }
 // prettier-ignore
 function MappedIntrinsicProperties(T, M, options) {

package/build/esm/type/intrinsic/intrinsic.mjs

@@ -1,3 +1,4 @@
+import { CreateType } from '../create/type.mjs';
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralExpressionFinite, TemplateLiteralExpressionGenerate } from '../template-literal/index.mjs';
 import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
@@ -58,5 +59,6 @@ export function Intrinsic(schema, mode, options = {}) {
         IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, schema) :
             IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) :
                 IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
-                    schema);
+                    // Default Type
+                    CreateType(schema, options));
 }

package/build/esm/type/iterator/iterator.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 an Iterator type */
-export function Iterator(items, options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Iterator',
-        type: 'Iterator',
-        items: CloneType(items),
-    };
+export function Iterator(items, options) {
+    return CreateType({ [Kind]: 'Iterator', type: 'Iterator', items }, options);
 }

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

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

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

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { KeyOf } from './keyof.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] = KeyOf(K[K2], options);
+        Acc[K2] = KeyOf(K[K2], Clone(options));
     return Acc;
 }
 // prettier-ignore

package/build/esm/type/keyof/keyof.mjs

@@ -1,8 +1,8 @@
+import { CreateType } from '../create/type.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Number } from '../number/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
@@ -13,7 +13,7 @@ export function KeyOfPropertyKeysToRest(T) {
     return T.map(L => L === '[number]' ? Number() : Literal(L));
 }
 /** `[Json]` Creates a KeyOf type */
-export function KeyOf(T, options = {}) {
+export function KeyOf(T, options) {
     if (IsMappedResult(T)) {
         return KeyOfFromMappedResult(T, options);
     }
@@ -21,6 +21,6 @@ export function KeyOf(T, options = {}) {
         const K = KeyOfPropertyKeys(T);
         const S = KeyOfPropertyKeysToRest(K);
         const U = UnionEvaluated(S);
-        return CloneType(U, options);
+        return CreateType(U, options);
     }
 }

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

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Literal type */
-export function Literal(value, options = {}) {
-    return {
-        ...options,
+export function Literal(value, options) {
+    return CreateType({
         [Kind]: 'Literal',
         const: value,
         type: typeof value,
-    };
+    }, options);
 }

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

@@ -1,8 +1,9 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // prettier-ignore
 export function MappedKey(T) {
-    return {
+    return CreateType({
         [Kind]: 'MappedKey',
         keys: T
-    };
+    });
 }

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

@@ -1,8 +1,9 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // prettier-ignore
 export function MappedResult(properties) {
-    return {
+    return CreateType({
         [Kind]: 'MappedResult',
         properties
-    };
+    });
 }

package/build/esm/type/mapped/mapped.mjs

@@ -1,5 +1,4 @@
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 // evaluation types
 import { Array } from '../array/index.mjs';
@@ -93,9 +92,9 @@ export function MappedFunctionReturnType(K, T) {
     return Acc;
 }
 /** `[Json]` Creates a Mapped object type */
-export function Mapped(key, map, options = {}) {
+export function Mapped(key, map, options) {
     const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
     const R = MappedFunctionReturnType(K, RT);
-    return CloneType(Object(R), options);
+    return Object(R, options);
 }

package/build/esm/type/never/never.mjs

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

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

@@ -7,4 +7,4 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
     not: T;
 }
 /** `[Json]` Creates a Not type */
-export declare function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+export declare function Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T>;

package/build/esm/type/not/not.mjs

@@ -1,10 +1,6 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Not type */
-export function Not(schema, options) {
-    return {
-        ...options,
-        [Kind]: 'Not',
-        not: CloneType(schema),
-    };
+export function Not(not, options) {
+    return CreateType({ [Kind]: 'Not', not }, options);
 }

package/build/esm/type/null/null.mjs

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

package/build/esm/type/number/number.mjs

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

package/build/esm/type/object/object.mjs

@@ -1,21 +1,22 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsOptional, IsSchema } from '../guard/kind.mjs';
+import { IsOptional } from '../guard/kind.mjs';
+function RequiredKeys(properties) {
+    const keys = [];
+    for (let key in properties) {
+        if (!IsOptional(properties[key]))
+            keys.push(key);
+    }
+    return keys;
+}
 /** `[Json]` Creates an Object type */
-function _Object(properties, options = {}) {
-    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-    const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]));
-    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-    const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
-    const clonedProperties = {};
-    for (const key of propertyKeys)
-        clonedProperties[key] = CloneType(properties[key]);
-    return (requiredKeys.length > 0
-        ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
-        : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties });
+function _Object(properties, options) {
+    const required = RequiredKeys(properties);
+    const schematic = required.length > 0 ? { [Kind]: 'Object', type: 'object', properties, required } : { [Kind]: 'Object', type: 'object', properties };
+    return CreateType(schematic, options);
 }
 /** `[Json]` Creates an Object type */
 export const Object = _Object;

package/build/esm/type/omit/omit-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 TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
 export {};