@sinclair/typebox 0.32.14 → 0.32.16

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/system/system.d.mts

@@ -8,7 +8,7 @@ export declare class TypeSystemDuplicateFormat extends TypeBoxError {
 /** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
     /** Creates a new type */
-    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe.mjs").TUnsafe<Type>;
+    function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("src/type/unsafe/unsafe.mjs").TUnsafe<Type>;
     /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
 }

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

@@ -16,7 +16,7 @@ import { type TIndexFromMappedResult } from './indexed-from-mapped-result.mjs';
 type TFromRest<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, K, [...Acc, Assert<TIndexFromPropertyKey<L, K>, TSchema>]> : Acc);
 type TFromIntersectRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFromIntersectRest<R, [...Acc]> : TFromIntersectRest<R, [...Acc, L]> : Acc);
 type TFromIntersect<T extends TSchema[], K extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<T, K>>>);
-type TFromUnionRest<T extends TSchema[]> = T;
+type TFromUnionRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? [] : TFromUnionRest<R, [L, ...Acc]> : Acc;
 type TFromUnion<T extends TSchema[], K extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<T, K>>>);
 type TFromTuple<T extends TSchema[], K extends PropertyKey> = (K extends keyof T ? T[K] : K extends '[number]' ? TUnionEvaluated<T> : TNever);
 type TFromArray<T extends TSchema, K extends PropertyKey> = (K extends '[number]' ? T : TNever);

package/build/import/type/indexed/indexed.mjs

@@ -23,7 +23,9 @@ function FromIntersect(T, K) {
 }
 // prettier-ignore
 function FromUnionRest(T) {
-    return T; // review this
+    return (T.some(L => IsNever(L))
+        ? []
+        : T);
 }
 // prettier-ignore
 function FromUnion(T, K) {

package/build/import/type/template-literal/parse.mjs

@@ -4,23 +4,42 @@ import { TypeBoxError } from '../error/index.mjs';
 // ------------------------------------------------------------------
 export class TemplateLiteralParserError extends TypeBoxError {
 }
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
 // prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
 function IsNonEscaped(pattern, index, char) {
     return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
 }
-// prettier-ignore
 function IsOpenParen(pattern, index) {
     return IsNonEscaped(pattern, index, '(');
 }
-// prettier-ignore
 function IsCloseParen(pattern, index) {
     return IsNonEscaped(pattern, index, ')');
 }
-// prettier-ignore
 function IsSeparator(pattern, index) {
     return IsNonEscaped(pattern, index, '|');
 }
-// prettier-ignore
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
 function IsGroup(pattern) {
     if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
         return false;
@@ -137,7 +156,7 @@ export function TemplateLiteralParse(pattern) {
     return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
         IsPrecedenceOr(pattern) ? Or(pattern) :
             IsPrecedenceAnd(pattern) ? And(pattern) :
-                { type: 'const', const: pattern });
+                { type: 'const', const: Unescape(pattern) });
 }
 // ------------------------------------------------------------------
 // TemplateLiteralParseExact

package/build/import/type/template-literal/syntax.d.mts

@@ -12,7 +12,7 @@ type FromUnionLiteral<T extends string> = T extends `${infer L}|${infer R}` ? [T
 ];
 type FromUnion<T extends string> = TUnionEvaluated<FromUnionLiteral<T>>;
 type FromTerminal<T extends string> = T extends 'boolean' ? TBoolean : T extends 'bigint' ? TBigInt : T extends 'number' ? TNumber : T extends 'string' ? TString : FromUnion<T>;
-type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$${infer R}` ? [TLiteral<L>, ...FromString<R>] : T extends `${infer L}` ? [TLiteral<L>] : [
+type FromString<T extends string> = T extends `{${infer L}}${infer R}` ? [FromTerminal<L>, ...FromString<R>] : T extends `${infer L}$\{${infer R1}\}${infer R2}` ? [TLiteral<L>, ...FromString<`{${R1}}`>, ...FromString<R2>] : T extends `${infer L}$\{${infer R1}\}` ? [TLiteral<L>, ...FromString<`{${R1}}`>] : T extends `${infer L}` ? [TLiteral<L>] : [
 ];
 export type TTemplateLiteralSyntax<T extends string> = (TTemplateLiteral<Assert<FromString<T>, TTemplateLiteralKind[]>>);
 /** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */

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

@@ -1,9 +1,6 @@
 import { Clone } from '../clone/index.mjs';
-import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
-import { IsObject as IsObjectType } from '../../type/guard/type.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
-import { Composite } from '../../type/composite/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
@@ -129,12 +126,8 @@ function FromDate(schema, references, value) {
 function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
-// prettier-ignore
 function FromIntersect(schema, references, value) {
-    const allObjects = schema.allOf.every(schema => IsObjectType(schema));
-    if (allObjects)
-        return Visit(Composite(schema.allOf), references, value);
-    return Visit(schema.allOf[0], references, value); // todo: fix this
+    return schema.allOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function FromLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -192,13 +185,7 @@ function FromUndefined(schema, references, value) {
     return TryConvertUndefined(value);
 }
 function FromUnion(schema, references, value) {
-    for (const subschema of schema.anyOf) {
-        const converted = Visit(subschema, references, value);
-        if (Check(subschema, references, converted)) {
-            return converted;
-        }
-    }
-    return value;
+    return schema.anyOf.reduce((value, schema) => Visit(schema, references, value), value);
 }
 function Visit(schema, references, value) {
     const references_ = IsString(schema.$id) ? [...references, schema] : references;

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

@@ -1,34 +1,34 @@
 import type { Static } from '../../type/static/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 export type Insert = Static<typeof Insert>;
-export declare const Insert: import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
+export declare const Insert: import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"insert">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
 }>;
 export type Update = Static<typeof Update>;
-export declare const Update: import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"update">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
+export declare const Update: import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"update">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
 }>;
 export type Delete = Static<typeof Delete>;
-export declare const Delete: import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
-    path: import("../../type/string/string.mjs").TString;
+export declare const Delete: import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"delete">;
+    path: import("src/type/string/string.mjs").TString;
 }>;
 export type Edit = Static<typeof Edit>;
-export declare const Edit: import("../../type/union/union-type.mjs").TUnion<[import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"insert">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
-}>, import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"update">;
-    path: import("../../type/string/string.mjs").TString;
-    value: import("../../type/unknown/unknown.mjs").TUnknown;
-}>, import("../../type/object/object.mjs").TObject<{
-    type: import("../../type/literal/literal.mjs").TLiteral<"delete">;
-    path: import("../../type/string/string.mjs").TString;
+export declare const Edit: import("src/type/union/union-type.mjs").TUnion<[import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"insert">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
+}>, import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"update">;
+    path: import("src/type/string/string.mjs").TString;
+    value: import("src/type/unknown/unknown.mjs").TUnknown;
+}>, import("src/type/object/object.mjs").TObject<{
+    type: import("src/type/literal/literal.mjs").TLiteral<"delete">;
+    path: import("src/type/string/string.mjs").TString;
 }>]>;
 export declare class ValueDeltaError extends TypeBoxError {
     readonly value: unknown;

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.d.mts

@@ -9,8 +9,10 @@ export declare class TransformDecodeCheckError extends TypeBoxError {
 }
 export declare class TransformDecodeError extends TypeBoxError {
     readonly schema: TSchema;
+    readonly path: string;
     readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
 }
 /**
  * `[Internal]` Decodes the value and returns the result. This function requires that