@sinclair/typebox 0.32.0-dev-23 → 0.32.0-dev-25

package/build/require/value/check/check.js

@@ -9,12 +9,13 @@ const index_4 = require("../../type/symbols/index");
 const index_5 = require("../../type/keyof/index");
 const index_6 = require("../../type/extends/index");
 const index_7 = require("../../type/registry/index");
-const index_8 = require("../../type/never/index");
+const index_8 = require("../../type/error/index");
+const index_9 = require("../../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-const index_9 = require("../guard/index");
+const index_10 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -22,7 +23,7 @@ const type_1 = require("../../type/guard/type");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCheckUnknownTypeError extends Error {
+class ValueCheckUnknownTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super(`Unknown type`);
         this.schema = schema;
@@ -48,7 +49,7 @@ function FromAny(schema, references, value) {
     return true;
 }
 function FromArray(schema, references, value) {
-    if (!(0, index_9.IsArray)(value))
+    if (!(0, index_10.IsArray)(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
         return false;
@@ -72,27 +73,27 @@ function FromArray(schema, references, value) {
         return false;
     }
     // contains
-    if (!(IsDefined(schema.contains) || (0, index_9.IsNumber)(schema.minContains) || (0, index_9.IsNumber)(schema.maxContains))) {
+    if (!(IsDefined(schema.contains) || (0, index_10.IsNumber)(schema.minContains) || (0, index_10.IsNumber)(schema.maxContains))) {
         return true; // exit
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_9.Never)();
     const containsCount = value.reduce((acc, value) => (Visit(containsSchema, references, value) ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         return false;
     }
-    if ((0, index_9.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_10.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         return false;
     }
-    if ((0, index_9.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_10.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         return false;
     }
     return true;
 }
 function FromAsyncIterator(schema, references, value) {
-    return (0, index_9.IsAsyncIterator)(value);
+    return (0, index_10.IsAsyncIterator)(value);
 }
 function FromBigInt(schema, references, value) {
-    if (!(0, index_9.IsBigInt)(value))
+    if (!(0, index_10.IsBigInt)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         return false;
@@ -112,13 +113,13 @@ function FromBigInt(schema, references, value) {
     return true;
 }
 function FromBoolean(schema, references, value) {
-    return (0, index_9.IsBoolean)(value);
+    return (0, index_10.IsBoolean)(value);
 }
 function FromConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
 function FromDate(schema, references, value) {
-    if (!(0, index_9.IsDate)(value))
+    if (!(0, index_10.IsDate)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         return false;
@@ -138,10 +139,10 @@ function FromDate(schema, references, value) {
     return true;
 }
 function FromFunction(schema, references, value) {
-    return (0, index_9.IsFunction)(value);
+    return (0, index_10.IsFunction)(value);
 }
 function FromInteger(schema, references, value) {
-    if (!(0, index_9.IsInteger)(value)) {
+    if (!(0, index_10.IsInteger)(value)) {
         return false;
     }
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -178,7 +179,7 @@ function FromIntersect(schema, references, value) {
     }
 }
 function FromIterator(schema, references, value) {
-    return (0, index_9.IsIterator)(value);
+    return (0, index_10.IsIterator)(value);
 }
 function FromLiteral(schema, references, value) {
     return value === schema.const;
@@ -190,7 +191,7 @@ function FromNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
 function FromNull(schema, references, value) {
-    return (0, index_9.IsNull)(value);
+    return (0, index_10.IsNull)(value);
 }
 function FromNumber(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
@@ -257,7 +258,7 @@ function FromObject(schema, references, value) {
     }
 }
 function FromPromise(schema, references, value) {
-    return (0, index_9.IsPromise)(value);
+    return (0, index_10.IsPromise)(value);
 }
 function FromRecord(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
@@ -290,7 +291,7 @@ function FromRef(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function FromString(schema, references, value) {
-    if (!(0, index_9.IsString)(value)) {
+    if (!(0, index_10.IsString)(value)) {
         return false;
     }
     if (IsDefined(schema.minLength)) {
@@ -315,16 +316,16 @@ function FromString(schema, references, value) {
     return true;
 }
 function FromSymbol(schema, references, value) {
-    return (0, index_9.IsSymbol)(value);
+    return (0, index_10.IsSymbol)(value);
 }
 function FromTemplateLiteral(schema, references, value) {
-    return (0, index_9.IsString)(value) && new RegExp(schema.pattern).test(value);
+    return (0, index_10.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
 function FromThis(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
 function FromTuple(schema, references, value) {
-    if (!(0, index_9.IsArray)(value)) {
+    if (!(0, index_10.IsArray)(value)) {
         return false;
     }
     if (schema.items === undefined && !(value.length === 0)) {
@@ -343,13 +344,13 @@ function FromTuple(schema, references, value) {
     return true;
 }
 function FromUndefined(schema, references, value) {
-    return (0, index_9.IsUndefined)(value);
+    return (0, index_10.IsUndefined)(value);
 }
 function FromUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
 function FromUint8Array(schema, references, value) {
-    if (!(0, index_9.IsUint8Array)(value)) {
+    if (!(0, index_10.IsUint8Array)(value)) {
         return false;
     }
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {

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

@@ -1,5 +1,6 @@
+import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
-export declare class ValueConvertUnknownTypeError extends Error {
+export declare class ValueConvertUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }

package/build/require/value/convert/convert.js

@@ -5,18 +5,19 @@ exports.Convert = exports.ValueConvertUnknownTypeError = void 0;
 const index_1 = require("../clone/index");
 const index_2 = require("../check/index");
 const index_3 = require("../deref/index");
+const index_4 = require("../../type/error/index");
 const type_1 = require("../../type/guard/type");
-const index_4 = require("../../type/symbols/index");
-const index_5 = require("../../type/composite/index");
+const index_5 = require("../../type/symbols/index");
+const index_6 = require("../../type/composite/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-const index_6 = require("../guard/index");
+const index_7 = require("../guard/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueConvertUnknownTypeError extends Error {
+class ValueConvertUnknownTypeError extends index_4.TypeBoxError {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
@@ -27,31 +28,31 @@ exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
 // Conversions
 // ------------------------------------------------------------------
 function IsStringNumeric(value) {
-    return (0, index_6.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
+    return (0, index_7.IsString)(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
 function IsValueToString(value) {
-    return (0, index_6.IsBigInt)(value) || (0, index_6.IsBoolean)(value) || (0, index_6.IsNumber)(value);
+    return (0, index_7.IsBigInt)(value) || (0, index_7.IsBoolean)(value) || (0, index_7.IsNumber)(value);
 }
 function IsValueTrue(value) {
-    return value === true || ((0, index_6.IsNumber)(value) && value === 1) || ((0, index_6.IsBigInt)(value) && value === BigInt('1')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
+    return value === true || ((0, index_7.IsNumber)(value) && value === 1) || ((0, index_7.IsBigInt)(value) && value === BigInt('1')) || ((0, index_7.IsString)(value) && (value.toLowerCase() === 'true' || value === '1'));
 }
 function IsValueFalse(value) {
-    return value === false || ((0, index_6.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_6.IsBigInt)(value) && value === BigInt('0')) || ((0, index_6.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
+    return value === false || ((0, index_7.IsNumber)(value) && (value === 0 || Object.is(value, -0))) || ((0, index_7.IsBigInt)(value) && value === BigInt('0')) || ((0, index_7.IsString)(value) && (value.toLowerCase() === 'false' || value === '0' || value === '-0'));
 }
 function IsTimeStringWithTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_7.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsTimeStringWithoutTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_7.IsString)(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateTimeStringWithTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+    return (0, index_7.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
 }
 function IsDateTimeStringWithoutTimeZone(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+    return (0, index_7.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
 }
 function IsDateString(value) {
-    return (0, index_6.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+    return (0, index_7.IsString)(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
 // ------------------------------------------------------------------
 // Convert
@@ -70,31 +71,31 @@ function TryConvertLiteralBoolean(value, target) {
 }
 // prettier-ignore
 function TryConvertLiteral(schema, value) {
-    return ((0, index_6.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
-        (0, index_6.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
-            (0, index_6.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
+    return ((0, index_7.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
+        (0, index_7.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
+            (0, index_7.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
                 (0, index_1.Clone)(value));
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
 }
 function TryConvertBigInt(value) {
-    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_6.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+    return IsStringNumeric(value) ? BigInt(parseInt(value)) : (0, index_7.IsNumber)(value) ? BigInt(value | 0) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
 }
 function TryConvertString(value) {
-    return IsValueToString(value) ? value.toString() : (0, index_6.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
+    return IsValueToString(value) ? value.toString() : (0, index_7.IsSymbol)(value) && value.description !== undefined ? value.description.toString() : value;
 }
 function TryConvertNumber(value) {
     return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertInteger(value) {
-    return IsStringNumeric(value) ? parseInt(value) : (0, index_6.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+    return IsStringNumeric(value) ? parseInt(value) : (0, index_7.IsNumber)(value) ? value | 0 : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
 }
 function TryConvertNull(value) {
-    return (0, index_6.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
+    return (0, index_7.IsString)(value) && value.toLowerCase() === 'null' ? null : value;
 }
 function TryConvertUndefined(value) {
-    return (0, index_6.IsString)(value) && value === 'undefined' ? undefined : value;
+    return (0, index_7.IsString)(value) && value === 'undefined' ? undefined : value;
 }
 // ------------------------------------------------------------------
 // note: this function may return an invalid dates for the regex
@@ -105,8 +106,8 @@ function TryConvertUndefined(value) {
 // ------------------------------------------------------------------
 // prettier-ignore
 function TryConvertDate(value) {
-    return ((0, index_6.IsDate)(value) ? value :
-        (0, index_6.IsNumber)(value) ? new Date(value) :
+    return ((0, index_7.IsDate)(value) ? value :
+        (0, index_7.IsNumber)(value) ? new Date(value) :
             IsValueTrue(value) ? new Date(1) :
                 IsValueFalse(value) ? new Date(0) :
                     IsStringNumeric(value) ? new Date(parseInt(value)) :
@@ -127,7 +128,7 @@ function Default(value) {
 // Convert
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
-    if ((0, index_6.IsArray)(value)) {
+    if ((0, index_7.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
@@ -148,7 +149,7 @@ function FromInteger(schema, references, value) {
 function FromIntersect(schema, references, value) {
     const allObjects = schema.allOf.every(schema => (0, type_1.IsObject)(schema));
     if (allObjects)
-        return Visit((0, index_5.Composite)(schema.allOf), references, value);
+        return Visit((0, index_6.Composite)(schema.allOf), references, value);
     return Visit(schema.allOf[0], references, value); // todo: fix this
 }
 function FromLiteral(schema, references, value) {
@@ -162,11 +163,11 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = (0, index_6.IsObject)(value);
+    const isConvertable = (0, index_7.IsObject)(value);
     if (!isConvertable)
         return value;
     return Object.getOwnPropertyNames(schema.properties).reduce((value, key) => {
-        return !(0, index_6.IsUndefined)(value[key])
+        return !(0, index_7.IsUndefined)(value[key])
             ? ({ ...value, [key]: Visit(schema.properties[key], references, value[key]) })
             : ({ ...value });
     }, value);
@@ -187,14 +188,14 @@ function FromString(schema, references, value) {
     return TryConvertString(value);
 }
 function FromSymbol(schema, references, value) {
-    return (0, index_6.IsString)(value) || (0, index_6.IsNumber)(value) ? Symbol(value) : value;
+    return (0, index_7.IsString)(value) || (0, index_7.IsNumber)(value) ? Symbol(value) : value;
 }
 function FromThis(schema, references, value) {
     return Visit((0, index_3.Deref)(schema, references), references, value);
 }
 // prettier-ignore
 function FromTuple(schema, references, value) {
-    const isConvertable = (0, index_6.IsArray)(value) && !(0, index_6.IsUndefined)(schema.items);
+    const isConvertable = (0, index_7.IsArray)(value) && !(0, index_7.IsUndefined)(schema.items);
     if (!isConvertable)
         return value;
     return value.map((value, index) => {
@@ -216,9 +217,9 @@ function FromUnion(schema, references, value) {
     return value;
 }
 function Visit(schema, references, value) {
-    const references_ = (0, index_6.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_7.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema[index_4.Kind]) {
+    switch (schema[index_5.Kind]) {
         case 'Array':
             return FromArray(schema_, references_, value);
         case 'BigInt':

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

@@ -1,26 +1,27 @@
+import { TypeBoxError } from '../../type/error/index';
 import type { TSchema } from '../../type/schema/index';
 import type { Static } from '../../type/static/index';
-export declare class ValueCreateUnknownTypeError extends Error {
+export declare class ValueCreateUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateNeverTypeError extends Error {
+export declare class ValueCreateNeverTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateNotTypeError extends Error {
+export declare class ValueCreateNotTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateIntersectTypeError extends Error {
+export declare class ValueCreateIntersectTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateTempateLiteralTypeError extends Error {
+export declare class ValueCreateTempateLiteralTypeError extends TypeBoxError {
     readonly schema: TSchema;
     constructor(schema: TSchema);
 }
-export declare class ValueCreateRecursiveInstantiationError extends Error {
+export declare class ValueCreateRecursiveInstantiationError extends TypeBoxError {
     readonly schema: TSchema;
     readonly recursiveMaxDepth: number;
     constructor(schema: TSchema, recursiveMaxDepth: number);

package/build/require/value/create/create.js

@@ -9,45 +9,46 @@ const index_4 = require("../../type/template-literal/index");
 const index_5 = require("../../type/patterns/index");
 const index_6 = require("../../type/registry/index");
 const index_7 = require("../../type/symbols/index");
+const index_8 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueCreateUnknownTypeError extends Error {
+class ValueCreateUnknownTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
 exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
-class ValueCreateNeverTypeError extends Error {
+class ValueCreateNeverTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super('Never types cannot be created');
         this.schema = schema;
     }
 }
 exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
-class ValueCreateNotTypeError extends Error {
+class ValueCreateNotTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super('Not types must have a default value');
         this.schema = schema;
     }
 }
 exports.ValueCreateNotTypeError = ValueCreateNotTypeError;
-class ValueCreateIntersectTypeError extends Error {
+class ValueCreateIntersectTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super('Intersect produced invalid value. Consider using a default value.');
         this.schema = schema;
     }
 }
 exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
-class ValueCreateTempateLiteralTypeError extends Error {
+class ValueCreateTempateLiteralTypeError extends index_8.TypeBoxError {
     constructor(schema) {
         super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
         this.schema = schema;
     }
 }
 exports.ValueCreateTempateLiteralTypeError = ValueCreateTempateLiteralTypeError;
-class ValueCreateRecursiveInstantiationError extends Error {
+class ValueCreateRecursiveInstantiationError extends index_8.TypeBoxError {
     constructor(schema, recursiveMaxDepth) {
         super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
         this.schema = schema;

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

@@ -1,4 +1,5 @@
 import type { Static } from '../../type/static/index';
+import { TypeBoxError } from '../../type/error/index';
 export type Insert = Static<typeof Insert>;
 export declare const Insert: import("../../type/object/object").TObject<{
     type: import("../../type/literal/literal").TLiteral<"insert">;
@@ -29,11 +30,11 @@ export declare const Edit: import("../../type/union/union-type").TUnion<[import(
     type: import("../../type/literal/literal").TLiteral<"delete">;
     path: import("../../type/string/string").TString;
 }>]>;
-export declare class ValueDeltaObjectWithSymbolKeyError extends Error {
+export declare class ValueDeltaObjectWithSymbolKeyError extends TypeBoxError {
     readonly key: unknown;
     constructor(key: unknown);
 }
-export declare class ValueDeltaUnableToDiffUnknownValue extends Error {
+export declare class ValueDeltaUnableToDiffUnknownValue extends TypeBoxError {
     readonly value: unknown;
     constructor(value: unknown);
 }

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

@@ -5,37 +5,38 @@ exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = expo
 const index_1 = require("../guard/index");
 const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
-const index_4 = require("../../type/literal/index");
-const index_5 = require("../../type/object/index");
-const index_6 = require("../../type/string/index");
-const index_7 = require("../../type/unknown/index");
-const index_8 = require("../../type/union/index");
-exports.Insert = (0, index_5.Object)({
-    type: (0, index_4.Literal)('insert'),
-    path: (0, index_6.String)(),
-    value: (0, index_7.Unknown)(),
+const index_4 = require("../../type/error/index");
+const index_5 = require("../../type/literal/index");
+const index_6 = require("../../type/object/index");
+const index_7 = require("../../type/string/index");
+const index_8 = require("../../type/unknown/index");
+const index_9 = require("../../type/union/index");
+exports.Insert = (0, index_6.Object)({
+    type: (0, index_5.Literal)('insert'),
+    path: (0, index_7.String)(),
+    value: (0, index_8.Unknown)(),
 });
-exports.Update = (0, index_5.Object)({
-    type: (0, index_4.Literal)('update'),
-    path: (0, index_6.String)(),
-    value: (0, index_7.Unknown)(),
+exports.Update = (0, index_6.Object)({
+    type: (0, index_5.Literal)('update'),
+    path: (0, index_7.String)(),
+    value: (0, index_8.Unknown)(),
 });
-exports.Delete = (0, index_5.Object)({
-    type: (0, index_4.Literal)('delete'),
-    path: (0, index_6.String)(),
+exports.Delete = (0, index_6.Object)({
+    type: (0, index_5.Literal)('delete'),
+    path: (0, index_7.String)(),
 });
-exports.Edit = (0, index_8.Union)([exports.Insert, exports.Update, exports.Delete]);
+exports.Edit = (0, index_9.Union)([exports.Insert, exports.Update, exports.Delete]);
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueDeltaObjectWithSymbolKeyError extends Error {
+class ValueDeltaObjectWithSymbolKeyError extends index_4.TypeBoxError {
     constructor(key) {
         super('Cannot diff objects with symbol keys');
         this.key = key;
     }
 }
 exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
-class ValueDeltaUnableToDiffUnknownValue extends Error {
+class ValueDeltaUnableToDiffUnknownValue extends index_4.TypeBoxError {
     constructor(value) {
         super('Unable to create diff edits for unknown value');
         this.value = value;

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

@@ -1,7 +1,8 @@
 import type { TSchema } from '../../type/schema/index';
 import type { TRef } from '../../type/ref/index';
 import type { TThis } from '../../type/recursive/index';
-export declare class TypeDereferenceError extends Error {
+import { TypeBoxError } from '../../type/error/index';
+export declare class TypeDereferenceError extends TypeBoxError {
     readonly schema: TRef | TThis;
     constructor(schema: TRef | TThis);
 }

package/build/require/value/deref/deref.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deref = exports.TypeDereferenceError = void 0;
-class TypeDereferenceError extends Error {
+const index_1 = require("../../type/error/index");
+class TypeDereferenceError extends index_1.TypeBoxError {
     constructor(schema) {
         super(`Unable to dereference schema with $id '${schema.$id}'`);
         this.schema = schema;

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

@@ -1,4 +1,5 @@
-export declare class ValueHashError extends Error {
+import { TypeBoxError } from '../../type/error/index';
+export declare class ValueHashError extends TypeBoxError {
     readonly value: unknown;
     constructor(value: unknown);
 }

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

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hash = exports.ValueHashError = void 0;
 const index_1 = require("../guard/index");
+const index_2 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueHashError extends Error {
+class ValueHashError extends index_2.TypeBoxError {
     constructor(value) {
         super(`Unable to hash value`);
         this.value = value;

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

@@ -1,7 +1,8 @@
-export declare class ValueMutateTypeMismatchError extends Error {
+import { TypeBoxError } from '../../type/error/index';
+export declare class ValueMutateTypeMismatchError extends TypeBoxError {
     constructor();
 }
-export declare class ValueMutateInvalidRootMutationError extends Error {
+export declare class ValueMutateInvalidRootMutationError extends TypeBoxError {
     constructor();
 }
 export type Mutable = {

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

@@ -5,16 +5,17 @@ exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMuta
 const index_1 = require("../guard/index");
 const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
+const index_4 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueMutateTypeMismatchError extends Error {
+class ValueMutateTypeMismatchError extends index_4.TypeBoxError {
     constructor() {
         super('Cannot assign due type mismatch of assignable values');
     }
 }
 exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
-class ValueMutateInvalidRootMutationError extends Error {
+class ValueMutateInvalidRootMutationError extends index_4.TypeBoxError {
     constructor() {
         super('Only object and array types can be mutated at the root level');
     }

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

@@ -1,10 +1,11 @@
-export declare class ValuePointerRootSetError extends Error {
+import { TypeBoxError } from '../../type/error/index';
+export declare class ValuePointerRootSetError extends TypeBoxError {
     readonly value: unknown;
     readonly path: string;
     readonly update: unknown;
     constructor(value: unknown, path: string, update: unknown);
 }
-export declare class ValuePointerRootDeleteError extends Error {
+export declare class ValuePointerRootDeleteError extends TypeBoxError {
     readonly value: unknown;
     readonly path: string;
     constructor(value: unknown, path: string);

package/build/require/value/pointer/pointer.js

@@ -2,10 +2,11 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Get = exports.Has = exports.Delete = exports.Set = exports.Format = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+const index_1 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValuePointerRootSetError extends Error {
+class ValuePointerRootSetError extends index_1.TypeBoxError {
     constructor(value, path, update) {
         super('Cannot set root value');
         this.value = value;
@@ -14,7 +15,7 @@ class ValuePointerRootSetError extends Error {
     }
 }
 exports.ValuePointerRootSetError = ValuePointerRootSetError;
-class ValuePointerRootDeleteError extends Error {
+class ValuePointerRootDeleteError extends index_1.TypeBoxError {
     constructor(value, path) {
         super('Cannot delete root value');
         this.value = value;