@sinclair/typebox 0.24.20 → 0.24.23

package/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { ValueError } from '../value/errors';
+import { ValueError } from '../error/errors';
 import * as Types from '../typebox';
 export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {

package/compiler/compiler.js

@@ -28,7 +28,8 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCheck = void 0;
-const errors_1 = require("../value/errors");
+const errors_1 = require("../error/errors");
+const property_1 = require("./property");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -61,13 +62,13 @@ exports.TypeCheck = TypeCheck;
 var TypeCompiler;
 (function (TypeCompiler) {
     // -------------------------------------------------------------------
-    // Schemas
+    // Types
     // -------------------------------------------------------------------
     function* Any(schema, value) {
         yield '(true)';
     }
     function* Array(schema, value) {
-        const expression = [...Visit(schema.items, `value`)].map((condition) => condition).join(' && ');
+        const expression = CreateExpression(schema.items, 'value');
         if (schema.minItems !== undefined)
             yield `(${value}.length >= ${schema.minItems})`;
         if (schema.maxItems !== undefined)
@@ -143,13 +144,14 @@ var TypeCompiler;
             }
         }
         for (const propertyKey of propertyKeys) {
+            const memberExpression = property_1.Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
-                yield* Visit(propertySchema, `${value}.${propertyKey}`);
+                yield* Visit(propertySchema, memberExpression);
             }
             else {
-                const expr = [...Visit(propertySchema, `${value}.${propertyKey}`)].map((condition) => condition).join(' && ');
-                yield `(${value}.${propertyKey} === undefined ? true : (${expr}))`;
+                const expression = CreateExpression(propertySchema, memberExpression);
+                yield `(${memberExpression} === undefined ? true : (${expression}))`;
             }
         }
     }
@@ -159,25 +161,16 @@ var TypeCompiler;
     function* Record(schema, value) {
         yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const local = PushLocal(`const local = new RegExp(/${keyPattern}/)`);
+        const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.keys(${value}).every(key => ${local}.test(key)))`;
-        const expr = [...Visit(valueSchema, 'value')].map((condition) => condition).join(' && ');
-        yield `(Object.values(${value}).every(value => ${expr}))`;
+        const expression = CreateExpression(valueSchema, 'value');
+        yield `(Object.values(${value}).every(value => ${expression}))`;
     }
     function* Ref(schema, value) {
-        // reference: referenced schemas can originate from either additional
-        // schemas or inline in the schema itself. Ideally the recursive
-        // path should align to reference path. Consider for review.
-        if (!functionNames.has(schema.$ref)) {
-            const reference = referenceMap.get(schema.$ref);
-            functionNames.add(schema.$ref);
-            const conditions = [...Visit(reference, 'value')];
-            const name = CreateFunctionName(schema.$ref);
-            const body = CreateFunction(name, conditions);
-            PushLocal(body);
-        }
-        const func = CreateFunctionName(schema.$ref);
-        yield `(${func}(${value}))`;
+        if (!referenceMap.has(schema.$ref))
+            throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
+        const reference = referenceMap.get(schema.$ref);
+        yield* Visit(reference, value);
     }
     function* Self(schema, value) {
         const func = CreateFunctionName(schema.$ref);
@@ -192,7 +185,7 @@ var TypeCompiler;
             yield `(${value}.length <= ${schema.maxLength})`;
         }
         if (schema.pattern !== undefined) {
-            const local = PushLocal(`const local = new RegExp(/${schema.pattern}/);`);
+            const local = PushLocal(`new RegExp(/${schema.pattern}/);`);
             yield `(${local}.test(${value}))`;
         }
     }
@@ -202,16 +195,16 @@ var TypeCompiler;
             return yield `(${value}.length === 0)`;
         yield `(${value}.length === ${schema.maxItems})`;
         for (let i = 0; i < schema.items.length; i++) {
-            const expr = [...Visit(schema.items[i], `${value}[${i}]`)].map((condition) => condition).join(' && ');
-            yield `(${expr})`;
+            const expression = CreateExpression(schema.items[i], `${value}[${i}]`);
+            yield `(${expression})`;
         }
     }
     function* Undefined(schema, value) {
         yield `(${value} === undefined)`;
     }
     function* Union(schema, value) {
-        const exprs = schema.anyOf.map((schema) => [...Visit(schema, value)].map((condition) => condition).join(' && '));
-        yield `(${exprs.join(' || ')})`;
+        const expressions = schema.anyOf.map((schema) => CreateExpression(schema, value));
+        yield `(${expressions.join(' || ')})`;
     }
     function* Uint8Array(schema, value) {
         yield `(${value} instanceof Uint8Array)`;
@@ -230,12 +223,11 @@ var TypeCompiler;
         // reference: referenced schemas can originate from either additional
         // schemas or inline in the schema itself. Ideally the recursive
         // path should align to reference path. Consider for review.
-        if (schema.$id && !functionNames.has(schema.$id)) {
-            functionNames.add(schema.$id);
-            const conditions = [...Visit(schema, 'value')];
+        if (schema.$id && !names.has(schema.$id)) {
+            names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
-            const body = CreateFunction(name, conditions);
-            PushLocal(body);
+            const body = CreateFunction(name, schema, 'value');
+            PushFunction(body);
             yield `(${name}(${value}))`;
             return;
         }
@@ -288,17 +280,17 @@ var TypeCompiler;
         }
     }
     // -------------------------------------------------------------------
-    // Locals
+    // Compile State
     // -------------------------------------------------------------------
     const referenceMap = new Map();
-    const functionLocals = new Set();
-    const functionNames = new Set();
-    function ClearLocals() {
-        functionLocals.clear();
-        functionNames.clear();
+    const locals = new Set(); // local variables and functions
+    const names = new Set(); // cache of local functions
+    function ResetCompiler() {
         referenceMap.clear();
+        locals.clear();
+        names.clear();
     }
-    function PushReferences(schemas = []) {
+    function AddReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
                 throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
@@ -307,33 +299,36 @@ var TypeCompiler;
             referenceMap.set(schema.$id, schema);
         }
     }
-    function PushLocal(code) {
-        const name = `local${functionLocals.size}`;
-        functionLocals.add(code.replace('local', name));
-        return name;
-    }
-    function GetLocals() {
-        return [...functionLocals.values()];
+    function CreateExpression(schema, value) {
+        return [...Visit(schema, value)].join(' && ');
     }
-    // -------------------------------------------------------------------
-    // Functions
-    // -------------------------------------------------------------------
     function CreateFunctionName($id) {
         return `check_${$id.replace(/-/g, '_')}`;
     }
-    function CreateFunction(name, conditions) {
-        const expression = conditions.map((condition) => `    ${condition}`).join(' &&\n');
+    function CreateFunction(name, schema, value) {
+        const expression = [...Visit(schema, value)].map((condition) => `    ${condition}`).join(' &&\n');
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
+    function PushFunction(functionBody) {
+        locals.add(functionBody);
+    }
+    function PushLocal(expression) {
+        const local = `local_${locals.size}`;
+        locals.add(`const ${local} = ${expression}`);
+        return local;
+    }
+    function GetLocals() {
+        return [...locals.values()];
+    }
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
     function Build(schema, references = []) {
-        ClearLocals();
-        PushReferences(references);
-        const conditions = [...Visit(schema, 'value')]; // locals populated during yield
+        ResetCompiler();
+        AddReferences(references);
+        const check = CreateFunction('check', schema, 'value');
         const locals = GetLocals();
-        return `${locals.join('\n')}\nreturn ${CreateFunction('check', conditions)}`;
+        return `${locals.join('\n')}\nreturn ${check}`;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {

package/compiler/index.d.ts

@@ -1,2 +1,2 @@
-export type { ValueError } from '../value/errors';
+export { ValueError, ValueErrorType } from '../error/errors';
 export * from './compiler';

package/compiler/index.js

@@ -41,4 +41,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrorType = void 0;
+var errors_1 = require("../error/errors");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
 __exportStar(require("./compiler"), exports);

package/compiler/property.d.ts

@@ -0,0 +1,4 @@
+export declare namespace Property {
+    /** Tests if this property name can be used in a member expression */
+    function Check(propertyName: string): boolean;
+}

package/compiler/property.js

@@ -0,0 +1,64 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = void 0;
+var Property;
+(function (Property) {
+    function DollarSign(char) {
+        return char === 36;
+    }
+    function Underscore(char) {
+        return char === 95;
+    }
+    function Numeric(char) {
+        return char >= 48 && char <= 57;
+    }
+    function Alpha(char) {
+        return (char >= 65 && char <= 90) || (char >= 97 && char <= 122);
+    }
+    /** Tests if this property name can be used in a member expression */
+    function Check(propertyName) {
+        if (propertyName.length === 0)
+            return false;
+        {
+            const code = propertyName.charCodeAt(0);
+            if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
+                return false;
+            }
+        }
+        for (let i = 1; i < propertyName.length; i++) {
+            const code = propertyName.charCodeAt(i);
+            if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Property.Check = Check;
+})(Property = exports.Property || (exports.Property = {}));

package/error/errors.d.ts

@@ -0,0 +1,52 @@
+import * as Types from '../typebox';
+export declare enum ValueErrorType {
+    Array = 0,
+    ArrayMinItems = 1,
+    ArrayMaxItems = 2,
+    ArrayUniqueItems = 3,
+    Boolean = 4,
+    Function = 5,
+    Integer = 6,
+    IntegerMultipleOf = 7,
+    IntegerExclusiveMinimum = 8,
+    IntegerExclusiveMaximum = 9,
+    IntegerMinimum = 10,
+    IntegerMaximum = 11,
+    Literal = 12,
+    Null = 13,
+    Number = 14,
+    NumberMultipleOf = 15,
+    NumberExclusiveMinimum = 16,
+    NumberExclusiveMaximum = 17,
+    NumberMinumum = 18,
+    NumberMaximum = 19,
+    Object = 20,
+    ObjectMinProperties = 21,
+    ObjectMaxProperties = 22,
+    ObjectAdditionalProperties = 23,
+    Promise = 24,
+    RecordKeyNumeric = 25,
+    RecordKeyString = 26,
+    String = 27,
+    StringMinLength = 28,
+    StringMaxLength = 29,
+    StringPattern = 30,
+    TupleZeroLength = 31,
+    TupleLength = 32,
+    Undefined = 33,
+    Union = 34,
+    Uint8Array = 35,
+    Uint8ArrayMinByteLength = 36,
+    Uint8ArrayMaxByteLength = 37,
+    Void = 38
+}
+export interface ValueError {
+    type: ValueErrorType;
+    schema: Types.TSchema;
+    path: string;
+    value: unknown;
+    message: string;
+}
+export declare namespace ValueErrors {
+    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
+}

package/{value → error}/errors.js

@@ -27,23 +27,71 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = void 0;
+exports.ValueErrors = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
+// -------------------------------------------------------------------
+// ValueErrorType
+// -------------------------------------------------------------------
+var ValueErrorType;
+(function (ValueErrorType) {
+    ValueErrorType[ValueErrorType["Array"] = 0] = "Array";
+    ValueErrorType[ValueErrorType["ArrayMinItems"] = 1] = "ArrayMinItems";
+    ValueErrorType[ValueErrorType["ArrayMaxItems"] = 2] = "ArrayMaxItems";
+    ValueErrorType[ValueErrorType["ArrayUniqueItems"] = 3] = "ArrayUniqueItems";
+    ValueErrorType[ValueErrorType["Boolean"] = 4] = "Boolean";
+    ValueErrorType[ValueErrorType["Function"] = 5] = "Function";
+    ValueErrorType[ValueErrorType["Integer"] = 6] = "Integer";
+    ValueErrorType[ValueErrorType["IntegerMultipleOf"] = 7] = "IntegerMultipleOf";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMinimum"] = 8] = "IntegerExclusiveMinimum";
+    ValueErrorType[ValueErrorType["IntegerExclusiveMaximum"] = 9] = "IntegerExclusiveMaximum";
+    ValueErrorType[ValueErrorType["IntegerMinimum"] = 10] = "IntegerMinimum";
+    ValueErrorType[ValueErrorType["IntegerMaximum"] = 11] = "IntegerMaximum";
+    ValueErrorType[ValueErrorType["Literal"] = 12] = "Literal";
+    ValueErrorType[ValueErrorType["Null"] = 13] = "Null";
+    ValueErrorType[ValueErrorType["Number"] = 14] = "Number";
+    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 15] = "NumberMultipleOf";
+    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 16] = "NumberExclusiveMinimum";
+    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 17] = "NumberExclusiveMaximum";
+    ValueErrorType[ValueErrorType["NumberMinumum"] = 18] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMaximum"] = 19] = "NumberMaximum";
+    ValueErrorType[ValueErrorType["Object"] = 20] = "Object";
+    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 21] = "ObjectMinProperties";
+    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 22] = "ObjectMaxProperties";
+    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 23] = "ObjectAdditionalProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 24] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 25] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 26] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 27] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 28] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 29] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 30] = "StringPattern";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 31] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 32] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 33] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 34] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 35] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 36] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 37] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 38] = "Void";
+})(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
+// -------------------------------------------------------------------
+// ValueErrors
+// -------------------------------------------------------------------
 var ValueErrors;
 (function (ValueErrors) {
     function* Any(schema, references, path, value) { }
     function* Array(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
-            return yield { schema, path, value, message: `Expected array` };
+            return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` };
         }
         if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
-            yield { schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
+            yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
         }
         if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
-            yield { schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
+            yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
         }
         if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
-            yield { schema, path, value, message: `Expected array elements to be unique` };
+            yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` };
         }
         for (let i = 0; i < value.length; i++) {
             yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
@@ -51,7 +99,7 @@ var ValueErrors;
     }
     function* Boolean(schema, references, path, value) {
         if (!(typeof value === 'boolean')) {
-            return yield { schema, path, value, message: `Expected boolean` };
+            return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` };
         }
     }
     function* Constructor(schema, references, path, value) {
@@ -59,78 +107,78 @@ var ValueErrors;
     }
     function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {
-            return yield { schema, path, value, message: `Expected function` };
+            return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` };
         }
     }
     function* Integer(schema, references, path, value) {
         if (!(typeof value === 'number')) {
-            return yield { schema, path, value, message: `Expected number` };
+            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
         }
         if (!globalThis.Number.isInteger(value)) {
-            yield { schema, path, value, message: `Expected integer` };
+            yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
         }
         if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
-            yield { schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
+            yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
         }
         if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
-            yield { schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
+            yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
         }
         if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
-            yield { schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
+            yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
         }
         if (schema.minimum && !(value >= schema.minimum)) {
-            yield { schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
+            yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
         }
         if (schema.maximum && !(value <= schema.maximum)) {
-            yield { schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
+            yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
         }
     }
     function* Literal(schema, references, path, value) {
         if (!(value === schema.const)) {
             const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
-            return yield { schema, path, value, message: `Expected ${error}` };
+            return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` };
         }
     }
     function* Null(schema, references, path, value) {
         if (!(value === null)) {
-            return yield { schema, path, value, message: `Expected null` };
+            return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` };
         }
     }
     function* Number(schema, references, path, value) {
         if (!(typeof value === 'number')) {
-            return yield { schema, path, value, message: `Expected number` };
+            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
         }
         if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
-            yield { schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
+            yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
         }
         if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
-            yield { schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
+            yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
         }
         if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
-            yield { schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
+            yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
         }
         if (schema.minimum && !(value >= schema.minimum)) {
-            yield { schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
+            yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
         }
         if (schema.maximum && !(value <= schema.maximum)) {
-            yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
+            yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
     function* Object(schema, references, path, value) {
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { schema, path, value, message: `Expected object` };
+            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
         }
         if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
-            yield { schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
+            yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
         }
         if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
-            yield { schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
+            yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
         }
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
             for (const propKey of globalThis.Object.keys(value)) {
                 if (!propertyKeys.includes(propKey)) {
-                    yield { schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
+                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
                 }
             }
         }
@@ -148,18 +196,20 @@ var ValueErrors;
     }
     function* Promise(schema, references, path, value) {
         if (!(typeof value === 'object' && typeof value.then === 'function')) {
-            yield { schema, path, value, message: `Expected Promise` };
+            yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` };
         }
     }
     function* Record(schema, references, path, value) {
         if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { schema, path, value, message: `Expected object` };
+            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
         if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
-            const message = keyPattern === '^(0|[1-9][0-9]*)$' ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
-            return yield { schema, path, value, message };
+            const numeric = keyPattern === '^(0|[1-9][0-9]*)$';
+            const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString;
+            const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
+            return yield { type, schema, path, value, message };
         }
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
             yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
@@ -179,30 +229,30 @@ var ValueErrors;
     }
     function* String(schema, references, path, value) {
         if (!(typeof value === 'string')) {
-            return yield { schema, path, value, message: 'Expected string' };
+            return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
         }
         if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
-            yield { schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
+            yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
         }
         if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
-            yield { schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
+            yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
         }
         if (schema.pattern !== undefined) {
             const regex = new RegExp(schema.pattern);
             if (!regex.test(value)) {
-                yield { schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
+                yield { type: ValueErrorType.StringPattern, schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
             }
         }
     }
     function* Tuple(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
-            return yield { schema, path, value, message: 'Expected Array' };
+            return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' };
         }
         if (schema.items === undefined && !(value.length === 0)) {
-            return yield { schema, path, value, message: 'Expected tuple to have 0 elements' };
+            return yield { type: ValueErrorType.TupleZeroLength, schema, path, value, message: 'Expected tuple to have 0 elements' };
         }
         if (!(value.length === schema.maxItems)) {
-            yield { schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` };
+            yield { type: ValueErrorType.TupleLength, schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` };
         }
         if (!schema.items) {
             return;
@@ -213,7 +263,7 @@ var ValueErrors;
     }
     function* Undefined(schema, references, path, value) {
         if (!(value === undefined)) {
-            yield { schema, path, value, message: `Expected undefined` };
+            yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` };
         }
     }
     function* Union(schema, references, path, value) {
@@ -228,24 +278,24 @@ var ValueErrors;
             yield error;
         }
         if (errors.length > 0) {
-            yield { schema, path, value, message: 'Expected value of union' };
+            yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' };
         }
     }
     function* Uint8Array(schema, references, path, value) {
         if (!(value instanceof globalThis.Uint8Array)) {
-            return yield { schema, path, value, message: `Expected Uint8Array` };
+            return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` };
         }
         if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
-            yield { schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
+            yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
         }
         if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
-            yield { schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
+            yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
         }
     }
     function* Unknown(schema, references, path, value) { }
     function* Void(schema, references, path, value) {
         if (!(value === null)) {
-            return yield { schema, path, value, message: `Expected null` };
+            return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` };
         }
     }
     function* Visit(schema, references, path, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.20",
+  "version": "0.24.23",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -47,30 +47,30 @@ type T = Static<typeof T>   // type T = string
 
 TypeBox is a type builder library that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create unified types that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate data received over the wire. It offers a type system aligned to the capabilities of TypeScript and can be used equally well in JavaScript environments.
+TypeBox can be used as a simple tool to build up complex schemas or integrated into RPC or REST services to help validate JSON data received over the wire.
 
 License MIT
 
 ## Contents
-- [Install](#Install)
-- [Overview](#Overview)
-- [Usage](#Usage)
-- [Types](#Types)
-- [Modifiers](#Modifiers)
-- [Options](#Options)
-- [Extended Types](#Extended-Types)
-- [Reference Types](#Reference-Types)
-- [Recursive Types](#Recursive-Types)
-- [Generic Types](#Generic-Types)
-- [Unsafe Types](#Unsafe-Types)
-- [Conditional Types](#Conditional-Types)
-- [Values](#Values)
-- [Guards](#Guards)
-- [Strict](#Strict)
-- [Validation](#Validation)
-- [Compiler](#Compiler)
-- [Benchmark](#Benchmark)
-- [Contribute](#Contribute)
+- [Install](#install)
+- [Overview](#overview)
+- [Usage](#usage)
+- [Types](#types)
+- [Modifiers](#modifiers)
+- [Options](#options)
+- [Extended Types](#extended-types)
+- [Reference Types](#reference-types)
+- [Recursive Types](#recursive-types)
+- [Generic Types](#generic-types)
+- [Unsafe Types](#unsafe-types)
+- [Conditional Types](#conditional-types)
+- [Values](#values)
+- [Guards](#guards)
+- [Strict](#strict)
+- [Validation](#validation)
+- [Compiler](#compiler)
+- [Benchmark](#benchmark)
+- [Contribute](#contribute)
 
 <a name="Example"></a>
 
@@ -147,8 +147,6 @@ function receive(value: T) {                         // ... as a Type
 }
 ```
 
-<a name="Types"></a>
-
 ## Types
 
 The following table outlines the TypeBox mappings between TypeScript and JSON schema.
@@ -342,7 +340,6 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 │                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
-<a name="Modifiers"></a>
 
 ## Modifiers
 
@@ -386,8 +383,6 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Options"></a>
-
 ## Options
 
 You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
@@ -403,8 +398,6 @@ const T = Type.Number({ multipleOf: 2 })
 const T = Type.Array(Type.Integer(), { minItems: 5 })
 ```
 
-<a name="Extended-Types"></a>
-
 ## Extended Types
 
 In addition to JSON schema types, TypeBox provides several extended types that allow for `function` and `constructor` types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
@@ -467,8 +460,6 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Reference-Types"></a>
-
 ## Reference Types
 
 Use `Type.Ref(...)` to create referenced types. The target type must specify an `$id`.
@@ -484,8 +475,6 @@ const R = Type.Ref(T)                                // const R = {
                                                      // }
 ```
 
-<a name="Recursive-Types"></a>
-
 ## Recursive Types
 
 Use `Type.Recursive(...)` to create recursive types.
@@ -524,11 +513,9 @@ function test(node: Node) {
 }
 ```
 
-<a name="Generic-Types"></a>
-
 ## Generic Types
 
-Generic types can be created using functions. The following creates a generic `Nullable<T>` type. 
+Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -556,8 +543,6 @@ const U = Nullable(Type.Number())                    // const U = {
 type U = Static<typeof U>                            // type U = number | null
 ```
 
-<a name="Unsafe-Types"></a>
-
 ## Unsafe Types
 
 Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
@@ -594,12 +579,12 @@ type T = Static<typeof T>                            // type T = string | null
 
 //--------------------------------------------------------------------------------------------
 //
-// StringUnion<[...]>
+// StringEnum<string[]>
 //
 //--------------------------------------------------------------------------------------------
 
 function StringEnum<T extends string[]>(values: [...T]) {
-  return Type.Unsafe<T[number]>({ enum: values })
+  return Type.Unsafe<T[number]>({ type: 'string', enum: values })
 }
 
 const T = StringEnum(['A', 'B', 'C'])                // const T = {
@@ -609,8 +594,6 @@ const T = StringEnum(['A', 'B', 'C'])                // const T = {
 type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 ```
 
-<a name="Conditional-Types"></a>
-
 ## Conditional Types
 
 Use `Conditional.Extends(...)` to create conditional mapped types.
@@ -660,8 +643,6 @@ The following table shows the TypeBox mappings between TypeScript and JSON schem
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
-<a name="Values"></a>
-
 ## Values
 
 Use `Value.Create(...)` to generate values from types.
@@ -697,8 +678,6 @@ const B = Value.Cast(T, { x: 1 })                      // const B = { x: 1, y: 0
 const C = Value.Cast(T, { x: 1, y: 2, z: 3 })          // const C = { x: 1, y: 2 }
 ```
 
-<a name="Guards"></a>
-
 ## Guards
 
 Use a `TypeGuard` to test if a value meets a TypeBox type specification. Guards can be helpful when reflecting types.
@@ -716,8 +695,6 @@ if(TypeGuard.TString(T)) {
 
 ```
 
-<a name="Strict"></a>
-
 ## Strict
 
 TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox internally compose types. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
@@ -745,8 +722,6 @@ const U = Type.Strict(T)                             // const U = {
                                                      // }
 ```
 
-<a name="Validation"></a>
-
 ## Validation
 
 TypeBox schemas target JSON Schema draft 6 so any validator capable of draft 6 should be fine. A good library to use for validation in JavaScript environments is [Ajv](https://www.npmjs.com/package/ajv). The following example shows setting up Ajv to work with TypeBox.
@@ -812,8 +787,6 @@ const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
 
 Please refer to the official Ajv [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using Ajv.
 
-<a name="Compiler"></a>
-
 ## Compiler
 
 TypeBox provides an optional high performance runtime type checker that can be used in applications that require extremely fast validation. This type checker is optimized for TypeBox types only whose schematics are known in advance. If defining custom schemas with `Type.Unsafe<T>` please consider Ajv.
@@ -845,16 +818,19 @@ const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObje
 const value = { }
 
 const errors = [...C.Errors(value)]                  // const errors = [{
+                                                     //   type: ValueErrorType.Number,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/x',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
+                                                     //   type: ValueErrorType.Number,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/y',
                                                      //   value: undefined,
                                                      //   message: 'Expected number'
                                                      // }, {
+                                                     //   type: ValueErrorType.Number,
                                                      //   schema: { type: 'number' },
                                                      //   path: '/z',
                                                      //   value: undefined,
@@ -874,9 +850,13 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
+
+
 ## Benchmark
 
-This project maintains benchmarks that measure Ajv and TypeCompiler validate and compile performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. Results show against Ajv version 8.11.0.
+This project maintains a set of benchmarks that measure Ajv and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 
+
+For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
 ### Validate
 
@@ -886,31 +866,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  16000000  │ '     73 ms' │ '     65 ms' │ '    1.12 x' │
-│           String │  16000000  │ '    281 ms' │ '    161 ms' │ '    1.75 x' │
-│          Boolean │  16000000  │ '    302 ms' │ '    151 ms' │ '    2.00 x' │
-│             Null │  16000000  │ '    281 ms' │ '    149 ms' │ '    1.89 x' │
-│            RegEx │  16000000  │ '    689 ms' │ '    550 ms' │ '    1.25 x' │
-│          ObjectA │  16000000  │ '    470 ms' │ '    311 ms' │ '    1.51 x' │
-│          ObjectB │  16000000  │ '    667 ms' │ '    556 ms' │ '    1.20 x' │
-│            Tuple │  16000000  │ '    362 ms' │ '    190 ms' │ '    1.91 x' │
-│            Union │  16000000  │ '    387 ms' │ '    209 ms' │ '    1.85 x' │
-│        Recursive │  16000000  │ '   6327 ms' │ '   2773 ms' │ '    2.28 x' │
-│          Vector4 │  16000000  │ '    362 ms' │ '    172 ms' │ '    2.10 x' │
-│          Matrix4 │  16000000  │ '    607 ms' │ '    418 ms' │ '    1.45 x' │
-│   Literal_String │  16000000  │ '    314 ms' │ '    151 ms' │ '    2.08 x' │
-│   Literal_Number │  16000000  │ '    281 ms' │ '    147 ms' │ '    1.91 x' │
-│  Literal_Boolean │  16000000  │ '    289 ms' │ '    148 ms' │ '    1.95 x' │
-│     Array_Number │  16000000  │ '    475 ms' │ '    230 ms' │ '    2.07 x' │
-│     Array_String │  16000000  │ '    463 ms' │ '    297 ms' │ '    1.56 x' │
-│    Array_Boolean │  16000000  │ '    521 ms' │ '    348 ms' │ '    1.50 x' │
-│    Array_ObjectA │  16000000  │ '  43842 ms' │ '  28375 ms' │ '    1.55 x' │
-│    Array_ObjectB │  16000000  │ '  45055 ms' │ '  32882 ms' │ '    1.37 x' │
-│      Array_Tuple │  16000000  │ '   1424 ms' │ '   1105 ms' │ '    1.29 x' │
-│      Array_Union │  16000000  │ '   3505 ms' │ '   1350 ms' │ '    2.60 x' │
-│  Array_Recursive │  16000000  │ ' 117087 ms' │ '  42982 ms' │ '    2.72 x' │
-│    Array_Vector4 │  16000000  │ '   1500 ms' │ '    817 ms' │ '    1.84 x' │
-│    Array_Matrix4 │  16000000  │ '   6126 ms' │ '   4965 ms' │ '    1.23 x' │
+│           Number │  4000000   │ '     17 ms' │ '     16 ms' │ '    1.06 x' │
+│           String │  4000000   │ '     74 ms' │ '     37 ms' │ '    2.00 x' │
+│          Boolean │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
+│             Null │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
+│            RegEx │  4000000   │ '    170 ms' │ '    143 ms' │ '    1.19 x' │
+│          ObjectA │  4000000   │ '    122 ms' │ '     84 ms' │ '    1.45 x' │
+│          ObjectB │  4000000   │ '    182 ms' │ '    137 ms' │ '    1.33 x' │
+│            Tuple │  4000000   │ '     82 ms' │ '     48 ms' │ '    1.71 x' │
+│            Union │  4000000   │ '     84 ms' │ '     52 ms' │ '    1.62 x' │
+│        Recursive │  4000000   │ '   1526 ms' │ '    631 ms' │ '    2.42 x' │
+│          Vector4 │  4000000   │ '     80 ms' │ '     42 ms' │ '    1.90 x' │
+│          Matrix4 │  4000000   │ '    157 ms' │ '    113 ms' │ '    1.39 x' │
+│   Literal_String │  4000000   │ '     69 ms' │ '     36 ms' │ '    1.92 x' │
+│   Literal_Number │  4000000   │ '     69 ms' │ '     35 ms' │ '    1.97 x' │
+│  Literal_Boolean │  4000000   │ '     68 ms' │ '     35 ms' │ '    1.94 x' │
+│     Array_Number │  4000000   │ '    119 ms' │ '     60 ms' │ '    1.98 x' │
+│     Array_String │  4000000   │ '    119 ms' │ '     76 ms' │ '    1.57 x' │
+│    Array_Boolean │  4000000   │ '    131 ms' │ '     88 ms' │ '    1.49 x' │
+│    Array_ObjectA │  4000000   │ '  10615 ms' │ '   7053 ms' │ '    1.51 x' │
+│    Array_ObjectB │  4000000   │ '  11305 ms' │ '   8128 ms' │ '    1.39 x' │
+│      Array_Tuple │  4000000   │ '    355 ms' │ '    271 ms' │ '    1.31 x' │
+│      Array_Union │  4000000   │ '    910 ms' │ '    340 ms' │ '    2.68 x' │
+│  Array_Recursive │  4000000   │ '  29101 ms' │ '  10837 ms' │ '    2.69 x' │
+│    Array_Vector4 │  4000000   │ '    381 ms' │ '    212 ms' │ '    1.80 x' │
+│    Array_Matrix4 │  4000000   │ '   1534 ms' │ '   1344 ms' │ '    1.14 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -922,34 +902,32 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    387 ms' │ '      7 ms' │ '   55.29 x' │
-│           String │    2000    │ '    340 ms' │ '      6 ms' │ '   56.67 x' │
-│          Boolean │    2000    │ '    314 ms' │ '      5 ms' │ '   62.80 x' │
-│             Null │    2000    │ '    259 ms' │ '      5 ms' │ '   51.80 x' │
-│            RegEx │    2000    │ '    491 ms' │ '      7 ms' │ '   70.14 x' │
-│          ObjectA │    2000    │ '   2850 ms' │ '     26 ms' │ '  109.62 x' │
-│          ObjectB │    2000    │ '   2989 ms' │ '     22 ms' │ '  135.86 x' │
-│            Tuple │    2000    │ '   1283 ms' │ '     17 ms' │ '   75.47 x' │
-│            Union │    2000    │ '   1292 ms' │ '     16 ms' │ '   80.75 x' │
-│          Vector4 │    2000    │ '   1588 ms' │ '     12 ms' │ '  132.33 x' │
-│          Matrix4 │    2000    │ '    934 ms' │ '      7 ms' │ '  133.43 x' │
-│   Literal_String │    2000    │ '    340 ms' │ '      5 ms' │ '   68.00 x' │
-│   Literal_Number │    2000    │ '    402 ms' │ '      4 ms' │ '  100.50 x' │
-│  Literal_Boolean │    2000    │ '    381 ms' │ '      6 ms' │ '   63.50 x' │
-│     Array_Number │    2000    │ '    750 ms' │ '      8 ms' │ '   93.75 x' │
-│     Array_String │    2000    │ '    760 ms' │ '      6 ms' │ '  126.67 x' │
-│    Array_Boolean │    2000    │ '    796 ms' │ '      7 ms' │ '  113.71 x' │
-│    Array_ObjectA │    2000    │ '   3617 ms' │ '     26 ms' │ '  139.12 x' │
-│    Array_ObjectB │    2000    │ '   3823 ms' │ '     26 ms' │ '  147.04 x' │
-│      Array_Tuple │    2000    │ '   2263 ms' │ '     13 ms' │ '  174.08 x' │
-│      Array_Union │    2000    │ '   1725 ms' │ '     16 ms' │ '  107.81 x' │
-│    Array_Vector4 │    2000    │ '   2445 ms' │ '     14 ms' │ '  174.64 x' │
-│    Array_Matrix4 │    2000    │ '   1638 ms' │ '     11 ms' │ '  148.91 x' │
+│           Number │    2000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
+│           String │    2000    │ '    311 ms' │ '      6 ms' │ '   51.83 x' │
+│          Boolean │    2000    │ '    304 ms' │ '      5 ms' │ '   60.80 x' │
+│             Null │    2000    │ '    252 ms' │ '      5 ms' │ '   50.40 x' │
+│            RegEx │    2000    │ '    480 ms' │ '      7 ms' │ '   68.57 x' │
+│          ObjectA │    2000    │ '   2786 ms' │ '     27 ms' │ '  103.19 x' │
+│          ObjectB │    2000    │ '   2946 ms' │ '     22 ms' │ '  133.91 x' │
+│            Tuple │    2000    │ '   1277 ms' │ '     16 ms' │ '   79.81 x' │
+│            Union │    2000    │ '   1288 ms' │ '     16 ms' │ '   80.50 x' │
+│          Vector4 │    2000    │ '   1628 ms' │ '     12 ms' │ '  135.67 x' │
+│          Matrix4 │    2000    │ '    912 ms' │ '      7 ms' │ '  130.29 x' │
+│   Literal_String │    2000    │ '    344 ms' │ '      5 ms' │ '   68.80 x' │
+│   Literal_Number │    2000    │ '    432 ms' │ '      5 ms' │ '   86.40 x' │
+│  Literal_Boolean │    2000    │ '    407 ms' │ '      4 ms' │ '  101.75 x' │
+│     Array_Number │    2000    │ '    788 ms' │ '      9 ms' │ '   87.56 x' │
+│     Array_String │    2000    │ '    823 ms' │ '      7 ms' │ '  117.57 x' │
+│    Array_Boolean │    2000    │ '    816 ms' │ '      5 ms' │ '  163.20 x' │
+│    Array_ObjectA │    2000    │ '   4270 ms' │ '     24 ms' │ '  177.92 x' │
+│    Array_ObjectB │    2000    │ '   4008 ms' │ '     28 ms' │ '  143.14 x' │
+│      Array_Tuple │    2000    │ '   2243 ms' │ '     13 ms' │ '  172.54 x' │
+│      Array_Union │    2000    │ '   1734 ms' │ '     16 ms' │ '  108.38 x' │
+│    Array_Vector4 │    2000    │ '   2348 ms' │ '     14 ms' │ '  167.71 x' │
+│    Array_Matrix4 │    2000    │ '   1608 ms' │ '     11 ms' │ '  146.18 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
-<a name="Contribute"></a>
-
 ## Contribute
 
 TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.

package/value/index.d.ts

@@ -1,2 +1,2 @@
-export type { ValueError } from './errors';
+export { ValueError, ValueErrorType } from '../error/errors';
 export * from './value';

package/value/index.js

@@ -41,4 +41,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueErrorType = void 0;
+var errors_1 = require("../error/errors");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return errors_1.ValueErrorType; } });
 __exportStar(require("./value"), exports);

package/value/value.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-import { ValueError } from './errors';
+import { ValueError } from '../error/errors';
 /** Creates Values from TypeBox Types */
 export declare namespace Value {
     /** Creates a value from the given type */

package/value/value.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
-const errors_1 = require("./errors");
+const errors_1 = require("../error/errors");
 const cast_1 = require("./cast");
 const create_1 = require("./create");
 const check_1 = require("./check");

package/value/errors.d.ts

@@ -1,10 +0,0 @@
-import * as Types from '../typebox';
-export interface ValueError {
-    schema: Types.TSchema;
-    path: string;
-    value: unknown;
-    message: string;
-}
-export declare namespace ValueErrors {
-    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
-}