@sinclair/typebox 0.32.0-dev-22 → 0.32.0-dev-24

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;

package/build/require/value/transform/decode.d.ts

@@ -1,12 +1,13 @@
+import { TypeBoxError } from '../../type/error/index';
 import { ValueError } from '../../errors/index';
 import type { TSchema } from '../../type/schema/index';
-export declare class TransformDecodeCheckError extends Error {
+export declare class TransformDecodeCheckError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     readonly error: ValueError;
     constructor(schema: TSchema, value: unknown, error: ValueError);
 }
-export declare class TransformDecodeError extends Error {
+export declare class TransformDecodeError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);

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

@@ -3,14 +3,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformDecode = exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
 const index_1 = require("../../type/symbols/index");
-const index_2 = require("../../type/keyof/index");
-const index_3 = require("../../type/indexed/index");
-const index_4 = require("../deref/index");
-const index_5 = require("../check/index");
+const index_2 = require("../../type/error/index");
+const index_3 = require("../../type/keyof/index");
+const index_4 = require("../../type/indexed/index");
+const index_5 = require("../deref/index");
+const index_6 = require("../check/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-const index_6 = require("../guard/index");
+const index_7 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -19,7 +20,7 @@ const type_1 = require("../../type/guard/type");
 // Errors
 // ------------------------------------------------------------------
 // thrown externally
-class TransformDecodeCheckError extends Error {
+class TransformDecodeCheckError extends index_2.TypeBoxError {
     constructor(schema, value, error) {
         super(`Unable to decode due to invalid value`);
         this.schema = schema;
@@ -28,7 +29,7 @@ class TransformDecodeCheckError extends Error {
     }
 }
 exports.TransformDecodeCheckError = TransformDecodeCheckError;
-class TransformDecodeError extends Error {
+class TransformDecodeError extends index_2.TypeBoxError {
     constructor(schema, value, error) {
         super(`${error instanceof Error ? error.message : 'Unknown error'}`);
         this.schema = schema;
@@ -50,18 +51,18 @@ function Default(schema, value) {
 }
 // prettier-ignore
 function FromArray(schema, references, value) {
-    return ((0, index_6.IsArray)(value))
+    return ((0, index_7.IsArray)(value))
         ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
         : Default(schema, value);
 }
 // prettier-ignore
 function FromIntersect(schema, references, value) {
-    if (!(0, index_6.IsPlainObject)(value) || (0, index_6.IsValueType)(value))
+    if (!(0, index_7.IsPlainObject)(value) || (0, index_7.IsValueType)(value))
         return Default(schema, value);
-    const knownKeys = (0, index_2.KeyOfPropertyKeys)(schema);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
-            ? { ...value, [key]: Visit((0, index_3.Index)(schema, [key]), references, value[key]) }
+            ? { ...value, [key]: Visit((0, index_4.Index)(schema, [key]), references, value[key]) }
             : value;
     }, value);
     if (!(0, type_1.IsTransform)(schema.unevaluatedProperties)) {
@@ -81,9 +82,9 @@ function FromNot(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    if (!(0, index_6.IsPlainObject)(value))
+    if (!(0, index_7.IsPlainObject)(value))
         return Default(schema, value);
-    const knownKeys = (0, index_2.KeyOfPropertyKeys)(schema);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = knownKeys.reduce((value, key) => {
         return (key in value)
             ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
@@ -103,7 +104,7 @@ function FromObject(schema, references, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, value) {
-    if (!(0, index_6.IsPlainObject)(value))
+    if (!(0, index_7.IsPlainObject)(value))
         return Default(schema, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -126,24 +127,24 @@ function FromRecord(schema, references, value) {
 }
 // prettier-ignore
 function FromRef(schema, references, value) {
-    const target = (0, index_4.Deref)(schema, references);
+    const target = (0, index_5.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
 // prettier-ignore
 function FromThis(schema, references, value) {
-    const target = (0, index_4.Deref)(schema, references);
+    const target = (0, index_5.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
 // prettier-ignore
 function FromTuple(schema, references, value) {
-    return ((0, index_6.IsArray)(value) && (0, index_6.IsArray)(schema.items))
+    return ((0, index_7.IsArray)(value) && (0, index_7.IsArray)(schema.items))
         ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
         : Default(schema, value);
 }
 // prettier-ignore
 function FromUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
-        if (!(0, index_5.Check)(subschema, references, value))
+        if (!(0, index_6.Check)(subschema, references, value))
             continue;
         // note: ensure interior is decoded first
         const decoded = Visit(subschema, references, value);

package/build/require/value/transform/encode.d.ts

@@ -1,12 +1,13 @@
+import { TypeBoxError } from '../../type/error/index';
 import { ValueError } from '../../errors/index';
 import type { TSchema } from '../../type/schema/index';
-export declare class TransformEncodeCheckError extends Error {
+export declare class TransformEncodeCheckError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     readonly error: ValueError;
     constructor(schema: TSchema, value: unknown, error: ValueError);
 }
-export declare class TransformEncodeError extends Error {
+export declare class TransformEncodeError extends TypeBoxError {
     readonly schema: TSchema;
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);