@sinclair/typebox 0.30.4 → 0.31.0-dev-2

package/compiler/compiler.d.ts

@@ -1,41 +1,49 @@
+import { ValueErrorIterator } from '../errors/errors';
 import * as Types from '../typebox';
-import * as ValueErrors from '../errors/index';
 export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
     private readonly references;
     private readonly checkFunc;
     private readonly code;
+    private readonly hasTransform;
     constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
     /** Returns an iterator for each error in this value. */
-    Errors(value: unknown): ValueErrors.ValueErrorIterator;
+    Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Types.Static<T>;
+    /** Decodes a value or throws if error */
+    Decode(value: unknown): Types.StaticDecode<T>;
+    /** Encodes a value or throws if error */
+    Encode(value: unknown): Types.StaticEncode<T>;
 }
-export declare class TypeCompilerUnknownTypeError extends Error {
+export declare class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
-export declare class TypeCompilerDereferenceError extends Error {
-    readonly schema: Types.TRef;
-    constructor(schema: Types.TRef);
-}
-export declare class TypeCompilerTypeGuardError extends Error {
+export declare class TypeCompilerTypeGuardError extends Types.TypeBoxError {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare namespace Policy {
+    function IsExactOptionalProperty(value: string, key: string, expression: string): string;
+    function IsObjectLike(value: string): string;
+    function IsRecordLike(value: string): string;
+    function IsNumberLike(value: string): string;
+    function IsVoidLike(value: string): string;
+}
 export type TypeCompilerLanguageOption = 'typescript' | 'javascript';
-export interface TypeCompilerOptions {
+export interface TypeCompilerCodegenOptions {
     language?: TypeCompilerLanguageOption;
 }
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
-    /** Returns the generated assertion code used to validate this type. */
-    function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerOptions): string;
-    /** Returns the generated assertion code used to validate this type. */
-    function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerOptions): string;
-    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
+    /** Generates the code used to assert this type and returns it as a string */
+    function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerCodegenOptions): string;
+    /** Generates the code used to assert this type and returns it as a string */
+    function Code<T extends Types.TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
+    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -27,12 +27,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
+const transform_1 = require("../value/transform");
+const guard_1 = require("../value/guard");
+const errors_1 = require("../errors/errors");
 const index_1 = require("../system/index");
+const deref_1 = require("../value/deref");
+const hash_1 = require("../value/hash");
 const Types = require("../typebox");
-const ValueErrors = require("../errors/index");
-const ValueHash = require("../value/hash");
-const ValueGuard = require("../value/guard");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
@@ -42,6 +44,7 @@ class TypeCheck {
         this.references = references;
         this.checkFunc = checkFunc;
         this.code = code;
+        this.hasTransform = transform_1.HasTransform.Has(schema, references);
     }
     /** Returns the generated assertion code used to validate this type. */
     Code() {
@@ -49,12 +52,25 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return ValueErrors.Errors(this.schema, this.references, value);
+        return (0, errors_1.Errors)(this.schema, this.references, value);
     }
     /** Returns true if the value matches the compiled type. */
     Check(value) {
         return this.checkFunc(value);
     }
+    /** Decodes a value or throws if error */
+    Decode(value) {
+        if (!this.checkFunc(value))
+            throw new transform_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
+        return this.hasTransform ? transform_1.DecodeTransform.Decode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value;
+    }
+    /** Encodes a value or throws if error */
+    Encode(value) {
+        const encoded = this.hasTransform ? transform_1.EncodeTransform.Encode(this.schema, this.references, value, (_, __, value) => this.Check(value)) : value;
+        if (!this.checkFunc(encoded))
+            throw new transform_1.TransformEncodeCheckError(this.schema, value, this.Errors(value).First());
+        return encoded;
+    }
 }
 exports.TypeCheck = TypeCheck;
 // -------------------------------------------------------------------
@@ -131,27 +147,48 @@ var Identifier;
 // -------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------
-class TypeCompilerUnknownTypeError extends Error {
+class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('TypeCompiler: Unknown type');
+        super('Unknown type');
         this.schema = schema;
     }
 }
 exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
-class TypeCompilerDereferenceError extends Error {
-    constructor(schema) {
-        super(`TypeCompiler: Unable to dereference type with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.TypeCompilerDereferenceError = TypeCompilerDereferenceError;
-class TypeCompilerTypeGuardError extends Error {
+class TypeCompilerTypeGuardError extends Types.TypeBoxError {
     constructor(schema) {
-        super('TypeCompiler: Preflight validation check failed to guard for the given schema');
+        super('Preflight validation check failed to guard for the given schema');
         this.schema = schema;
     }
 }
 exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
+// -------------------------------------------------------------------
+// Policy
+// -------------------------------------------------------------------
+var Policy;
+(function (Policy) {
+    function IsExactOptionalProperty(value, key, expression) {
+        return index_1.TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+    }
+    Policy.IsExactOptionalProperty = IsExactOptionalProperty;
+    function IsObjectLike(value) {
+        return !index_1.TypeSystemPolicy.AllowArrayObject ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+    }
+    Policy.IsObjectLike = IsObjectLike;
+    function IsRecordLike(value) {
+        return !index_1.TypeSystemPolicy.AllowArrayObject
+            ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+            : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
+    }
+    Policy.IsRecordLike = IsRecordLike;
+    function IsNumberLike(value) {
+        return !index_1.TypeSystemPolicy.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    }
+    Policy.IsNumberLike = IsNumberLike;
+    function IsVoidLike(value) {
+        return index_1.TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+    }
+    Policy.IsVoidLike = IsVoidLike;
+})(Policy || (exports.Policy = Policy = {}));
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
@@ -162,26 +199,6 @@ var TypeCompiler;
         return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown';
     }
     // -------------------------------------------------------------------
-    // Polices
-    // -------------------------------------------------------------------
-    function IsExactOptionalProperty(value, key, expression) {
-        return index_1.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
-    }
-    function IsObjectCheck(value) {
-        return !index_1.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
-    }
-    function IsRecordCheck(value) {
-        return !index_1.TypeSystem.AllowArrayObjects
-            ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
-            : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
-    }
-    function IsNumberCheck(value) {
-        return !index_1.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
-    }
-    function IsVoidCheck(value) {
-        return index_1.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
-    }
-    // -------------------------------------------------------------------
     // Types
     // -------------------------------------------------------------------
     function* TAny(schema, references, value) {
@@ -190,17 +207,17 @@ var TypeCompiler;
     function* TArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
-        if (ValueGuard.IsNumber(schema.minItems))
-            yield `${value}.length >= ${schema.minItems}`;
-        if (ValueGuard.IsNumber(schema.maxItems))
+        if ((0, guard_1.IsNumber)(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
+        if ((0, guard_1.IsNumber)(schema.minItems))
+            yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if (Types.TypeGuard.TSchema(schema.contains) || ValueGuard.IsNumber(schema.minContains) || ValueGuard.IsNumber(schema.maxContains)) {
+        if (Types.TypeGuard.TSchema(schema.contains) || (0, guard_1.IsNumber)(schema.minContains) || (0, guard_1.IsNumber)(schema.maxContains)) {
             const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
-            const checkMinContains = ValueGuard.IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
-            const checkMaxContains = ValueGuard.IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+            const checkMinContains = (0, guard_1.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = (0, guard_1.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
             const checkCount = `const count = ${value}.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
             const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ');
             yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
@@ -216,16 +233,16 @@ var TypeCompiler;
     }
     function* TBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if (ValueGuard.IsBigInt(schema.multipleOf))
-            yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
-        if (ValueGuard.IsBigInt(schema.exclusiveMinimum))
-            yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if (ValueGuard.IsBigInt(schema.exclusiveMaximum))
+        if ((0, guard_1.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if (ValueGuard.IsBigInt(schema.minimum))
-            yield `${value} >= BigInt(${schema.minimum})`;
-        if (ValueGuard.IsBigInt(schema.maximum))
+        if ((0, guard_1.IsBigInt)(schema.exclusiveMinimum))
+            yield `${value} > BigInt(${schema.exclusiveMinimum})`;
+        if ((0, guard_1.IsBigInt)(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
+        if ((0, guard_1.IsBigInt)(schema.minimum))
+            yield `${value} >= BigInt(${schema.minimum})`;
+        if ((0, guard_1.IsBigInt)(schema.multipleOf))
+            yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
     function* TBoolean(schema, references, value) {
         yield `(typeof ${value} === 'boolean')`;
@@ -235,30 +252,32 @@ var TypeCompiler;
     }
     function* TDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if (ValueGuard.IsNumber(schema.exclusiveMinimumTimestamp))
-            yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if (ValueGuard.IsNumber(schema.exclusiveMaximumTimestamp))
+        if ((0, guard_1.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if (ValueGuard.IsNumber(schema.minimumTimestamp))
-            yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if (ValueGuard.IsNumber(schema.maximumTimestamp))
+        if ((0, guard_1.IsNumber)(schema.exclusiveMinimumTimestamp))
+            yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.minimumTimestamp))
+            yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.multipleOfTimestamp))
+            yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
     function* TFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
     function* TInteger(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
-        if (ValueGuard.IsNumber(schema.multipleOf))
-            yield `(${value} % ${schema.multipleOf}) === 0`;
-        if (ValueGuard.IsNumber(schema.exclusiveMinimum))
-            yield `${value} > ${schema.exclusiveMinimum}`;
-        if (ValueGuard.IsNumber(schema.exclusiveMaximum))
+        if ((0, guard_1.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if (ValueGuard.IsNumber(schema.minimum))
-            yield `${value} >= ${schema.minimum}`;
-        if (ValueGuard.IsNumber(schema.maximum))
+        if ((0, guard_1.IsNumber)(schema.exclusiveMinimum))
+            yield `${value} > ${schema.exclusiveMinimum}`;
+        if ((0, guard_1.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
+        if ((0, guard_1.IsNumber)(schema.minimum))
+            yield `${value} >= ${schema.minimum}`;
+        if ((0, guard_1.IsNumber)(schema.multipleOf))
+            yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* TIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
@@ -298,23 +317,23 @@ var TypeCompiler;
         yield `(${value} === null)`;
     }
     function* TNumber(schema, references, value) {
-        yield IsNumberCheck(value);
-        if (ValueGuard.IsNumber(schema.multipleOf))
-            yield `(${value} % ${schema.multipleOf}) === 0`;
-        if (ValueGuard.IsNumber(schema.exclusiveMinimum))
-            yield `${value} > ${schema.exclusiveMinimum}`;
-        if (ValueGuard.IsNumber(schema.exclusiveMaximum))
+        yield Policy.IsNumberLike(value);
+        if ((0, guard_1.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if (ValueGuard.IsNumber(schema.minimum))
-            yield `${value} >= ${schema.minimum}`;
-        if (ValueGuard.IsNumber(schema.maximum))
+        if ((0, guard_1.IsNumber)(schema.exclusiveMinimum))
+            yield `${value} > ${schema.exclusiveMinimum}`;
+        if ((0, guard_1.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
+        if ((0, guard_1.IsNumber)(schema.minimum))
+            yield `${value} >= ${schema.minimum}`;
+        if ((0, guard_1.IsNumber)(schema.multipleOf))
+            yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* TObject(schema, references, value) {
-        yield IsObjectCheck(value);
-        if (ValueGuard.IsNumber(schema.minProperties))
+        yield Policy.IsObjectLike(value);
+        if ((0, guard_1.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if (ValueGuard.IsNumber(schema.maxProperties))
+        if ((0, guard_1.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
@@ -327,7 +346,7 @@ var TypeCompiler;
             }
             else {
                 const expression = CreateExpression(property, references, memberExpression);
-                yield IsExactOptionalProperty(value, knownKey, expression);
+                yield Policy.IsExactOptionalProperty(value, knownKey, expression);
             }
         }
         if (schema.additionalProperties === false) {
@@ -349,10 +368,10 @@ var TypeCompiler;
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
     function* TRecord(schema, references, value) {
-        yield IsRecordCheck(value);
-        if (ValueGuard.IsNumber(schema.minProperties))
+        yield Policy.IsRecordLike(value);
+        if ((0, guard_1.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if (ValueGuard.IsNumber(schema.maxProperties))
+        if ((0, guard_1.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`new RegExp(/${patternKey}/)`);
@@ -362,10 +381,7 @@ var TypeCompiler;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
     function* TRef(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new TypeCompilerDereferenceError(schema);
-        const target = references[index];
+        const target = (0, deref_1.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
         // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
         if (state.functions.has(schema.$ref))
@@ -374,10 +390,10 @@ var TypeCompiler;
     }
     function* TString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if (ValueGuard.IsNumber(schema.minLength))
-            yield `${value}.length >= ${schema.minLength}`;
-        if (ValueGuard.IsNumber(schema.maxLength))
+        if ((0, guard_1.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
+        if ((0, guard_1.IsNumber)(schema.minLength))
+            yield `${value}.length >= ${schema.minLength}`;
         if (schema.pattern !== undefined) {
             const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
             yield `${variable}.test(${value})`;
@@ -395,8 +411,8 @@ var TypeCompiler;
         yield `${variable}.test(${value})`;
     }
     function* TThis(schema, references, value) {
-        const func = CreateFunctionName(schema.$ref);
-        yield `${func}(${value})`;
+        // Note: This types are assured to be hoisted prior to this call. Just yield the function.
+        yield `${CreateFunctionName(schema.$ref)}(${value})`;
     }
     function* TTuple(schema, references, value) {
         yield `Array.isArray(${value})`;
@@ -417,16 +433,16 @@ var TypeCompiler;
     }
     function* TUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if (ValueGuard.IsNumber(schema.maxByteLength))
+        if ((0, guard_1.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if (ValueGuard.IsNumber(schema.minByteLength))
+        if ((0, guard_1.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* TUnknown(schema, references, value) {
         yield 'true';
     }
     function* TVoid(schema, references, value) {
-        yield IsVoidCheck(value);
+        yield Policy.IsVoidLike(value);
     }
     function* TKind(schema, references, value) {
         const instance = state.instances.size;
@@ -434,12 +450,12 @@ var TypeCompiler;
         yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
-        const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
+        const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
         // ----------------------------------------------------------------------------------
         // Hoisting
         // ----------------------------------------------------------------------------------
-        if (useHoisting && ValueGuard.IsString(schema.$id)) {
+        if (useHoisting && (0, guard_1.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
                 return yield `${functionName}(${value})`;
@@ -450,9 +466,6 @@ var TypeCompiler;
                 return yield `${functionName}(${value})`;
             }
         }
-        // ----------------------------------------------------------------------------------
-        // Types
-        // ----------------------------------------------------------------------------------
         switch (schema_[Types.Kind]) {
             case 'Any':
                 return yield* TAny(schema_, references_, value);
@@ -568,17 +581,17 @@ var TypeCompiler;
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
         // prettier-ignore
-        const checkFunction = ValueGuard.IsString(schema.$id) // ensure top level schemas with $id's are hoisted
+        const checkFunction = (0, guard_1.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
     }
-    /** Returns the generated assertion code used to validate this type. */
+    /** Generates the code used to assert this type and returns it as a string */
     function Code(...args) {
         const defaults = { language: 'javascript' };
         // prettier-ignore
-        const [schema, references, options] = (args.length === 2 && ValueGuard.IsArray(args[1]) ? [args[0], args[1], defaults] :
-            args.length === 2 && !ValueGuard.IsArray(args[1]) ? [args[0], [], args[1]] :
+        const [schema, references, options] = (args.length === 2 && (0, guard_1.IsArray)(args[1]) ? [args[0], args[1], defaults] :
+            args.length === 2 && !(0, guard_1.IsArray)(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);
@@ -595,7 +608,7 @@ var TypeCompiler;
         return Build(schema, references, options);
     }
     TypeCompiler.Code = Code;
-    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
+    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile(schema, references = []) {
         const generatedCode = Code(schema, references, { language: 'javascript' });
         const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);
@@ -603,8 +616,8 @@ var TypeCompiler;
         function typeRegistryFunction(kind, instance, value) {
             if (!Types.TypeRegistry.Has(kind) || !instances.has(instance))
                 return false;
-            const schema = instances.get(instance);
             const checkFunc = Types.TypeRegistry.Get(kind);
+            const schema = instances.get(instance);
             return checkFunc(schema, value);
         }
         function formatRegistryFunction(format, value) {
@@ -613,10 +626,10 @@ var TypeCompiler;
             const checkFunc = Types.FormatRegistry.Get(format);
             return checkFunc(value);
         }
-        function valueHashFunction(value) {
-            return ValueHash.Hash(value);
+        function hashFunction(value) {
+            return (0, hash_1.Hash)(value);
         }
-        const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, valueHashFunction);
+        const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, hashFunction);
         return new TypeCheck(schema, references, checkFunction, generatedCode);
     }
     TypeCompiler.Compile = Compile;

package/compiler/index.d.ts

@@ -1,2 +1,2 @@
-export { ValueError, ValueErrorType } from '../errors/index';
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
 export * from './compiler';

package/compiler/index.js

@@ -41,7 +41,8 @@ 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;
+exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
 __exportStar(require("./compiler"), exports);

package/errors/errors.d.ts

@@ -1,69 +1,68 @@
 import * as Types from '../typebox';
 export declare enum ValueErrorType {
-    Array = 0,
-    ArrayMinItems = 1,
+    ArrayContains = 0,
+    ArrayMaxContains = 1,
     ArrayMaxItems = 2,
-    ArrayContains = 3,
-    ArrayMinContains = 4,
-    ArrayMaxContains = 5,
-    ArrayUniqueItems = 6,
+    ArrayMinContains = 3,
+    ArrayMinItems = 4,
+    ArrayUniqueItems = 5,
+    Array = 6,
     AsyncIterator = 7,
-    BigInt = 8,
-    BigIntMultipleOf = 9,
-    BigIntExclusiveMinimum = 10,
-    BigIntExclusiveMaximum = 11,
-    BigIntMinimum = 12,
-    BigIntMaximum = 13,
+    BigIntExclusiveMaximum = 8,
+    BigIntExclusiveMinimum = 9,
+    BigIntMaximum = 10,
+    BigIntMinimum = 11,
+    BigIntMultipleOf = 12,
+    BigInt = 13,
     Boolean = 14,
-    Date = 15,
+    DateExclusiveMaximumTimestamp = 15,
     DateExclusiveMinimumTimestamp = 16,
-    DateExclusiveMaximumTimestamp = 17,
+    DateMaximumTimestamp = 17,
     DateMinimumTimestamp = 18,
-    DateMaximumTimestamp = 19,
-    Function = 20,
-    Integer = 21,
-    IntegerMultipleOf = 22,
+    DateMultipleOfTimestamp = 19,
+    Date = 20,
+    Function = 21,
+    IntegerExclusiveMaximum = 22,
     IntegerExclusiveMinimum = 23,
-    IntegerExclusiveMaximum = 24,
+    IntegerMaximum = 24,
     IntegerMinimum = 25,
-    IntegerMaximum = 26,
-    Intersect = 27,
+    IntegerMultipleOf = 26,
+    Integer = 27,
     IntersectUnevaluatedProperties = 28,
-    Iterator = 29,
-    Literal = 30,
-    Never = 31,
-    Not = 32,
-    Null = 33,
-    Number = 34,
-    NumberMultipleOf = 35,
-    NumberExclusiveMinimum = 36,
-    NumberExclusiveMaximum = 37,
-    NumberMinimum = 38,
-    NumberMaximum = 39,
-    Object = 40,
-    ObjectMinProperties = 41,
-    ObjectMaxProperties = 42,
-    ObjectAdditionalProperties = 43,
-    ObjectRequiredProperties = 44,
-    Promise = 45,
-    RecordKeyNumeric = 46,
-    RecordKeyString = 47,
-    String = 48,
-    StringMinLength = 49,
+    Intersect = 29,
+    Iterator = 30,
+    Kind = 31,
+    Literal = 32,
+    Never = 33,
+    Not = 34,
+    Null = 35,
+    NumberExclusiveMaximum = 36,
+    NumberExclusiveMinimum = 37,
+    NumberMaximum = 38,
+    NumberMinimum = 39,
+    NumberMultipleOf = 40,
+    Number = 41,
+    ObjectAdditionalProperties = 42,
+    ObjectMaxProperties = 43,
+    ObjectMinProperties = 44,
+    ObjectRequiredProperty = 45,
+    Object = 46,
+    Promise = 47,
+    StringFormatUnknown = 48,
+    StringFormat = 49,
     StringMaxLength = 50,
-    StringPattern = 51,
-    StringFormatUnknown = 52,
-    StringFormat = 53,
+    StringMinLength = 51,
+    StringPattern = 52,
+    String = 53,
     Symbol = 54,
-    TupleZeroLength = 55,
-    TupleLength = 56,
-    Undefined = 57,
-    Union = 58,
+    TupleLength = 55,
+    Tuple = 56,
+    Uint8ArrayMaxByteLength = 57,
+    Uint8ArrayMinByteLength = 58,
     Uint8Array = 59,
-    Uint8ArrayMinByteLength = 60,
-    Uint8ArrayMaxByteLength = 61,
-    Void = 62,
-    Kind = 63
+    Undefined = 60,
+    Union = 61,
+    Void = 62
 }
 export interface ValueError {
     type: ValueErrorType;
@@ -72,6 +71,10 @@ export interface ValueError {
     value: unknown;
     message: string;
 }
+export declare class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare class ValueErrorIterator {
     private readonly iterator;
     constructor(iterator: IterableIterator<ValueError>);
@@ -79,14 +82,6 @@ export declare class ValueErrorIterator {
     /** Returns the first value error or undefined if no errors */
     First(): ValueError | undefined;
 }
-export declare class ValueErrorsUnknownTypeError extends Error {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class ValueErrorsDereferenceError extends Error {
-    readonly schema: Types.TRef | Types.TThis;
-    constructor(schema: Types.TRef | Types.TThis);
-}
 /** Returns an iterator for each error in this value. */
 export declare function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrorIterator;
 /** Returns an iterator for each error in this value. */