@sinclair/typebox 0.33.3 → 0.33.5

package/build/cjs/value/transform/decode.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
 exports.TransformDecode = TransformDecode;
+const policy_1 = require("../../system/policy");
 const index_1 = require("../../type/symbols/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/keyof/index");
@@ -61,7 +62,7 @@ function FromArray(schema, references, path, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
-    if (!(0, index_6.IsStandardObject)(value) || (0, index_6.IsValueType)(value))
+    if (!(0, index_6.IsObject)(value) || (0, index_6.IsValueType)(value))
         return Default(schema, path, value);
     const knownEntries = (0, index_3.KeyOfPropertyEntries)(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -87,14 +88,22 @@ function FromNot(schema, references, path, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, path, value) {
-    if (!(0, index_6.IsStandardObject)(value))
+    if (!(0, index_6.IsObject)(value))
         return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...value };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!(0, index_6.HasPropertyKey)(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, type_1.IsUndefined)(schema.properties[key]) ||
+            policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // decode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return Default(schema, path, knownProperties);
     }
@@ -109,7 +118,7 @@ function FromObject(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
-    if (!(0, index_6.IsStandardObject)(value))
+    if (!(0, index_6.IsObject)(value))
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -157,9 +166,13 @@ function FromUnion(schema, references, path, value) {
     }
     return Default(schema, path, value);
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references, path, value) {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[index_1.Kind]) {
         case 'Array':

package/build/cjs/value/transform/encode.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncodeError = exports.TransformEncodeCheckError = void 0;
 exports.TransformEncode = TransformEncode;
+const policy_1 = require("../../system/policy");
 const index_1 = require("../../type/symbols/index");
 const index_2 = require("../../type/error/index");
 const index_3 = require("../../type/keyof/index");
@@ -62,7 +63,7 @@ function FromArray(schema, references, path, value) {
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!(0, index_6.IsStandardObject)(value) || (0, index_6.IsValueType)(value))
+    if (!(0, index_6.IsObject)(value) || (0, index_6.IsValueType)(value))
         return defaulted;
     const knownEntries = (0, index_3.KeyOfPropertyEntries)(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -90,14 +91,22 @@ function FromNot(schema, references, path, value) {
 // prettier-ignore
 function FromObject(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!(0, index_6.IsStandardObject)(defaulted))
+    if (!(0, index_6.IsObject)(defaulted))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...defaulted };
-    for (const key of knownKeys)
-        if (key in knownProperties) {
-            knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-        }
+    for (const key of knownKeys) {
+        if (!(0, index_6.HasPropertyKey)(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, type_1.IsUndefined)(schema.properties[key]) ||
+            policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // encode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
         return knownProperties;
     }
@@ -113,7 +122,7 @@ function FromObject(schema, references, path, value) {
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!(0, index_6.IsStandardObject)(value))
+    if (!(0, index_6.IsObject)(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -123,7 +132,7 @@ function FromRecord(schema, references, path, value) {
             knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
         }
     if (!(0, type_1.IsSchema)(schema.additionalProperties)) {
-        return Default(schema, path, knownProperties);
+        return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
@@ -169,9 +178,13 @@ function FromUnion(schema, references, path, value) {
     }
     return Default(schema, path, value);
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references, path, value) {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[index_1.Kind]) {
         case 'Array':

package/build/cjs/value/transform/has.js

@@ -76,9 +76,13 @@ function FromTuple(schema, references) {
 function FromUnion(schema, references) {
     return (0, type_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references) {
-    const references_ = (0, index_3.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_3.IsString)(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     if (schema.$id && visited.has(schema.$id))
         return false;

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

@@ -3,6 +3,10 @@ import { Edit } from '../delta/index';
 import { ValueErrorIterator } from '../../errors/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index';
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export declare function Assert<T extends TSchema, R = Static<T>>(schema: T, references: TSchema[], value: unknown): asserts value is R;
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export declare function Assert<T extends TSchema, R = Static<T>>(schema: T, value: unknown): asserts value is R;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
@@ -19,9 +23,9 @@ export declare function Check<T extends TSchema>(schema: T, value: unknown): val
 export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean(schema: TSchema, value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, value: unknown): unknown;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
@@ -37,6 +41,10 @@ export declare function Default(schema: TSchema, value: unknown): unknown;
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
 /** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
 /** Returns an iterator for each error in this value. */

package/build/cjs/value/value/value.js

@@ -1,6 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assert = Assert;
 exports.Cast = Cast;
 exports.Create = Create;
 exports.Check = Check;
@@ -10,6 +11,7 @@ exports.Clone = Clone;
 exports.Decode = Decode;
 exports.Default = Default;
 exports.Encode = Encode;
+exports.Parse = Parse;
 exports.Errors = Errors;
 exports.Equal = Equal;
 exports.Diff = Diff;
@@ -17,41 +19,47 @@ exports.Hash = Hash;
 exports.Patch = Patch;
 exports.Mutate = Mutate;
 const index_1 = require("../transform/index");
-const index_2 = require("../mutate/index");
-const index_3 = require("../hash/index");
-const index_4 = require("../equal/index");
-const index_5 = require("../cast/index");
-const index_6 = require("../clone/index");
-const index_7 = require("../convert/index");
-const index_8 = require("../create/index");
-const index_9 = require("../clean/index");
-const index_10 = require("../check/index");
-const index_11 = require("../default/index");
-const index_12 = require("../delta/index");
-const index_13 = require("../../errors/index");
+const index_2 = require("../assert/index");
+const index_3 = require("../mutate/index");
+const index_4 = require("../hash/index");
+const index_5 = require("../equal/index");
+const index_6 = require("../cast/index");
+const index_7 = require("../clone/index");
+const index_8 = require("../convert/index");
+const index_9 = require("../create/index");
+const index_10 = require("../clean/index");
+const index_11 = require("../check/index");
+const index_12 = require("../parse/index");
+const index_13 = require("../default/index");
+const index_14 = require("../delta/index");
+const index_15 = require("../../errors/index");
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+function Assert(...args) {
+    return index_2.Assert.apply(index_2.Assert, args);
+}
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 function Cast(...args) {
-    return index_5.Cast.apply(index_5.Cast, args);
+    return index_6.Cast.apply(index_6.Cast, args);
 }
 /** Creates a value from the given type */
 function Create(...args) {
-    return index_8.Create.apply(index_8.Create, args);
+    return index_9.Create.apply(index_9.Create, args);
 }
 /** Returns true if the value matches the given type */
 function Check(...args) {
-    return index_10.Check.apply(index_10.Check, args);
+    return index_11.Check.apply(index_11.Check, args);
 }
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 function Clean(...args) {
-    return index_9.Clean.apply(index_9.Clean, args);
+    return index_10.Clean.apply(index_10.Clean, args);
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 function Convert(...args) {
-    return index_7.Convert.apply(index_7.Convert, args);
+    return index_8.Convert.apply(index_8.Convert, args);
 }
 /** Returns a structural clone of the given value */
 function Clone(value) {
-    return (0, index_6.Clone)(value);
+    return (0, index_7.Clone)(value);
 }
 /** Decodes a value or throws if error */
 function Decode(...args) {
@@ -62,7 +70,7 @@ function Decode(...args) {
 }
 /** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 function Default(...args) {
-    return index_11.Default.apply(index_11.Default, args);
+    return index_13.Default.apply(index_13.Default, args);
 }
 /** Encodes a value or throws if error */
 function Encode(...args) {
@@ -72,27 +80,31 @@ function Encode(...args) {
         throw new index_1.TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
     return encoded;
 }
+/** Parses a value or throws an `AssertError` if invalid. */
+function Parse(...args) {
+    return index_12.Parse.apply(index_12.Parse, args);
+}
 /** Returns an iterator for each error in this value. */
 function Errors(...args) {
-    return index_13.Errors.apply(index_13.Errors, args);
+    return index_15.Errors.apply(index_15.Errors, args);
 }
 /** Returns true if left and right values are structurally equal */
 function Equal(left, right) {
-    return (0, index_4.Equal)(left, right);
+    return (0, index_5.Equal)(left, right);
 }
 /** Returns edits to transform the current value into the next value */
 function Diff(current, next) {
-    return (0, index_12.Diff)(current, next);
+    return (0, index_14.Diff)(current, next);
 }
 /** Returns a FNV1A-64 non cryptographic hash of the given value */
 function Hash(value) {
-    return (0, index_3.Hash)(value);
+    return (0, index_4.Hash)(value);
 }
 /** Returns a new value with edits applied to the given value */
 function Patch(current, edits) {
-    return (0, index_12.Patch)(current, edits);
+    return (0, index_14.Patch)(current, edits);
 }
 /** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 function Mutate(current, next) {
-    (0, index_2.Mutate)(current, next);
+    (0, index_3.Mutate)(current, next);
 }

package/build/esm/compiler/compiler.d.mts

@@ -17,9 +17,9 @@ export declare class TypeCheck<T extends TSchema> {
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Static<T>;
     /** Decodes a value or throws if error */
-    Decode(value: unknown): StaticDecode<T>;
+    Decode<R = StaticDecode<T>>(value: unknown): R;
     /** Encodes a value or throws if error */
-    Encode(value: unknown): StaticEncode<T>;
+    Encode<R = StaticEncode<T>>(value: unknown): R;
 }
 export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/esm/compiler/compiler.mjs

@@ -44,7 +44,7 @@ export class TypeCheck {
     Decode(value) {
         if (!this.checkFunc(value))
             throw new TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
-        return this.hasTransform ? TransformDecode(this.schema, this.references, value) : value;
+        return (this.hasTransform ? TransformDecode(this.schema, this.references, value) : value);
     }
     /** Encodes a value or throws if error */
     Encode(value) {

package/build/esm/system/policy.d.mts

@@ -16,14 +16,14 @@ export declare namespace TypeSystemPolicy {
     let AllowNaN: boolean;
     /** Sets whether `null` should validate for void types. The default is `false` */
     let AllowNullVoid: boolean;
-    /** Asserts this value using the ExactOptionalPropertyTypes policy */
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
-    /** Asserts this value using the AllowArrayObjects policy */
+    /** Checks this value using the AllowArrayObjects policy */
     function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
-    /** Asserts this value as a record using the AllowArrayObjects policy */
+    /** Checks this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
-    /** Asserts this value using the AllowNaN policy */
+    /** Checks this value using the AllowNaN policy */
     function IsNumberLike(value: unknown): value is number;
-    /** Asserts this value using the AllowVoidNull policy */
+    /** Checks this value using the AllowVoidNull policy */
     function IsVoidLike(value: unknown): value is void;
 }

package/build/esm/system/policy.mjs

@@ -24,28 +24,28 @@ export var TypeSystemPolicy;
     TypeSystemPolicy.AllowNaN = false;
     /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystemPolicy.AllowNullVoid = false;
-    /** Asserts this value using the ExactOptionalPropertyTypes policy */
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value, key) {
         return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
     }
     TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
-    /** Asserts this value using the AllowArrayObjects policy */
+    /** Checks this value using the AllowArrayObjects policy */
     function IsObjectLike(value) {
         const isObject = IsObject(value);
         return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray(value);
     }
     TypeSystemPolicy.IsObjectLike = IsObjectLike;
-    /** Asserts this value as a record using the AllowArrayObjects policy */
+    /** Checks this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value) {
         return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
     }
     TypeSystemPolicy.IsRecordLike = IsRecordLike;
-    /** Asserts this value using the AllowNaN policy */
+    /** Checks this value using the AllowNaN policy */
     function IsNumberLike(value) {
         return TypeSystemPolicy.AllowNaN ? IsNumber(value) : Number.isFinite(value);
     }
     TypeSystemPolicy.IsNumberLike = IsNumberLike;
-    /** Asserts this value using the AllowVoidNull policy */
+    /** Checks this value using the AllowVoidNull policy */
     function IsVoidLike(value) {
         const isUndefined = IsUndefined(value);
         return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;

package/build/esm/value/assert/assert.d.mts

@@ -0,0 +1,15 @@
+import { ValueErrorIterator, ValueError } from '../../errors/index.mjs';
+import { TypeBoxError } from '../../type/error/error.mjs';
+import { TSchema } from '../../type/schema/index.mjs';
+import { Static } from '../../type/static/index.mjs';
+export declare class AssertError extends TypeBoxError {
+    #private;
+    error: ValueError | undefined;
+    constructor(iterator: ValueErrorIterator);
+    /** Returns an iterator for each error in this value. */
+    Errors(): ValueErrorIterator;
+}
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export declare function Assert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): asserts value is Static<T>;
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export declare function Assert<T extends TSchema>(schema: T, value: unknown): asserts value is Static<T>;

package/build/esm/value/assert/assert.mjs

@@ -0,0 +1,49 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AssertError_instances, _AssertError_iterator, _AssertError_Iterator;
+import { Errors, ValueErrorIterator } from '../../errors/index.mjs';
+import { TypeBoxError } from '../../type/error/error.mjs';
+import { Check } from '../check/check.mjs';
+// ------------------------------------------------------------------
+// AssertError
+// ------------------------------------------------------------------
+export class AssertError extends TypeBoxError {
+    constructor(iterator) {
+        const error = iterator.First();
+        super(error === undefined ? 'Invalid Value' : error.message);
+        _AssertError_instances.add(this);
+        _AssertError_iterator.set(this, void 0);
+        __classPrivateFieldSet(this, _AssertError_iterator, iterator, "f");
+        this.error = error;
+    }
+    /** Returns an iterator for each error in this value. */
+    Errors() {
+        return new ValueErrorIterator(__classPrivateFieldGet(this, _AssertError_instances, "m", _AssertError_Iterator).call(this));
+    }
+}
+_AssertError_iterator = new WeakMap(), _AssertError_instances = new WeakSet(), _AssertError_Iterator = function* _AssertError_Iterator() {
+    if (this.error)
+        yield this.error;
+    yield* __classPrivateFieldGet(this, _AssertError_iterator, "f");
+};
+// ------------------------------------------------------------------
+// AssertValue
+// ------------------------------------------------------------------
+function AssertValue(schema, references, value) {
+    if (Check(schema, references, value))
+        return;
+    throw new AssertError(Errors(schema, references, value));
+}
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export function Assert(...args) {
+    return args.length === 3 ? AssertValue(args[0], args[1], args[2]) : AssertValue(args[0], [], args[1]);
+}

package/build/esm/value/assert/index.d.mts

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

package/build/esm/value/assert/index.mjs

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

package/build/esm/value/cast/cast.mjs

@@ -1,4 +1,4 @@
-import { IsStandardObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index.mjs';
+import { IsObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { Create } from '../create/index.mjs';
@@ -100,7 +100,7 @@ function FromConstructor(schema, references, value) {
 }
 function FromIntersect(schema, references, value) {
     const created = Create(schema, references);
-    const mapped = IsStandardObject(created) && IsStandardObject(value) ? { ...created, ...value } : value;
+    const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
     return Check(schema, references, mapped) ? mapped : Create(schema, references);
 }
 function FromNever(schema, references, value) {

package/build/esm/value/clean/clean.mjs

@@ -7,17 +7,17 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ValueGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
+import { HasPropertyKey, IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { IsSchema } from '../../type/guard/type.mjs';
+import { IsKind } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // IsCheckable
 // ------------------------------------------------------------------
 function IsCheckable(schema) {
-    return IsSchema(schema) && schema[Kind] !== 'Unsafe';
+    return IsKind(schema) && schema[Kind] !== 'Unsafe';
 }
 // ------------------------------------------------------------------
 // Types
@@ -31,7 +31,7 @@ function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, Clone(value)));
     const composite = intersections.reduce((acc, value) => (IsObject(value) ? { ...acc, ...value } : value), {});
-    if (!IsObject(value) || !IsObject(composite) || !IsSchema(unevaluatedProperties))
+    if (!IsObject(value) || !IsObject(composite) || !IsKind(unevaluatedProperties))
         return composite;
     const knownkeys = KeyOfPropertyKeys(schema);
     for (const key of Object.getOwnPropertyNames(value)) {
@@ -48,11 +48,11 @@ function FromObject(schema, references, value) {
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
     for (const key of Object.getOwnPropertyNames(value)) {
-        if (key in schema.properties) {
+        if (HasPropertyKey(schema.properties, key)) {
             value[key] = Visit(schema.properties[key], references, value[key]);
             continue;
         }
-        if (IsSchema(additionalProperties) && Check(additionalProperties, references, value[key])) {
+        if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }
@@ -72,7 +72,7 @@ function FromRecord(schema, references, value) {
             value[key] = Visit(propertySchema, references, value[key]);
             continue;
         }
-        if (IsSchema(additionalProperties) && Check(additionalProperties, references, value[key])) {
+        if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }

package/build/esm/value/clone/clone.mjs

@@ -1,11 +1,11 @@
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsDate, IsStandardObject, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsArray, IsDate, IsMap, IsSet, IsObject, IsTypedArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // Clonable
 // ------------------------------------------------------------------
-function ObjectType(value) {
+function FromObject(value) {
     const Acc = {};
     for (const key of Object.getOwnPropertyNames(value)) {
         Acc[key] = Clone(value[key]);
@@ -15,16 +15,22 @@ function ObjectType(value) {
     }
     return Acc;
 }
-function ArrayType(value) {
+function FromArray(value) {
     return value.map((element) => Clone(element));
 }
-function TypedArrayType(value) {
+function FromTypedArray(value) {
     return value.slice();
 }
-function DateType(value) {
+function FromMap(value) {
+    return new Map(Clone([...value.entries()]));
+}
+function FromSet(value) {
+    return new Set(Clone([...value.entries()]));
+}
+function FromDate(value) {
     return new Date(value.toISOString());
 }
-function ValueType(value) {
+function FromValue(value) {
     return value;
 }
 // ------------------------------------------------------------------
@@ -33,14 +39,18 @@ function ValueType(value) {
 /** Returns a clone of the given value */
 export function Clone(value) {
     if (IsArray(value))
-        return ArrayType(value);
+        return FromArray(value);
     if (IsDate(value))
-        return DateType(value);
-    if (IsStandardObject(value))
-        return ObjectType(value);
+        return FromDate(value);
     if (IsTypedArray(value))
-        return TypedArrayType(value);
+        return FromTypedArray(value);
+    if (IsMap(value))
+        return FromMap(value);
+    if (IsSet(value))
+        return FromSet(value);
+    if (IsObject(value))
+        return FromObject(value);
     if (IsValueType(value))
-        return ValueType(value);
+        return FromValue(value);
     throw new Error('ValueClone: Unable to clone value');
 }

package/build/esm/value/convert/convert.d.mts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, value: unknown): unknown;