@sinclair/typebox 0.32.7 → 0.32.9

package/build/import/index.d.mts

@@ -4,6 +4,8 @@ export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
 export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
 export { CloneType, CloneRest } from './type/clone/type.mjs';
 export { TypeBoxError } from './type/error/index.mjs';
+export { SetComplement, SetDistinct, SetIncludes, SetIntersect, SetIntersectMany, SetIsSubset, SetUnion, SetUnionMany, type TSetComplement, type TSetDistinct, type TSetIncludes, type TSetIntersect, type TSetIntersectMany, type TSetIsSubset, type TSetUnion, type TSetUnionMany, } from './type/sets/index.mjs';
+export { Increment, type TIncrement, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
 export { Any, type TAny } from './type/any/index.mjs';
 export { Array, type TArray, type ArrayOptions } from './type/array/index.mjs';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index.mjs';
@@ -21,7 +23,6 @@ export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/ex
 export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index.mjs';
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index.mjs';
 export { Function, type TFunction } from './type/function/index.mjs';
-export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index.mjs';
 export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromPropertyKeys, type TIndexFromPropertyKey, type TIndexFromMappedKey, type TIndexFromMappedResult, } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
@@ -55,7 +56,7 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index.mjs';
 export { Strict } from './type/strict/index.mjs';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index.mjs';
-export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index.mjs';
+export { Symbol, type TSymbol, type TSymbolValue } from './type/symbol/index.mjs';
 export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TIsTemplateLiteralFinite, } from './type/template-literal/index.mjs';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index.mjs';
 export { Tuple, type TTuple } from './type/tuple/index.mjs';

package/build/import/index.mjs

@@ -6,9 +6,20 @@ export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact,
 export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
 export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
 export { CloneType, CloneRest } from './type/clone/type.mjs';
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
 export { TypeBoxError } from './type/error/index.mjs';
 // ------------------------------------------------------------------
-// Type
+// Sets
+// ------------------------------------------------------------------
+export { SetComplement, SetDistinct, SetIncludes, SetIntersect, SetIntersectMany, SetIsSubset, SetUnion, SetUnionMany, } from './type/sets/index.mjs';
+// ------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------
+export { Increment } from './type/helpers/index.mjs';
+// ------------------------------------------------------------------
+// Types
 // ------------------------------------------------------------------
 export { Any } from './type/any/index.mjs';
 export { Array } from './type/array/index.mjs';
@@ -27,7 +38,6 @@ export { Exclude } from './type/exclude/index.mjs';
 export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck } from './type/extends/index.mjs';
 export { Extract } from './type/extract/index.mjs';
 export { Function } from './type/function/index.mjs';
-export { Increment } from './type/helpers/index.mjs';
 export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';

package/build/import/type/composite/composite.d.mts

@@ -1,13 +1,18 @@
-import type { UnionToTuple, Assert, Ensure, Evaluate } from '../helpers/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import { type TIntersectEvaluated } from '../intersect/index.mjs';
+import { type TIndexFromPropertyKeys } from '../indexed/index.mjs';
+import { type TKeyOfPropertyKeys } from '../keyof/index.mjs';
+import { type TNever } from '../never/index.mjs';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TIntersect } from '../intersect/index.mjs';
-import { type TIndex } from '../indexed/index.mjs';
-type TCompositeKeys<T extends TObject[], Acc extends PropertyKey = never> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? TCompositeKeys<R, Acc | keyof L['properties']> : Acc;
-type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc extends TProperties = {}> = K extends [infer L extends string, ...infer R extends string[]] ? TCompositeIndex<T, R, Acc & {
-    [_ in L]: TIndex<T, [L]>;
-}> : Acc;
-type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect ? Ensure<TObject<TCompositeReduce<T>>> : Ensure<TObject<{}>>;
-/** `[Json]` Creates a Composite object type */
-export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
+import { TSetDistinct } from '../sets/index.mjs';
+type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TCompositeKeys<R, TSetDistinct<[...Acc, ...TKeyOfPropertyKeys<L>]>> : Acc);
+type TFilterNever<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? Acc : TFilterNever<R, [...Acc, L]> : Acc);
+type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TCompositeProperty<R, K, TFilterNever<[...Acc, ...TIndexFromPropertyKeys<L, [K]>]>> : Acc);
+type TCompositeProperties<T extends TSchema[], K extends PropertyKey[], Acc = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TCompositeProperties<T, R, Acc & {
+    [_ in L]: TIntersectEvaluated<TCompositeProperty<T, L>>;
+}> : Acc);
+type TCompositeEvaluate<T extends TSchema[], K extends PropertyKey[] = TCompositeKeys<T>, P extends TProperties = Evaluate<TCompositeProperties<T, K>>, R extends TObject = TObject<P>> = R;
+export type TComposite<T extends TSchema[]> = TCompositeEvaluate<T>;
+export declare function Composite<T extends TSchema[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/import/type/composite/composite.mjs

@@ -1,11 +1,38 @@
-import { Object } from '../object/index.mjs';
-import { Intersect } from '../intersect/index.mjs';
-import { Index } from '../indexed/index.mjs';
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { IndexFromPropertyKeys } from '../indexed/index.mjs';
 import { KeyOfPropertyKeys } from '../keyof/index.mjs';
-/** `[Json]` Creates a Composite object type */
-export function Composite(T, options) {
-    const intersect = Intersect(T, {});
-    const keys = KeyOfPropertyKeys(intersect);
-    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {});
-    return Object(properties, options);
+import { Object } from '../object/index.mjs';
+import { SetDistinct } from '../sets/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsNever } from '../guard/type.mjs';
+// prettier-ignore
+function CompositeKeys(T) {
+    return T.reduce((Acc, L) => {
+        return SetDistinct([...Acc, ...KeyOfPropertyKeys(L)]);
+    }, []);
+}
+// prettier-ignore
+function FilterNever(T) {
+    return T.filter(L => !IsNever(L));
+}
+// prettier-ignore
+function CompositeProperty(T, K) {
+    return T.reduce((Acc, L) => {
+        return FilterNever([...Acc, ...IndexFromPropertyKeys(L, [K])]);
+    }, []);
+}
+// prettier-ignore
+function CompositeProperties(T, K) {
+    return K.reduce((Acc, L) => {
+        return { ...Acc, [L]: IntersectEvaluated(CompositeProperty(T, L)) };
+    }, {});
+}
+// prettier-ignore
+export function Composite(T, options = {}) {
+    const K = CompositeKeys(T);
+    const P = CompositeProperties(T, K);
+    const R = Object(P, options);
+    return R;
 }

package/build/import/type/helpers/helpers.d.mts

@@ -33,9 +33,9 @@ type IncrementBase = {
 type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
 type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
 type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
-export type Increment<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+export type TIncrement<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
 /** Increments the given string value + 1 */
-export declare function Increment<T extends string>(T: T): Increment<T>;
+export declare function Increment<T extends string>(T: T): TIncrement<T>;
 export type AssertProperties<T> = T extends TProperties ? T : TProperties;
 export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
 export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;

package/build/import/type/keyof/keyof-property-keys.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../schema/index.mjs';
-import { type ZeroString, type UnionToTuple, Increment } from '../helpers/index.mjs';
+import { type ZeroString, type UnionToTuple, type TIncrement } from '../helpers/index.mjs';
 import type { TRecursive } from '../recursive/index.mjs';
 import type { TIntersect } from '../intersect/index.mjs';
 import type { TUnion } from '../union/index.mjs';
@@ -8,16 +8,14 @@ import type { TArray } from '../array/index.mjs';
 import type { TObject, TProperties } from '../object/index.mjs';
 import { type TSetUnionMany, type TSetIntersectMany } from '../sets/index.mjs';
 type TFromRest<T extends TSchema[], Acc extends PropertyKey[][] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TKeyOfPropertyKeys<L>]> : Acc);
-type FromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<C>> = R;
-declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
-type FromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
-declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
-type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, Increment<I>, [...Acc, I]> : Acc;
+type TFromIntersect<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetUnionMany<C>> = R;
+type TFromUnion<T extends TSchema[], C extends PropertyKey[][] = TFromRest<T>, R extends PropertyKey[] = TSetIntersectMany<C>> = R;
+type TFromTuple<T extends TSchema[], I extends string = ZeroString, Acc extends PropertyKey[] = []> = T extends [infer _ extends TSchema, ...infer R extends TSchema[]] ? TFromTuple<R, TIncrement<I>, [...Acc, I]> : Acc;
 type TFromArray<_ extends TSchema> = ([
     '[number]'
 ]);
 type TFromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
-export type TKeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? TFromTuple<S> : T extends TArray<infer S> ? TFromArray<S> : T extends TObject<infer S> ? TFromProperties<S> : [
+export type TKeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? TKeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? TFromIntersect<S> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TTuple<infer S> ? TFromTuple<S> : T extends TArray<infer S> ? TFromArray<S> : T extends TObject<infer S> ? TFromProperties<S> : [
 ]);
 /** Returns a tuple of PropertyKeys derived from the given TSchema. */
 export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): TKeyOfPropertyKeys<T>;

package/build/import/type/sets/set.d.mts

@@ -1,24 +1,28 @@
 export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TSetIncludes<R, S> : false);
-/** Returns true if element S is in the set of T */
+/** Returns true if element right is in the set of left */
 export declare function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S>;
-export type SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? SetIsSubset<R, S> : false : true);
-/** Returns true if T is a subset of S */
-export declare function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): SetIsSubset<T, S>;
+export type TSetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIsSubset<R, S> : false : true);
+/** Returns true if left is a subset of right */
+export declare function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIsSubset<T, S>;
 export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<Acc, L> extends false ? TSetDistinct<R, [...Acc, L]> : TSetDistinct<R, [...Acc]> : Acc;
 /** Returns a distinct set of elements */
 export declare function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T>;
-export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIntersect<R, S, [L, ...Acc]> : TSetIntersect<R, S, [...Acc]> : Acc);
+export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIntersect<R, S, [...Acc, L]> : TSetIntersect<R, S, [...Acc]> : Acc);
 /** Returns the Intersect of the given sets */
 export declare function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIntersect<T, S>;
-export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetUnion<R, S, [...Acc, L]> : Acc);
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[]> = ([
+    ...T,
+    ...S
+]);
 /** Returns the Union of the given sets */
 export declare function SetUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetUnion<T, S>;
 export type TSetComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetComplement<R, S, [...Acc]> : TSetComplement<R, S, [...Acc, L]> : Acc);
 /** Returns the Complement by omitting elements in T that are in S */
 export declare function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetComplement<T, S>;
-export type TSetIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectMany<R, TSetIntersect<Acc, L>> : Acc);
-/** Returns the Intersect of multiple sets */
+type TSetIntersectManyResolve<T extends PropertyKey[][], Acc extends PropertyKey[]> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectManyResolve<R, TSetIntersect<Acc, L>> : Acc);
+export type TSetIntersectMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectManyResolve<R, L> : []);
 export declare function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetIntersectMany<T>;
 export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetUnionMany<R, TSetUnion<Acc, L>> : Acc);
 /** Returns the Union of multiple sets */
 export declare function SetUnionMany<T extends PropertyKey[][]>(T: [...T]): TSetUnionMany<T>;
+export {};

package/build/import/type/sets/set.mjs

@@ -1,9 +1,9 @@
-/** Returns true if element S is in the set of T */
+/** Returns true if element right is in the set of left */
 // prettier-ignore
 export function SetIncludes(T, S) {
     return T.includes(S);
 }
-/** Returns true if T is a subset of S */
+/** Returns true if left is a subset of right */
 export function SetIsSubset(T, S) {
     return T.every((L) => SetIncludes(S, L));
 }
@@ -24,10 +24,20 @@ export function SetUnion(T, S) {
 export function SetComplement(T, S) {
     return T.filter(L => !S.includes(L));
 }
-/** Returns the Intersect of multiple sets */
+// prettier-ignore
+function SetIntersectManyResolve(T, Init) {
+    return T.reduce((Acc, L) => {
+        return SetIntersect(Acc, L);
+    }, Init);
+}
 // prettier-ignore
 export function SetIntersectMany(T) {
-    return (T.length === 1 ? T[0] : T.reduce((Acc, L) => [...SetIntersect(Acc, L)], []));
+    return (T.length === 1
+        ? T[0]
+        // Use left to initialize the accumulator for resolve
+        : T.length > 1
+            ? SetIntersectManyResolve(T.slice(1), T[0])
+            : []);
 }
 /** Returns the Union of multiple sets */
 export function SetUnionMany(T) {

package/build/import/type/type/json.d.mts

@@ -71,7 +71,7 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Intrinsic function to Capitalize LiteralString types */
     Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
     /** `[Json]` Creates a Composite object type */
-    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
+    Composite<T extends TSchema[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[JavaScript]` Creates a readonly const type from the given value. */
     Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
     /** `[Json]` Creates a dereferenced type */

package/build/import/type/type/json.mjs

@@ -83,8 +83,8 @@ export class JsonTypeBuilder {
         return Capitalize(schema, options);
     }
     /** `[Json]` Creates a Composite object type */
-    Composite(objects, options) {
-        return Composite(objects, options); // (error) TS 5.4.0-dev - review TComposite implementation
+    Composite(schemas, options) {
+        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 = {}) {

package/build/import/value/cast/cast.mjs

@@ -53,7 +53,7 @@ function SelectUnion(union, references, value) {
 }
 function CastUnion(union, references, value) {
     if ('default' in union) {
-        return union.default;
+        return typeof value === 'function' ? union.default : Clone(union.default);
     }
     else {
         const schema = SelectUnion(union, references, value);

package/build/import/value/create/create.mjs

@@ -1,5 +1,6 @@
 import { HasPropertyKey, IsString } from '../guard/index.mjs';
 import { Check } from '../check/index.mjs';
+import { Clone } from '../clone/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../../type/template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index.mjs';
@@ -17,11 +18,17 @@ export class ValueCreateError extends TypeBoxError {
     }
 }
 // ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+function FromDefault(value) {
+    return typeof value === 'function' ? value : Clone(value);
+}
+// ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
 function FromAny(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return {};
@@ -35,7 +42,7 @@ function FromArray(schema, references) {
         throw new ValueCreateError(schema, 'Array with the contains constraint requires a default value');
     }
     else if ('default' in schema) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (schema.minItems !== undefined) {
         return Array.from({ length: schema.minItems }).map((item) => {
@@ -48,7 +55,7 @@ function FromArray(schema, references) {
 }
 function FromAsyncIterator(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return (async function* () { })();
@@ -56,7 +63,7 @@ function FromAsyncIterator(schema, references) {
 }
 function FromBigInt(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return BigInt(0);
@@ -64,7 +71,7 @@ function FromBigInt(schema, references) {
 }
 function FromBoolean(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return false;
@@ -72,7 +79,7 @@ function FromBoolean(schema, references) {
 }
 function FromConstructor(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         const value = Visit(schema.returns, references);
@@ -94,7 +101,7 @@ function FromConstructor(schema, references) {
 }
 function FromDate(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (schema.minimumTimestamp !== undefined) {
         return new Date(schema.minimumTimestamp);
@@ -105,7 +112,7 @@ function FromDate(schema, references) {
 }
 function FromFunction(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return () => Visit(schema.returns, references);
@@ -113,7 +120,7 @@ function FromFunction(schema, references) {
 }
 function FromInteger(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (schema.minimum !== undefined) {
         return schema.minimum;
@@ -124,7 +131,7 @@ function FromInteger(schema, references) {
 }
 function FromIntersect(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         // --------------------------------------------------------------
@@ -145,7 +152,7 @@ function FromIntersect(schema, references) {
 }
 function FromIterator(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return (function* () { })();
@@ -153,7 +160,7 @@ function FromIterator(schema, references) {
 }
 function FromLiteral(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return schema.const;
@@ -161,7 +168,7 @@ function FromLiteral(schema, references) {
 }
 function FromNever(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         throw new ValueCreateError(schema, 'Never types cannot be created. Consider using a default value.');
@@ -169,7 +176,7 @@ function FromNever(schema, references) {
 }
 function FromNot(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         throw new ValueCreateError(schema, 'Not types must have a default value');
@@ -177,7 +184,7 @@ function FromNot(schema, references) {
 }
 function FromNull(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return null;
@@ -185,7 +192,7 @@ function FromNull(schema, references) {
 }
 function FromNumber(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (schema.minimum !== undefined) {
         return schema.minimum;
@@ -196,11 +203,11 @@ function FromNumber(schema, references) {
 }
 function FromObject(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         const required = new Set(schema.required);
-        return (schema.default ||
+        return (FromDefault(schema.default) ||
             Object.entries(schema.properties).reduce((acc, [key, schema]) => {
                 return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc };
             }, {}));
@@ -208,7 +215,7 @@ function FromObject(schema, references) {
 }
 function FromPromise(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return Promise.resolve(Visit(schema.item, references));
@@ -217,7 +224,7 @@ function FromPromise(schema, references) {
 function FromRecord(schema, references) {
     const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0];
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (!(keyPattern === PatternStringExact || keyPattern === PatternNumberExact)) {
         const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
@@ -231,7 +238,7 @@ function FromRecord(schema, references) {
 }
 function FromRef(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return Visit(Deref(schema, references), references);
@@ -239,7 +246,7 @@ function FromRef(schema, references) {
 }
 function FromRegExp(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         throw new ValueCreateError(schema, 'RegExp types cannot be created. Consider using a default value.');
@@ -251,7 +258,7 @@ function FromString(schema, references) {
             throw new ValueCreateError(schema, 'String types with patterns must specify a default value');
         }
         else {
-            return schema.default;
+            return FromDefault(schema.default);
         }
     }
     else if (schema.format !== undefined) {
@@ -259,12 +266,12 @@ function FromString(schema, references) {
             throw new ValueCreateError(schema, 'String types with formats must specify a default value');
         }
         else {
-            return schema.default;
+            return FromDefault(schema.default);
         }
     }
     else {
         if (HasPropertyKey(schema, 'default')) {
-            return schema.default;
+            return FromDefault(schema.default);
         }
         else if (schema.minLength !== undefined) {
             // prettier-ignore
@@ -277,7 +284,7 @@ function FromString(schema, references) {
 }
 function FromSymbol(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if ('value' in schema) {
         return Symbol.for(schema.value);
@@ -288,7 +295,7 @@ function FromSymbol(schema, references) {
 }
 function FromTemplateLiteral(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     if (!IsTemplateLiteralFinite(schema))
         throw new ValueCreateError(schema, 'Can only create template literals that produce a finite variants. Consider using a default value.');
@@ -299,7 +306,7 @@ function FromThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
         throw new ValueCreateError(schema, 'Cannot create recursive type as it appears possibly infinite. Consider using a default.');
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return Visit(Deref(schema, references), references);
@@ -307,7 +314,7 @@ function FromThis(schema, references) {
 }
 function FromTuple(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     if (schema.items === undefined) {
         return [];
@@ -318,7 +325,7 @@ function FromTuple(schema, references) {
 }
 function FromUndefined(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return undefined;
@@ -326,7 +333,7 @@ function FromUndefined(schema, references) {
 }
 function FromUnion(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (schema.anyOf.length === 0) {
         throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
@@ -337,7 +344,7 @@ function FromUnion(schema, references) {
 }
 function FromUint8Array(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else if (schema.minByteLength !== undefined) {
         return new Uint8Array(schema.minByteLength);
@@ -348,7 +355,7 @@ function FromUint8Array(schema, references) {
 }
 function FromUnknown(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return {};
@@ -356,7 +363,7 @@ function FromUnknown(schema, references) {
 }
 function FromVoid(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         return void 0;
@@ -364,7 +371,7 @@ function FromVoid(schema, references) {
 }
 function FromKind(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
-        return schema.default;
+        return FromDefault(schema.default);
     }
     else {
         throw new Error('User defined types must specify a default value');

package/build/require/index.d.ts

@@ -4,6 +4,8 @@ export { TypeRegistry, FormatRegistry } from './type/registry/index';
 export { TypeGuard, ValueGuard } from './type/guard/index';
 export { CloneType, CloneRest } from './type/clone/type';
 export { TypeBoxError } from './type/error/index';
+export { SetComplement, SetDistinct, SetIncludes, SetIntersect, SetIntersectMany, SetIsSubset, SetUnion, SetUnionMany, type TSetComplement, type TSetDistinct, type TSetIncludes, type TSetIntersect, type TSetIntersectMany, type TSetIsSubset, type TSetUnion, type TSetUnionMany, } from './type/sets/index';
+export { Increment, type TIncrement, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
 export { Any, type TAny } from './type/any/index';
 export { Array, type TArray, type ArrayOptions } from './type/array/index';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
@@ -21,7 +23,6 @@ export { Exclude, type TExclude, type TExcludeFromMappedResult } from './type/ex
 export { Extends, ExtendsCheck, ExtendsResult, ExtendsUndefinedCheck, type TExtends, type ExtendsFromMappedResult, type ExtendsFromMappedKey } from './type/extends/index';
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
-export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
 export { Index, IndexPropertyKeys, IndexFromPropertyKeys, IndexFromPropertyKey, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromPropertyKeys, type TIndexFromPropertyKey, type TIndexFromMappedKey, type TIndexFromMappedResult, } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
@@ -55,7 +56,7 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode, type TDecodeType, type TDecodeRest, type TDecodeProperties } from './type/static/index';
 export { Strict } from './type/strict/index';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
-export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index';
+export { Symbol, type TSymbol, type TSymbolValue } from './type/symbol/index';
 export { TemplateLiteral, TemplateLiteralSyntax, TemplateLiteralGenerate, TemplateLiteralParse, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralExpressionGenerate, IsTemplateLiteralExpressionFinite, type TTemplateLiteral, type TTemplateLiteralSyntax, type TTemplateLiteralGenerate, type TTemplateLiteralKind, type TIsTemplateLiteralFinite, } from './type/template-literal/index';
 export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index';
 export { Tuple, type TTuple } from './type/tuple/index';