@sinclair/typebox 0.32.35 → 0.33.0

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.mjs

@@ -1,3 +1,4 @@
+import { CreateType } from '../create/type.mjs';
 import { Object } from '../object/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Union } from '../union/index.mjs';
@@ -5,7 +6,6 @@ import { IsTemplateLiteralFinite } from '../template-literal/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
 // ------------------------------------------------------------------
@@ -19,12 +19,11 @@ import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsT
 // ------------------------------------------------------------------
 // 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

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);
 }

package/build/esm/type/type/javascript.mjs

@@ -19,19 +19,19 @@ import { Void } from '../void/index.mjs';
 /** JavaScript Type Builder with Static Resolution for TypeScript */
 export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options = {}) {
+    AsyncIterator(items, options) {
         return AsyncIterator(items, options);
     }
     /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options = {}) {
+    Awaited(schema, options) {
         return Awaited(schema, options);
     }
     /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options = {}) {
+    BigInt(options) {
         return BigInt(options);
     }
     /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
+    ConstructorParameters(schema, options) {
         return ConstructorParameters(schema, options);
     }
     /** `[JavaScript]` Creates a Constructor type */
@@ -47,27 +47,27 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
         return FunctionType(parameters, returns, options);
     }
     /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options = {}) {
+    InstanceType(schema, options) {
         return InstanceType(schema, options);
     }
     /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options = {}) {
+    Iterator(items, options) {
         return Iterator(items, options);
     }
     /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
+    Parameters(schema, options) {
         return Parameters(schema, options);
     }
     /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options = {}) {
+    Promise(item, options) {
         return Promise(item, options);
     }
     /** `[JavaScript]` Creates a RegExp type */
-    RegExp(unresolved, options = {}) {
+    RegExp(unresolved, options) {
         return RegExp(unresolved, options);
     }
     /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options = {}) {
+    ReturnType(schema, options) {
         return ReturnType(schema, options);
     }
     /** `[JavaScript]` Creates a Symbol type */
@@ -75,15 +75,15 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
         return Symbol(options);
     }
     /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options = {}) {
+    Undefined(options) {
         return Undefined(options);
     }
     /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
+    Uint8Array(options) {
         return Uint8Array(options);
     }
     /** `[JavaScript]` Creates a Void type */
-    Void(options = {}) {
+    Void(options) {
         return Void(options);
     }
 }

package/build/esm/type/type/json.mjs

@@ -67,19 +67,19 @@ export class JsonTypeBuilder {
     // Types
     // ------------------------------------------------------------------------
     /** `[Json]` Creates an Any type */
-    Any(options = {}) {
+    Any(options) {
         return Any(options);
     }
     /** `[Json]` Creates an Array type */
-    Array(schema, options = {}) {
+    Array(schema, options) {
         return Array(schema, options);
     }
     /** `[Json]` Creates a Boolean type */
-    Boolean(options = {}) {
+    Boolean(options) {
         return Boolean(options);
     }
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize(schema, options = {}) {
+    Capitalize(schema, options) {
         return Capitalize(schema, options);
     }
     /** `[Json]` Creates a Composite object type */
@@ -87,7 +87,7 @@ export class JsonTypeBuilder {
         return Composite(schemas, options); // (error) TS 5.4.0-dev - review TComposite implementation
     }
     /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const(value, options = {}) {
+    Const(value, options) {
         return Const(value, options);
     }
     /** `[Json]` Creates a dereferenced type */
@@ -95,51 +95,51 @@ export class JsonTypeBuilder {
         return Deref(schema, references);
     }
     /** `[Json]` Creates a Enum type */
-    Enum(item, options = {}) {
+    Enum(item, options) {
         return Enum(item, options);
     }
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude(unionType, excludedMembers, options = {}) {
+    Exclude(unionType, excludedMembers, options) {
         return Exclude(unionType, excludedMembers, options);
     }
     /** `[Json]` Creates a Conditional type */
-    Extends(L, R, T, F, options = {}) {
+    Extends(L, R, T, F, options) {
         return Extends(L, R, T, F, options);
     }
     /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract(type, union, options = {}) {
+    Extract(type, union, options) {
         return Extract(type, union, options);
     }
     /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options = {}) {
+    Index(schema, unresolved, options) {
         return Index(schema, unresolved, options);
     }
     /** `[Json]` Creates an Integer type */
-    Integer(options = {}) {
+    Integer(options) {
         return Integer(options);
     }
     /** `[Json]` Creates an Intersect type */
-    Intersect(T, options = {}) {
+    Intersect(T, options) {
         return Intersect(T, options);
     }
     /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options = {}) {
+    KeyOf(schema, options) {
         return KeyOf(schema, options);
     }
     /** `[Json]` Creates a Literal type */
-    Literal(value, options = {}) {
+    Literal(value, options) {
         return Literal(value, options);
     }
     /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options = {}) {
+    Lowercase(schema, options) {
         return Lowercase(schema, options);
     }
     /** `[Json]` Creates a Mapped object type */
-    Mapped(key, map, options = {}) {
+    Mapped(key, map, options) {
         return Mapped(key, map, options);
     }
     /** `[Json]` Creates a Never type */
-    Never(options = {}) {
+    Never(options) {
         return Never(options);
     }
     /** `[Json]` Creates a Not type */
@@ -147,43 +147,43 @@ export class JsonTypeBuilder {
         return Not(schema, options);
     }
     /** `[Json]` Creates a Null type */
-    Null(options = {}) {
+    Null(options) {
         return Null(options);
     }
     /** `[Json]` Creates a Number type */
-    Number(options = {}) {
+    Number(options) {
         return Number(options);
     }
     /** `[Json]` Creates an Object type */
-    Object(properties, options = {}) {
+    Object(properties, options) {
         return Object(properties, options);
     }
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options = {}) {
+    Omit(schema, unresolved, options) {
         return Omit(schema, unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options = {}) {
+    Partial(schema, options) {
         return Partial(schema, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options = {}) {
+    Pick(schema, unresolved, options) {
         return Pick(schema, unresolved, options);
     }
     /** `[Json]` Creates a Record type */
-    Record(key, schema, options = {}) {
+    Record(key, schema, options) {
         return Record(key, schema, options);
     }
     /** `[Json]` Creates a Recursive type */
-    Recursive(callback, options = {}) {
+    Recursive(callback, options) {
         return Recursive(callback, options);
     }
     /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options = {}) {
+    Ref(unresolved, options) {
         return Ref(unresolved, options);
     }
     /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options = {}) {
+    Required(schema, options) {
         return Required(schema, options);
     }
     /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
@@ -191,11 +191,11 @@ export class JsonTypeBuilder {
         return Rest(schema);
     }
     /** `[Json]` Creates a String type */
-    String(options = {}) {
+    String(options) {
         return String(options);
     }
     /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral(unresolved, options = {}) {
+    TemplateLiteral(unresolved, options) {
         return TemplateLiteral(unresolved, options);
     }
     /** `[Json]` Creates a Transform type */
@@ -203,27 +203,27 @@ export class JsonTypeBuilder {
         return Transform(schema);
     }
     /** `[Json]` Creates a Tuple type */
-    Tuple(items, options = {}) {
+    Tuple(items, options) {
         return Tuple(items, options);
     }
     /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options = {}) {
+    Uncapitalize(schema, options) {
         return Uncapitalize(schema, options);
     }
     /** `[Json]` Creates a Union type */
-    Union(schemas, options = {}) {
+    Union(schemas, options) {
         return Union(schemas, options);
     }
     /** `[Json]` Creates an Unknown type */
-    Unknown(options = {}) {
+    Unknown(options) {
         return Unknown(options);
     }
     /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe(options = {}) {
+    Unsafe(options) {
         return Unsafe(options);
     }
     /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase(schema, options = {}) {
+    Uppercase(schema, options) {
         return Uppercase(schema, options);
     }
 }

package/build/esm/type/uint8array/uint8array.mjs

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

package/build/esm/type/undefined/undefined.mjs

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

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

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

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

@@ -1,5 +1,5 @@
-import { CloneRest } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 export function UnionCreate(T, options) {
-    return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) };
+    return CreateType({ [Kind]: 'Union', anyOf: T }, options);
 }

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

@@ -1,5 +1,5 @@
+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 { Never } from '../never/index.mjs';
 import { Optional } from '../optional/index.mjs';
@@ -27,9 +27,9 @@ function ResolveUnion(T, options) {
         : UnionCreate(RemoveOptionalFromRest(T), options));
 }
 /** `[Json]` Creates an evaluated Union type */
-export function UnionEvaluated(T, options = {}) {
+export function UnionEvaluated(T, options) {
     // prettier-ignore
     return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CloneType(T[0], options) :
+        T.length === 1 ? CreateType(T[0], options) :
             ResolveUnion(T, options));
 }

package/build/esm/type/union/union.mjs

@@ -1,10 +1,10 @@
 import { Never } from '../never/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { UnionCreate } from './union-create.mjs';
 /** `[Json]` Creates a Union type */
-export function Union(T, options = {}) {
+export function Union(T, options) {
     // prettier-ignore
     return (T.length === 0 ? Never(options) :
-        T.length === 1 ? CloneType(T[0], options) :
+        T.length === 1 ? CreateType(T[0], options) :
             UnionCreate(T, options));
 }

package/build/esm/type/unknown/unknown.mjs

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

package/build/esm/type/unsafe/unsafe.mjs

@@ -1,8 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
 export function Unsafe(options = {}) {
-    return {
-        ...options,
-        [Kind]: options[Kind] ?? 'Unsafe',
-    };
+    return CreateType({ [Kind]: options[Kind] ?? 'Unsafe' }, options);
 }

package/build/esm/type/void/void.mjs

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