@sinclair/typebox 0.32.14 → 0.32.15

package/build/import/compiler/index.d.mts

@@ -1,2 +1,2 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export { TypeCompiler, TypeCheck, type TypeCompilerCodegenOptions, type TypeCompilerLanguageOption, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler.mjs';
+export * from './compiler.mjs';

package/build/import/compiler/index.mjs

@@ -1,2 +1,2 @@
 export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export { TypeCompiler, TypeCheck, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler.mjs';
+export * from './compiler.mjs';

package/build/import/errors/index.d.mts

@@ -1,2 +1,2 @@
-export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors.mjs';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function.mjs';
+export * from './errors.mjs';
+export * from './function.mjs';

package/build/import/errors/index.mjs

@@ -1,2 +1,2 @@
-export { Errors, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors.mjs';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction } from './function.mjs';
+export * from './errors.mjs';
+export * from './function.mjs';

package/build/import/system/index.d.mts

@@ -1,2 +1,2 @@
-export { TypeSystemPolicy } from './policy.mjs';
-export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system.mjs';
+export * from './policy.mjs';
+export * from './system.mjs';

package/build/import/system/index.mjs

@@ -1,2 +1,2 @@
-export { TypeSystemPolicy } from './policy.mjs';
-export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system.mjs';
+export * from './policy.mjs';
+export * from './system.mjs';

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

@@ -1,4 +1,4 @@
-import { IsPlainObject, IsArray, IsString, IsNumber, IsNull } from '../guard/index.mjs';
+import { IsStandardObject, 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 = IsPlainObject(created) && IsPlainObject(value) ? { ...created, ...value } : value;
+    const mapped = IsStandardObject(created) && IsStandardObject(value) ? { ...created, ...value } : value;
     return Check(schema, references, mapped) ? mapped : Create(schema, references);
 }
 function FromNever(schema, references, value) {

package/build/import/value/clone/clone.mjs

@@ -1,7 +1,7 @@
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsDate, IsPlainObject, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsArray, IsDate, IsStandardObject, IsTypedArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // Clonable
 // ------------------------------------------------------------------
@@ -30,7 +30,7 @@ export function Clone(value) {
         return ArrayType(value);
     if (IsDate(value))
         return DateType(value);
-    if (IsPlainObject(value))
+    if (IsStandardObject(value))
         return ObjectType(value);
     if (IsTypedArray(value))
         return TypedArrayType(value);

package/build/import/value/delta/delta.mjs

@@ -1,4 +1,4 @@
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
@@ -55,7 +55,7 @@ function CreateDelete(path) {
 // Diffing Generators
 // ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
-    if (!IsPlainObject(next))
+    if (!IsStandardObject(next))
         return yield CreateUpdate(path, next);
     const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
@@ -115,7 +115,7 @@ function* ValueType(path, current, next) {
     yield CreateUpdate(path, next);
 }
 function* Visit(path, current, next) {
-    if (IsPlainObject(current))
+    if (IsStandardObject(current))
         return yield* ObjectType(path, current, next);
     if (IsArray(current))
         return yield* ArrayType(path, current, next);

package/build/import/value/equal/equal.mjs

@@ -1,9 +1,9 @@
-import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!IsPlainObject(right))
+    if (!IsStandardObject(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -32,7 +32,7 @@ function ValueType(left, right) {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 export function Equal(left, right) {
-    if (IsPlainObject(left))
+    if (IsStandardObject(left))
         return ObjectType(left, right);
     if (IsDate(left))
         return DateType(left, right);

package/build/import/value/guard/guard.d.mts

@@ -6,18 +6,46 @@ export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16A
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
 /** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<any>;
-/** Returns true if this value is a typed array */
-export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if this value is not an instance of a class */
+export declare function IsStandardObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an instance of a class */
+export declare function IsInstanceObject(value: unknown): value is ObjectType;
 /** Returns true if this value is a Promise */
 export declare function IsPromise(value: unknown): value is Promise<unknown>;
-/** Returns true if the value is a Uint8Array */
-export declare function IsUint8Array(value: unknown): value is Uint8Array;
 /** Returns true if this value is a Date */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is an instance of Map<K, T> */
+export declare function IsMap(value: unknown): value is Map<unknown, unknown>;
+/** Returns true if this value is an instance of Set<T> */
+export declare function IsSet(value: unknown): value is Set<unknown>;
+/** Returns true if this value is RegExp */
+export declare function IsRegExp(value: unknown): value is RegExp;
+/** Returns true if this value is a typed array */
+export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if the value is a Int8Array */
+export declare function IsInt8Array(value: unknown): value is Int8Array;
+/** Returns true if the value is a Uint8Array */
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if the value is a Uint8ClampedArray */
+export declare function IsUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+/** Returns true if the value is a Int16Array */
+export declare function IsInt16Array(value: unknown): value is Int16Array;
+/** Returns true if the value is a Uint16Array */
+export declare function IsUint16Array(value: unknown): value is Uint16Array;
+/** Returns true if the value is a Int32Array */
+export declare function IsInt32Array(value: unknown): value is Int32Array;
+/** Returns true if the value is a Uint32Array */
+export declare function IsUint32Array(value: unknown): value is Uint32Array;
+/** Returns true if the value is a Float32Array */
+export declare function IsFloat32Array(value: unknown): value is Float32Array;
+/** Returns true if the value is a Float64Array */
+export declare function IsFloat64Array(value: unknown): value is Float64Array;
+/** Returns true if the value is a BigInt64Array */
+export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
+/** Returns true if the value is a BigUint64Array */
+export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
-/** Returns true if this object is not an instance of any other type */
-export declare function IsPlainObject(value: unknown): value is ObjectType;
 /** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
 /** Returns true if this value is an array, but not a typed array */

package/build/import/value/guard/guard.mjs

@@ -10,24 +10,87 @@ export function IsIterator(value) {
     return IsObject(value) && Symbol.iterator in value;
 }
 // --------------------------------------------------------------------------
-// Nominal
+// Object Instances
 // --------------------------------------------------------------------------
-/** Returns true if this value is a typed array */
-export function IsTypedArray(value) {
-    return ArrayBuffer.isView(value);
+/** Returns true if this value is not an instance of a class */
+export function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
+}
+/** Returns true if this value is an instance of a class */
+export function IsInstanceObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
 }
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
 /** Returns true if this value is a Promise */
 export function IsPromise(value) {
     return value instanceof Promise;
 }
-/** Returns true if the value is a Uint8Array */
-export function IsUint8Array(value) {
-    return value instanceof Uint8Array;
-}
 /** Returns true if this value is a Date */
 export function IsDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
 }
+/** Returns true if this value is an instance of Map<K, T> */
+export function IsMap(value) {
+    return value instanceof globalThis.Map;
+}
+/** Returns true if this value is an instance of Set<T> */
+export function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+/** Returns true if this value is RegExp */
+export function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is a typed array */
+export function IsTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+/** Returns true if the value is a Int8Array */
+export function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+/** Returns true if the value is a Uint8Array */
+export function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if the value is a Uint8ClampedArray */
+export function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+/** Returns true if the value is a Int16Array */
+export function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+/** Returns true if the value is a Uint16Array */
+export function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+/** Returns true if the value is a Int32Array */
+export function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+/** Returns true if the value is a Uint32Array */
+export function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+/** Returns true if the value is a Float32Array */
+export function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+/** Returns true if the value is a Float64Array */
+export function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+/** Returns true if the value is a BigInt64Array */
+export function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+/** Returns true if the value is a BigUint64Array */
+export function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
 // --------------------------------------------------------------------------
 // Standard
 // --------------------------------------------------------------------------
@@ -35,10 +98,6 @@ export function IsDate(value) {
 export function HasPropertyKey(value, key) {
     return key in value;
 }
-/** Returns true if this object is not an instance of any other type */
-export function IsPlainObject(value) {
-    return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
-}
 /** Returns true of this value is an object type */
 export function IsObject(value) {
     return value !== null && typeof value === 'object';

package/build/import/value/hash/hash.mjs

@@ -1,4 +1,4 @@
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsStandardObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
@@ -120,7 +120,7 @@ function Visit(value) {
         return NullType(value);
     if (IsNumber(value))
         return NumberType(value);
-    if (IsPlainObject(value))
+    if (IsStandardObject(value))
         return ObjectType(value);
     if (IsString(value))
         return StringType(value);

package/build/import/value/index.d.mts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export { Cast, ValueCastError } from './cast/index.mjs';
-export { Check } from './check/index.mjs';
-export { Clean } from './clean/index.mjs';
-export { Clone } from './clone/index.mjs';
-export { Convert } from './convert/index.mjs';
-export { Create, ValueCreateError } from './create/index.mjs';
-export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
-export { Equal } from './equal/index.mjs';
-export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, ValueMutateError, type Mutable } from './mutate/index.mjs';
-export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index.mjs';
+export * from './guard/index.mjs';
+export * from './cast/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './default/index.mjs';
+export * from './delta/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './pointer/index.mjs';
+export * from './transform/index.mjs';
 export { Value } from './value/index.mjs';

package/build/import/value/index.mjs

@@ -1,28 +1,28 @@
 // ------------------------------------------------------------------
-// Value Errors (re-export)
+// Errors (re-export)
 // ------------------------------------------------------------------
 export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
 // ------------------------------------------------------------------
-// Value Operators
+// Guards
 // ------------------------------------------------------------------
-export { Cast, ValueCastError } from './cast/index.mjs';
-export { Check } from './check/index.mjs';
-export { Clean } from './clean/index.mjs';
-export { Clone } from './clone/index.mjs';
-export { Convert } from './convert/index.mjs';
-export { Create, ValueCreateError } from './create/index.mjs';
-export { Default } from './default/index.mjs';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index.mjs';
-export { Equal } from './equal/index.mjs';
-export { Hash, ValueHashError } from './hash/index.mjs';
-export { Mutate, ValueMutateError } from './mutate/index.mjs';
-export { ValuePointer } from './pointer/index.mjs';
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+export * from './guard/index.mjs';
 // ------------------------------------------------------------------
-// Value Guards
+// Operators
 // ------------------------------------------------------------------
-export { HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, } from './guard/index.mjs';
+export * from './cast/index.mjs';
+export * from './check/index.mjs';
+export * from './clean/index.mjs';
+export * from './clone/index.mjs';
+export * from './convert/index.mjs';
+export * from './create/index.mjs';
+export * from './default/index.mjs';
+export * from './delta/index.mjs';
+export * from './equal/index.mjs';
+export * from './hash/index.mjs';
+export * from './mutate/index.mjs';
+export * from './pointer/index.mjs';
+export * from './transform/index.mjs';
 // ------------------------------------------------------------------
-// Value Namespace
+// Namespace
 // ------------------------------------------------------------------
 export { Value } from './value/index.mjs';

package/build/import/value/mutate/mutate.mjs

@@ -1,4 +1,4 @@
-import { IsPlainObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
@@ -11,7 +11,7 @@ export class ValueMutateError extends TypeBoxError {
     }
 }
 function ObjectType(root, path, current, next) {
-    if (!IsPlainObject(current)) {
+    if (!IsStandardObject(current)) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
@@ -63,7 +63,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if (IsTypedArray(next))
         return TypedArrayType(root, path, current, next);
-    if (IsPlainObject(next))
+    if (IsStandardObject(next))
         return ObjectType(root, path, current, next);
     if (IsValueType(next))
         return ValueType(root, path, current, next);
@@ -76,8 +76,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((IsPlainObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsPlainObject(next)));
+    return ((IsStandardObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsStandardObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/build/import/value/transform/decode.mjs

@@ -7,7 +7,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -56,7 +56,7 @@ function FromArray(schema, references, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, value) {
-    if (!IsPlainObject(value) || IsValueType(value))
+    if (!IsStandardObject(value) || IsValueType(value))
         return Default(schema, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -81,7 +81,7 @@ function FromNot(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return Default(schema, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -103,7 +103,7 @@ function FromObject(schema, references, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, value) {
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return Default(schema, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);

package/build/import/value/transform/encode.mjs

@@ -7,7 +7,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -57,7 +57,7 @@ function FromArray(schema, references, value) {
 // prettier-ignore
 function FromIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!IsPlainObject(value) || IsValueType(value))
+    if (!IsStandardObject(value) || IsValueType(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -83,7 +83,7 @@ function FromNot(schema, references, value) {
 // prettier-ignore
 function FromObject(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -105,7 +105,7 @@ function FromObject(schema, references, value) {
 // prettier-ignore
 function FromRecord(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
+    if (!IsStandardObject(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);

package/build/require/compiler/index.d.ts

@@ -1,2 +1,2 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { TypeCompiler, TypeCheck, type TypeCompilerCodegenOptions, type TypeCompilerLanguageOption, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler';
+export * from './compiler';

package/build/require/compiler/index.js

@@ -1,12 +1,22 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompilerUnknownTypeError = exports.TypeCompilerTypeGuardError = exports.TypeCheck = exports.TypeCompiler = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-var compiler_1 = require("./compiler");
-Object.defineProperty(exports, "TypeCompiler", { enumerable: true, get: function () { return compiler_1.TypeCompiler; } });
-Object.defineProperty(exports, "TypeCheck", { enumerable: true, get: function () { return compiler_1.TypeCheck; } });
-Object.defineProperty(exports, "TypeCompilerTypeGuardError", { enumerable: true, get: function () { return compiler_1.TypeCompilerTypeGuardError; } });
-Object.defineProperty(exports, "TypeCompilerUnknownTypeError", { enumerable: true, get: function () { return compiler_1.TypeCompilerUnknownTypeError; } });
+__exportStar(require("./compiler"), exports);

package/build/require/errors/index.d.ts

@@ -1,2 +1,2 @@
-export { Errors, ValueError, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors';
-export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction, type ErrorFunction, type ErrorFunctionParameter } from './function';
+export * from './errors';
+export * from './function';

package/build/require/errors/index.js

@@ -1,13 +1,19 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetErrorFunction = exports.GetErrorFunction = exports.DefaultErrorFunction = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = exports.ValueErrorIterator = exports.Errors = void 0;
-var errors_1 = require("./errors");
-Object.defineProperty(exports, "Errors", { enumerable: true, get: function () { return errors_1.Errors; } });
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return errors_1.ValueErrorIterator; } });
-Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
-Object.defineProperty(exports, "ValueErrorsUnknownTypeError", { enumerable: true, get: function () { return errors_1.ValueErrorsUnknownTypeError; } });
-var function_1 = require("./function");
-Object.defineProperty(exports, "DefaultErrorFunction", { enumerable: true, get: function () { return function_1.DefaultErrorFunction; } });
-Object.defineProperty(exports, "GetErrorFunction", { enumerable: true, get: function () { return function_1.GetErrorFunction; } });
-Object.defineProperty(exports, "SetErrorFunction", { enumerable: true, get: function () { return function_1.SetErrorFunction; } });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./function"), exports);

package/build/require/system/index.d.ts

@@ -1,2 +1,2 @@
-export { TypeSystemPolicy } from './policy';
-export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system';
+export * from './policy';
+export * from './system';

package/build/require/system/index.js

@@ -1,10 +1,19 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeSystemDuplicateTypeKind = exports.TypeSystemDuplicateFormat = exports.TypeSystem = exports.TypeSystemPolicy = void 0;
-var policy_1 = require("./policy");
-Object.defineProperty(exports, "TypeSystemPolicy", { enumerable: true, get: function () { return policy_1.TypeSystemPolicy; } });
-var system_1 = require("./system");
-Object.defineProperty(exports, "TypeSystem", { enumerable: true, get: function () { return system_1.TypeSystem; } });
-Object.defineProperty(exports, "TypeSystemDuplicateFormat", { enumerable: true, get: function () { return system_1.TypeSystemDuplicateFormat; } });
-Object.defineProperty(exports, "TypeSystemDuplicateTypeKind", { enumerable: true, get: function () { return system_1.TypeSystemDuplicateTypeKind; } });
+__exportStar(require("./policy"), exports);
+__exportStar(require("./system"), exports);

package/build/require/value/cast/cast.js

@@ -104,7 +104,7 @@ function FromConstructor(schema, references, value) {
 }
 function FromIntersect(schema, references, value) {
     const created = (0, index_4.Create)(schema, references);
-    const mapped = (0, index_1.IsPlainObject)(created) && (0, index_1.IsPlainObject)(value) ? { ...created, ...value } : value;
+    const mapped = (0, index_1.IsStandardObject)(created) && (0, index_1.IsStandardObject)(value) ? { ...created, ...value } : value;
     return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.Create)(schema, references);
 }
 function FromNever(schema, references, value) {

package/build/require/value/clone/clone.js

@@ -34,7 +34,7 @@ function Clone(value) {
         return ArrayType(value);
     if ((0, index_1.IsDate)(value))
         return DateType(value);
-    if ((0, index_1.IsPlainObject)(value))
+    if ((0, index_1.IsStandardObject)(value))
         return ObjectType(value);
     if ((0, index_1.IsTypedArray)(value))
         return TypedArrayType(value);

package/build/require/value/delta/delta.js

@@ -59,7 +59,7 @@ function CreateDelete(path) {
 // Diffing Generators
 // ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
-    if (!(0, index_1.IsPlainObject)(next))
+    if (!(0, index_1.IsStandardObject)(next))
         return yield CreateUpdate(path, next);
     const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
     const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
@@ -119,7 +119,7 @@ function* ValueType(path, current, next) {
     yield CreateUpdate(path, next);
 }
 function* Visit(path, current, next) {
-    if ((0, index_1.IsPlainObject)(current))
+    if ((0, index_1.IsStandardObject)(current))
         return yield* ObjectType(path, current, next);
     if ((0, index_1.IsArray)(current))
         return yield* ArrayType(path, current, next);

package/build/require/value/equal/equal.js

@@ -7,7 +7,7 @@ const index_1 = require("../guard/index");
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!(0, index_1.IsPlainObject)(right))
+    if (!(0, index_1.IsStandardObject)(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -36,7 +36,7 @@ function ValueType(left, right) {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 function Equal(left, right) {
-    if ((0, index_1.IsPlainObject)(left))
+    if ((0, index_1.IsStandardObject)(left))
         return ObjectType(left, right);
     if ((0, index_1.IsDate)(left))
         return DateType(left, right);

package/build/require/value/guard/guard.d.ts

@@ -6,18 +6,46 @@ export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16A
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
 /** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<any>;
-/** Returns true if this value is a typed array */
-export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if this value is not an instance of a class */
+export declare function IsStandardObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an instance of a class */
+export declare function IsInstanceObject(value: unknown): value is ObjectType;
 /** Returns true if this value is a Promise */
 export declare function IsPromise(value: unknown): value is Promise<unknown>;
-/** Returns true if the value is a Uint8Array */
-export declare function IsUint8Array(value: unknown): value is Uint8Array;
 /** Returns true if this value is a Date */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value is an instance of Map<K, T> */
+export declare function IsMap(value: unknown): value is Map<unknown, unknown>;
+/** Returns true if this value is an instance of Set<T> */
+export declare function IsSet(value: unknown): value is Set<unknown>;
+/** Returns true if this value is RegExp */
+export declare function IsRegExp(value: unknown): value is RegExp;
+/** Returns true if this value is a typed array */
+export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if the value is a Int8Array */
+export declare function IsInt8Array(value: unknown): value is Int8Array;
+/** Returns true if the value is a Uint8Array */
+export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if the value is a Uint8ClampedArray */
+export declare function IsUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+/** Returns true if the value is a Int16Array */
+export declare function IsInt16Array(value: unknown): value is Int16Array;
+/** Returns true if the value is a Uint16Array */
+export declare function IsUint16Array(value: unknown): value is Uint16Array;
+/** Returns true if the value is a Int32Array */
+export declare function IsInt32Array(value: unknown): value is Int32Array;
+/** Returns true if the value is a Uint32Array */
+export declare function IsUint32Array(value: unknown): value is Uint32Array;
+/** Returns true if the value is a Float32Array */
+export declare function IsFloat32Array(value: unknown): value is Float32Array;
+/** Returns true if the value is a Float64Array */
+export declare function IsFloat64Array(value: unknown): value is Float64Array;
+/** Returns true if the value is a BigInt64Array */
+export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
+/** Returns true if the value is a BigUint64Array */
+export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
-/** Returns true if this object is not an instance of any other type */
-export declare function IsPlainObject(value: unknown): value is ObjectType;
 /** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
 /** Returns true if this value is an array, but not a typed array */

package/build/require/value/guard/guard.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.IsPlainObject = exports.HasPropertyKey = exports.IsDate = exports.IsUint8Array = exports.IsPromise = exports.IsTypedArray = exports.IsIterator = exports.IsAsyncIterator = void 0;
+exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.HasPropertyKey = exports.IsBigUint64Array = exports.IsBigInt64Array = exports.IsFloat64Array = exports.IsFloat32Array = exports.IsUint32Array = exports.IsInt32Array = exports.IsUint16Array = exports.IsInt16Array = exports.IsUint8ClampedArray = exports.IsUint8Array = exports.IsInt8Array = exports.IsTypedArray = exports.IsRegExp = exports.IsSet = exports.IsMap = exports.IsDate = exports.IsPromise = exports.IsInstanceObject = exports.IsStandardObject = exports.IsIterator = exports.IsAsyncIterator = void 0;
 // --------------------------------------------------------------------------
 // Iterators
 // --------------------------------------------------------------------------
@@ -16,28 +16,106 @@ function IsIterator(value) {
 }
 exports.IsIterator = IsIterator;
 // --------------------------------------------------------------------------
-// Nominal
+// Object Instances
 // --------------------------------------------------------------------------
-/** Returns true if this value is a typed array */
-function IsTypedArray(value) {
-    return ArrayBuffer.isView(value);
+/** Returns true if this value is not an instance of a class */
+function IsStandardObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
 }
-exports.IsTypedArray = IsTypedArray;
+exports.IsStandardObject = IsStandardObject;
+/** Returns true if this value is an instance of a class */
+function IsInstanceObject(value) {
+    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
+}
+exports.IsInstanceObject = IsInstanceObject;
+// --------------------------------------------------------------------------
+// JavaScript
+// --------------------------------------------------------------------------
 /** Returns true if this value is a Promise */
 function IsPromise(value) {
     return value instanceof Promise;
 }
 exports.IsPromise = IsPromise;
-/** Returns true if the value is a Uint8Array */
-function IsUint8Array(value) {
-    return value instanceof Uint8Array;
-}
-exports.IsUint8Array = IsUint8Array;
 /** Returns true if this value is a Date */
 function IsDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
 }
 exports.IsDate = IsDate;
+/** Returns true if this value is an instance of Map<K, T> */
+function IsMap(value) {
+    return value instanceof globalThis.Map;
+}
+exports.IsMap = IsMap;
+/** Returns true if this value is an instance of Set<T> */
+function IsSet(value) {
+    return value instanceof globalThis.Set;
+}
+exports.IsSet = IsSet;
+/** Returns true if this value is RegExp */
+function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+exports.IsRegExp = IsRegExp;
+/** Returns true if this value is a typed array */
+function IsTypedArray(value) {
+    return ArrayBuffer.isView(value);
+}
+exports.IsTypedArray = IsTypedArray;
+/** Returns true if the value is a Int8Array */
+function IsInt8Array(value) {
+    return value instanceof globalThis.Int8Array;
+}
+exports.IsInt8Array = IsInt8Array;
+/** Returns true if the value is a Uint8Array */
+function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+exports.IsUint8Array = IsUint8Array;
+/** Returns true if the value is a Uint8ClampedArray */
+function IsUint8ClampedArray(value) {
+    return value instanceof globalThis.Uint8ClampedArray;
+}
+exports.IsUint8ClampedArray = IsUint8ClampedArray;
+/** Returns true if the value is a Int16Array */
+function IsInt16Array(value) {
+    return value instanceof globalThis.Int16Array;
+}
+exports.IsInt16Array = IsInt16Array;
+/** Returns true if the value is a Uint16Array */
+function IsUint16Array(value) {
+    return value instanceof globalThis.Uint16Array;
+}
+exports.IsUint16Array = IsUint16Array;
+/** Returns true if the value is a Int32Array */
+function IsInt32Array(value) {
+    return value instanceof globalThis.Int32Array;
+}
+exports.IsInt32Array = IsInt32Array;
+/** Returns true if the value is a Uint32Array */
+function IsUint32Array(value) {
+    return value instanceof globalThis.Uint32Array;
+}
+exports.IsUint32Array = IsUint32Array;
+/** Returns true if the value is a Float32Array */
+function IsFloat32Array(value) {
+    return value instanceof globalThis.Float32Array;
+}
+exports.IsFloat32Array = IsFloat32Array;
+/** Returns true if the value is a Float64Array */
+function IsFloat64Array(value) {
+    return value instanceof globalThis.Float64Array;
+}
+exports.IsFloat64Array = IsFloat64Array;
+/** Returns true if the value is a BigInt64Array */
+function IsBigInt64Array(value) {
+    return value instanceof globalThis.BigInt64Array;
+}
+exports.IsBigInt64Array = IsBigInt64Array;
+/** Returns true if the value is a BigUint64Array */
+function IsBigUint64Array(value) {
+    return value instanceof globalThis.BigUint64Array;
+}
+exports.IsBigUint64Array = IsBigUint64Array;
 // --------------------------------------------------------------------------
 // Standard
 // --------------------------------------------------------------------------
@@ -46,11 +124,6 @@ function HasPropertyKey(value, key) {
     return key in value;
 }
 exports.HasPropertyKey = HasPropertyKey;
-/** Returns true if this object is not an instance of any other type */
-function IsPlainObject(value) {
-    return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
-}
-exports.IsPlainObject = IsPlainObject;
 /** Returns true of this value is an object type */
 function IsObject(value) {
     return value !== null && typeof value === 'object';

package/build/require/value/hash/hash.js

@@ -124,7 +124,7 @@ function Visit(value) {
         return NullType(value);
     if ((0, index_1.IsNumber)(value))
         return NumberType(value);
-    if ((0, index_1.IsPlainObject)(value))
+    if ((0, index_1.IsStandardObject)(value))
         return ObjectType(value);
     if ((0, index_1.IsString)(value))
         return StringType(value);

package/build/require/value/index.d.ts

@@ -1,16 +1,16 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
-export { Cast, ValueCastError } from './cast/index';
-export { Check } from './check/index';
-export { Clean } from './clean/index';
-export { Clone } from './clone/index';
-export { Convert } from './convert/index';
-export { Create, ValueCreateError } from './create/index';
-export { Default } from './default/index';
-export { Diff, Patch, Edit, Delete, Insert, Update, ValueDeltaError } from './delta/index';
-export { Equal } from './equal/index';
-export { Hash, ValueHashError } from './hash/index';
-export { Mutate, ValueMutateError, type Mutable } from './mutate/index';
-export { ValuePointer } from './pointer/index';
-export { TransformDecode, TransformEncode, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index';
-export { ArrayType, HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, type ObjectType, type TypedArrayType, type ValueType, } from './guard/index';
+export * from './guard/index';
+export * from './cast/index';
+export * from './check/index';
+export * from './clean/index';
+export * from './clone/index';
+export * from './convert/index';
+export * from './create/index';
+export * from './default/index';
+export * from './delta/index';
+export * from './equal/index';
+export * from './hash/index';
+export * from './mutate/index';
+export * from './pointer/index';
+export * from './transform/index';
 export { Value } from './value/index';

package/build/require/value/index.js

@@ -1,85 +1,49 @@
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUndefined = exports.IsUint8Array = exports.IsTypedArray = exports.IsSymbol = exports.IsString = exports.IsPromise = exports.IsPlainObject = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = exports.IsInteger = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.HasPropertyKey = exports.TransformEncodeError = exports.TransformEncodeCheckError = exports.TransformDecodeError = exports.TransformDecodeCheckError = exports.HasTransform = exports.TransformEncode = exports.TransformDecode = exports.ValuePointer = exports.ValueMutateError = exports.Mutate = exports.ValueHashError = exports.Hash = exports.Equal = exports.ValueDeltaError = exports.Update = exports.Insert = exports.Delete = exports.Edit = exports.Patch = exports.Diff = exports.Default = exports.ValueCreateError = exports.Create = exports.Convert = exports.Clone = exports.Clean = exports.Check = exports.ValueCastError = exports.Cast = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
-exports.Value = exports.IsValueType = void 0;
+exports.Value = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 // ------------------------------------------------------------------
-// Value Errors (re-export)
+// Errors (re-export)
 // ------------------------------------------------------------------
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
 Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
 // ------------------------------------------------------------------
-// Value Operators
+// Guards
 // ------------------------------------------------------------------
-var index_2 = require("./cast/index");
-Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return index_2.Cast; } });
-Object.defineProperty(exports, "ValueCastError", { enumerable: true, get: function () { return index_2.ValueCastError; } });
-var index_3 = require("./check/index");
-Object.defineProperty(exports, "Check", { enumerable: true, get: function () { return index_3.Check; } });
-var index_4 = require("./clean/index");
-Object.defineProperty(exports, "Clean", { enumerable: true, get: function () { return index_4.Clean; } });
-var index_5 = require("./clone/index");
-Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return index_5.Clone; } });
-var index_6 = require("./convert/index");
-Object.defineProperty(exports, "Convert", { enumerable: true, get: function () { return index_6.Convert; } });
-var index_7 = require("./create/index");
-Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return index_7.Create; } });
-Object.defineProperty(exports, "ValueCreateError", { enumerable: true, get: function () { return index_7.ValueCreateError; } });
-var index_8 = require("./default/index");
-Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return index_8.Default; } });
-var index_9 = require("./delta/index");
-Object.defineProperty(exports, "Diff", { enumerable: true, get: function () { return index_9.Diff; } });
-Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return index_9.Patch; } });
-Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return index_9.Edit; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return index_9.Delete; } });
-Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return index_9.Insert; } });
-Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return index_9.Update; } });
-Object.defineProperty(exports, "ValueDeltaError", { enumerable: true, get: function () { return index_9.ValueDeltaError; } });
-var index_10 = require("./equal/index");
-Object.defineProperty(exports, "Equal", { enumerable: true, get: function () { return index_10.Equal; } });
-var index_11 = require("./hash/index");
-Object.defineProperty(exports, "Hash", { enumerable: true, get: function () { return index_11.Hash; } });
-Object.defineProperty(exports, "ValueHashError", { enumerable: true, get: function () { return index_11.ValueHashError; } });
-var index_12 = require("./mutate/index");
-Object.defineProperty(exports, "Mutate", { enumerable: true, get: function () { return index_12.Mutate; } });
-Object.defineProperty(exports, "ValueMutateError", { enumerable: true, get: function () { return index_12.ValueMutateError; } });
-var index_13 = require("./pointer/index");
-Object.defineProperty(exports, "ValuePointer", { enumerable: true, get: function () { return index_13.ValuePointer; } });
-var index_14 = require("./transform/index");
-Object.defineProperty(exports, "TransformDecode", { enumerable: true, get: function () { return index_14.TransformDecode; } });
-Object.defineProperty(exports, "TransformEncode", { enumerable: true, get: function () { return index_14.TransformEncode; } });
-Object.defineProperty(exports, "HasTransform", { enumerable: true, get: function () { return index_14.HasTransform; } });
-Object.defineProperty(exports, "TransformDecodeCheckError", { enumerable: true, get: function () { return index_14.TransformDecodeCheckError; } });
-Object.defineProperty(exports, "TransformDecodeError", { enumerable: true, get: function () { return index_14.TransformDecodeError; } });
-Object.defineProperty(exports, "TransformEncodeCheckError", { enumerable: true, get: function () { return index_14.TransformEncodeCheckError; } });
-Object.defineProperty(exports, "TransformEncodeError", { enumerable: true, get: function () { return index_14.TransformEncodeError; } });
+__exportStar(require("./guard/index"), exports);
 // ------------------------------------------------------------------
-// Value Guards
+// Operators
 // ------------------------------------------------------------------
-var index_15 = require("./guard/index");
-Object.defineProperty(exports, "HasPropertyKey", { enumerable: true, get: function () { return index_15.HasPropertyKey; } });
-Object.defineProperty(exports, "IsArray", { enumerable: true, get: function () { return index_15.IsArray; } });
-Object.defineProperty(exports, "IsAsyncIterator", { enumerable: true, get: function () { return index_15.IsAsyncIterator; } });
-Object.defineProperty(exports, "IsBigInt", { enumerable: true, get: function () { return index_15.IsBigInt; } });
-Object.defineProperty(exports, "IsBoolean", { enumerable: true, get: function () { return index_15.IsBoolean; } });
-Object.defineProperty(exports, "IsDate", { enumerable: true, get: function () { return index_15.IsDate; } });
-Object.defineProperty(exports, "IsFunction", { enumerable: true, get: function () { return index_15.IsFunction; } });
-Object.defineProperty(exports, "IsInteger", { enumerable: true, get: function () { return index_15.IsInteger; } });
-Object.defineProperty(exports, "IsIterator", { enumerable: true, get: function () { return index_15.IsIterator; } });
-Object.defineProperty(exports, "IsNull", { enumerable: true, get: function () { return index_15.IsNull; } });
-Object.defineProperty(exports, "IsNumber", { enumerable: true, get: function () { return index_15.IsNumber; } });
-Object.defineProperty(exports, "IsObject", { enumerable: true, get: function () { return index_15.IsObject; } });
-Object.defineProperty(exports, "IsPlainObject", { enumerable: true, get: function () { return index_15.IsPlainObject; } });
-Object.defineProperty(exports, "IsPromise", { enumerable: true, get: function () { return index_15.IsPromise; } });
-Object.defineProperty(exports, "IsString", { enumerable: true, get: function () { return index_15.IsString; } });
-Object.defineProperty(exports, "IsSymbol", { enumerable: true, get: function () { return index_15.IsSymbol; } });
-Object.defineProperty(exports, "IsTypedArray", { enumerable: true, get: function () { return index_15.IsTypedArray; } });
-Object.defineProperty(exports, "IsUint8Array", { enumerable: true, get: function () { return index_15.IsUint8Array; } });
-Object.defineProperty(exports, "IsUndefined", { enumerable: true, get: function () { return index_15.IsUndefined; } });
-Object.defineProperty(exports, "IsValueType", { enumerable: true, get: function () { return index_15.IsValueType; } });
+__exportStar(require("./cast/index"), exports);
+__exportStar(require("./check/index"), exports);
+__exportStar(require("./clean/index"), exports);
+__exportStar(require("./clone/index"), exports);
+__exportStar(require("./convert/index"), exports);
+__exportStar(require("./create/index"), exports);
+__exportStar(require("./default/index"), exports);
+__exportStar(require("./delta/index"), exports);
+__exportStar(require("./equal/index"), exports);
+__exportStar(require("./hash/index"), exports);
+__exportStar(require("./mutate/index"), exports);
+__exportStar(require("./pointer/index"), exports);
+__exportStar(require("./transform/index"), exports);
 // ------------------------------------------------------------------
-// Value Namespace
+// Namespace
 // ------------------------------------------------------------------
-var index_16 = require("./value/index");
-Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_16.Value; } });
+var index_2 = require("./value/index");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_2.Value; } });

package/build/require/value/mutate/mutate.js

@@ -16,7 +16,7 @@ class ValueMutateError extends index_4.TypeBoxError {
 }
 exports.ValueMutateError = ValueMutateError;
 function ObjectType(root, path, current, next) {
-    if (!(0, index_1.IsPlainObject)(current)) {
+    if (!(0, index_1.IsStandardObject)(current)) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
@@ -68,7 +68,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if ((0, index_1.IsTypedArray)(next))
         return TypedArrayType(root, path, current, next);
-    if ((0, index_1.IsPlainObject)(next))
+    if ((0, index_1.IsStandardObject)(next))
         return ObjectType(root, path, current, next);
     if ((0, index_1.IsValueType)(next))
         return ValueType(root, path, current, next);
@@ -81,8 +81,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return (((0, index_1.IsPlainObject)(current) && (0, index_1.IsArray)(next)) ||
-        ((0, index_1.IsArray)(current) && (0, index_1.IsPlainObject)(next)));
+    return (((0, index_1.IsStandardObject)(current) && (0, index_1.IsArray)(next)) ||
+        ((0, index_1.IsArray)(current) && (0, index_1.IsStandardObject)(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

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

@@ -57,7 +57,7 @@ function FromArray(schema, references, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, value) {
-    if (!(0, index_7.IsPlainObject)(value) || (0, index_7.IsValueType)(value))
+    if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
         return Default(schema, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -82,7 +82,7 @@ function FromNot(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    if (!(0, index_7.IsPlainObject)(value))
+    if (!(0, index_7.IsStandardObject)(value))
         return Default(schema, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -104,7 +104,7 @@ function FromObject(schema, references, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, value) {
-    if (!(0, index_7.IsPlainObject)(value))
+    if (!(0, index_7.IsStandardObject)(value))
         return Default(schema, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);

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

@@ -58,7 +58,7 @@ function FromArray(schema, references, value) {
 // prettier-ignore
 function FromIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!(0, index_7.IsPlainObject)(value) || (0, index_7.IsValueType)(value))
+    if (!(0, index_7.IsStandardObject)(value) || (0, index_7.IsValueType)(value))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -84,7 +84,7 @@ function FromNot(schema, references, value) {
 // prettier-ignore
 function FromObject(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!(0, index_7.IsPlainObject)(value))
+    if (!(0, index_7.IsStandardObject)(value))
         return defaulted;
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
@@ -106,7 +106,7 @@ function FromObject(schema, references, value) {
 // prettier-ignore
 function FromRecord(schema, references, value) {
     const defaulted = Default(schema, value);
-    if (!(0, index_7.IsPlainObject)(value))
+    if (!(0, index_7.IsStandardObject)(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.14",
+  "version": "0.32.15",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",