@sinclair/typebox 0.25.24 → 0.26.0-dev

package/compiler/compiler.d.ts

@@ -1,12 +1,11 @@
-import { ValueError } from '../errors/index';
 import * as Types from '../typebox';
+import { ValueError } 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;
-    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
+    constructor(schema: T, checkFunc: CheckFunction, code: string);
     /** Returns the generated validation code used to validate this type. */
     Code(): string;
     /** Returns an iterator for each error in this value. */
@@ -21,8 +20,14 @@ export declare class TypeCompilerUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class TypeCompilerPreflightCheckError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
+    /** Returns the generated validation code used to validate this type. */
+    function Code<T extends Types.TSchema>(schema: T): string;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
+    function Compile<T extends Types.TSchema>(schema: T): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -27,21 +27,17 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.MemberExpression = exports.TypeCheck = void 0;
+exports.TypeCompiler = exports.TypeCompilerPreflightCheckError = exports.TypeCompilerUnknownTypeError = exports.MemberExpression = exports.TypeCheck = void 0;
+const Types = require("../typebox");
 const index_1 = require("../errors/index");
 const index_2 = require("../system/index");
-const index_3 = require("../guard/index");
-const index_4 = require("../format/index");
-const index_5 = require("../custom/index");
-const index_6 = require("../hash/index");
-const Types = require("../typebox");
+const hash_1 = require("../value/hash");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
 class TypeCheck {
-    constructor(schema, references, checkFunc, code) {
+    constructor(schema, checkFunc, code) {
         this.schema = schema;
-        this.references = references;
         this.checkFunc = checkFunc;
         this.code = code;
     }
@@ -51,7 +47,7 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return index_1.ValueErrors.Errors(this.schema, this.references, value);
+        return index_1.ValueErrors.Errors(this.schema, value);
     }
     /** Returns true if the value matches the compiled type. */
     Check(value) {
@@ -138,220 +134,260 @@ class TypeCompilerUnknownTypeError extends Error {
     }
 }
 exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
+class TypeCompilerPreflightCheckError extends Error {
+    constructor(schema) {
+        super('TypeCompiler: Preflight validation check failed for given schema');
+        this.schema = schema;
+    }
+}
+exports.TypeCompilerPreflightCheckError = TypeCompilerPreflightCheckError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
     // -------------------------------------------------------------------
     // Guards
     // -------------------------------------------------------------------
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
     function IsNumber(value) {
-        return typeof value === 'number' && !globalThis.isNaN(value);
+        return typeof value === 'number' && globalThis.Number.isFinite(value);
     }
     // -------------------------------------------------------------------
     // Types
     // -------------------------------------------------------------------
     function* Any(schema, value) {
-        yield '(true)';
+        yield 'true';
     }
     function* Array(schema, value) {
         const expression = CreateExpression(schema.items, 'value');
-        yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`;
+        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
         if (IsNumber(schema.minItems))
-            yield `(${value}.length >= ${schema.minItems})`;
+            yield `${value}.length >= ${schema.minItems}`;
         if (IsNumber(schema.maxItems))
-            yield `(${value}.length <= ${schema.maxItems})`;
+            yield `${value}.length <= ${schema.maxItems}`;
         if (schema.uniqueItems === true)
             yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
     }
+    function* BigInt(schema, value) {
+        yield `(typeof ${value} === 'bigint')`;
+        if (IsBigInt(schema.multipleOf))
+            yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
+        if (IsBigInt(schema.exclusiveMinimum))
+            yield `${value} > BigInt(${schema.exclusiveMinimum})`;
+        if (IsBigInt(schema.exclusiveMaximum))
+            yield `${value} < BigInt(${schema.exclusiveMaximum})`;
+        if (IsBigInt(schema.minimum))
+            yield `${value} >= BigInt(${schema.minimum})`;
+        if (IsBigInt(schema.maximum))
+            yield `${value} <= BigInt(${schema.maximum})`;
+    }
     function* Boolean(schema, value) {
-        yield `(typeof ${value} === 'boolean')`;
+        yield `typeof ${value} === 'boolean'`;
     }
     function* Constructor(schema, value) {
         yield* Visit(schema.returns, `${value}.prototype`);
     }
     function* Date(schema, value) {
-        yield `(${value} instanceof Date) && !isNaN(${value}.getTime())`;
+        yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
         if (IsNumber(schema.exclusiveMinimumTimestamp))
-            yield `(${value}.getTime() > ${schema.exclusiveMinimumTimestamp})`;
+            yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
         if (IsNumber(schema.exclusiveMaximumTimestamp))
-            yield `(${value}.getTime() < ${schema.exclusiveMaximumTimestamp})`;
+            yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
         if (IsNumber(schema.minimumTimestamp))
-            yield `(${value}.getTime() >= ${schema.minimumTimestamp})`;
+            yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
         if (IsNumber(schema.maximumTimestamp))
-            yield `(${value}.getTime() <= ${schema.maximumTimestamp})`;
+            yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
     }
     function* Function(schema, value) {
-        yield `(typeof ${value} === 'function')`;
+        yield `typeof ${value} === 'function'`;
     }
     function* Integer(schema, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
         if (IsNumber(schema.multipleOf))
-            yield `(${value} % ${schema.multipleOf} === 0)`;
+            yield `(${value} % ${schema.multipleOf}) === 0`;
         if (IsNumber(schema.exclusiveMinimum))
-            yield `(${value} > ${schema.exclusiveMinimum})`;
+            yield `${value} > ${schema.exclusiveMinimum}`;
         if (IsNumber(schema.exclusiveMaximum))
-            yield `(${value} < ${schema.exclusiveMaximum})`;
+            yield `${value} < ${schema.exclusiveMaximum}`;
         if (IsNumber(schema.minimum))
-            yield `(${value} >= ${schema.minimum})`;
+            yield `${value} >= ${schema.minimum}`;
         if (IsNumber(schema.maximum))
-            yield `(${value} <= ${schema.maximum})`;
+            yield `${value} <= ${schema.maximum}`;
+    }
+    function* Intersect(schema, value) {
+        if (schema.unevaluatedProperties === undefined) {
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, value));
+            yield `${expressions.join(' && ')}`;
+        }
+        else if (schema.unevaluatedProperties === false) {
+            // prettier-ignore
+            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, value));
+            const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`;
+            yield `${expressions.join(' && ')} && ${expression1}`;
+        }
+        else if (typeof schema.unevaluatedProperties === 'object') {
+            // prettier-ignore
+            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
+            const expressions = schema.allOf.map((schema) => CreateExpression(schema, value));
+            const expression1 = CreateExpression(schema.unevaluatedProperties, 'value[key]');
+            const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`;
+            yield `${expressions.join(' && ')} && ${expression2}`;
+        }
     }
     function* Literal(schema, value) {
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
-            yield `(${value} === ${schema.const})`;
+            yield `${value} === ${schema.const}`;
         }
         else {
-            yield `(${value} === '${schema.const}')`;
+            yield `${value} === '${schema.const}'`;
         }
     }
     function* Never(schema, value) {
-        yield `(false)`;
+        yield `false`;
+    }
+    function* Not(schema, value) {
+        const left = CreateExpression(schema.allOf[0].not, value);
+        const right = CreateExpression(schema.allOf[1], value);
+        yield `!${left} && ${right}`;
     }
     function* Null(schema, value) {
-        yield `(${value} === null)`;
+        yield `${value} === null`;
     }
     function* Number(schema, value) {
-        if (index_2.TypeSystem.AllowNaN) {
-            yield `(typeof ${value} === 'number')`;
-        }
-        else {
-            yield `(typeof ${value} === 'number' && !isNaN(${value}))`;
-        }
+        yield `typeof ${value} === 'number'`;
+        if (!index_2.TypeSystem.AllowNaN)
+            yield `Number.isFinite(${value})`;
         if (IsNumber(schema.multipleOf))
-            yield `(${value} % ${schema.multipleOf} === 0)`;
+            yield `(${value} % ${schema.multipleOf}) === 0`;
         if (IsNumber(schema.exclusiveMinimum))
-            yield `(${value} > ${schema.exclusiveMinimum})`;
+            yield `${value} > ${schema.exclusiveMinimum}`;
         if (IsNumber(schema.exclusiveMaximum))
-            yield `(${value} < ${schema.exclusiveMaximum})`;
+            yield `${value} < ${schema.exclusiveMaximum}`;
         if (IsNumber(schema.minimum))
-            yield `(${value} >= ${schema.minimum})`;
+            yield `${value} >= ${schema.minimum}`;
         if (IsNumber(schema.maximum))
-            yield `(${value} <= ${schema.maximum})`;
+            yield `${value} <= ${schema.maximum}`;
     }
     function* Object(schema, value) {
-        if (index_2.TypeSystem.AllowArrayObjects) {
-            yield `(typeof ${value} === 'object' && ${value} !== null)`;
-        }
-        else {
-            yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
-        }
+        yield `(typeof ${value} === 'object' && ${value} !== null)`;
+        if (!index_2.TypeSystem.AllowArrayObjects)
+            yield `!Array.isArray(${value})`;
         if (IsNumber(schema.minProperties))
-            yield `(Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties})`;
+            yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
         if (IsNumber(schema.maxProperties))
-            yield `(Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties})`;
-        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-        if (schema.additionalProperties === false) {
-            // Optimization: If the property key length matches the required keys length
-            // then we only need check that the values property key length matches that
-            // of the property key length. This is because exhaustive testing for values
-            // will occur in subsequent property tests.
-            if (schema.required && schema.required.length === propertyKeys.length) {
-                yield `(Object.getOwnPropertyNames(${value}).length === ${propertyKeys.length})`;
+            yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
+        const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        for (const schemaKey of schemaKeys) {
+            const memberExpression = MemberExpression.Encode(value, schemaKey);
+            const property = schema.properties[schemaKey];
+            if (schema.required && schema.required.includes(schemaKey)) {
+                yield* Visit(property, memberExpression);
+                if (Types.ExtendsUndefined.Check(property))
+                    yield `('${schemaKey}' in ${value})`;
             }
             else {
-                const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-                yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key)))`;
+                const expression = CreateExpression(property, memberExpression);
+                yield `('${schemaKey}' in ${value} ? ${expression} : true)`;
             }
         }
-        if (index_3.TypeGuard.TSchema(schema.additionalProperties)) {
-            const expression = CreateExpression(schema.additionalProperties, 'value[key]');
-            const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-            yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
-        }
-        for (const propertyKey of propertyKeys) {
-            const memberExpression = MemberExpression.Encode(value, propertyKey);
-            const propertySchema = schema.properties[propertyKey];
-            if (schema.required && schema.required.includes(propertyKey)) {
-                yield* Visit(propertySchema, memberExpression);
-                if (index_3.TypeExtends.Undefined(propertySchema)) {
-                    yield `('${propertyKey}' in ${value})`;
-                }
+        if (schema.additionalProperties === false) {
+            if (schema.required && schema.required.length === schemaKeys.length) {
+                yield `Object.getOwnPropertyNames(${value}).length === ${schemaKeys.length}`;
             }
             else {
-                const expression = CreateExpression(propertySchema, memberExpression);
-                yield `(${memberExpression} === undefined ? true : (${expression}))`;
+                const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
+                yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
             }
         }
+        if (typeof schema.additionalProperties === 'object') {
+            const expression = CreateExpression(schema.additionalProperties, 'value[key]');
+            const keys = `[${schemaKeys.map((key) => `'${key}'`).join(', ')}]`;
+            yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
+        }
     }
     function* Promise(schema, value) {
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
     function* Record(schema, value) {
-        if (index_2.TypeSystem.AllowArrayObjects) {
-            yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`;
-        }
-        else {
-            yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !Array.isArray(${value}))`;
-        }
+        yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`;
+        if (!index_2.TypeSystem.AllowArrayObjects)
+            yield `!Array.isArray(${value})`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
         const expression = CreateExpression(valueSchema, 'value');
-        yield `(Object.values(${value}).every(value => ${expression}))`;
+        yield `Object.values(${value}).every(value => ${expression})`;
     }
     function* Ref(schema, value) {
         // 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. Consider for refactor.
         if (state_local_function_names.has(schema.$ref))
-            return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
-        if (!state_reference_map.has(schema.$ref))
-            throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
-        const reference = state_reference_map.get(schema.$ref);
-        yield* Visit(reference, value);
+            return yield `${CreateFunctionName(schema.$ref)}(${value})`;
+        yield* Visit(Types.ReferenceRegistry.DerefOne(schema), value);
     }
     function* Self(schema, value) {
         const func = CreateFunctionName(schema.$ref);
-        yield `(${func}(${value}))`;
+        yield `${func}(${value})`;
     }
     function* String(schema, value) {
         yield `(typeof ${value} === 'string')`;
         if (IsNumber(schema.minLength))
-            yield `(${value}.length >= ${schema.minLength})`;
+            yield `${value}.length >= ${schema.minLength}`;
         if (IsNumber(schema.maxLength))
-            yield `(${value}.length <= ${schema.maxLength})`;
+            yield `${value}.length <= ${schema.maxLength}`;
         if (schema.pattern !== undefined) {
             const local = PushLocal(`${new RegExp(schema.pattern)};`);
-            yield `(${local}.test(${value}))`;
+            yield `${local}.test(${value})`;
         }
         if (schema.format !== undefined) {
-            yield `(format('${schema.format}', ${value}))`;
+            yield `format('${schema.format}', ${value})`;
         }
     }
+    function* Symbol(schema, value) {
+        yield `(typeof ${value} === 'symbol')`;
+    }
     function* Tuple(schema, value) {
         yield `(Array.isArray(${value}))`;
         if (schema.items === undefined)
-            return yield `(${value}.length === 0)`;
+            return yield `${value}.length === 0`;
         yield `(${value}.length === ${schema.maxItems})`;
         for (let i = 0; i < schema.items.length; i++) {
             const expression = CreateExpression(schema.items[i], `${value}[${i}]`);
-            yield `(${expression})`;
+            yield `${expression}`;
         }
     }
     function* Undefined(schema, value) {
-        yield `(${value} === undefined)`;
+        yield `${value} === undefined`;
     }
     function* Union(schema, value) {
         const expressions = schema.anyOf.map((schema) => CreateExpression(schema, value));
         yield `(${expressions.join(' || ')})`;
     }
     function* Uint8Array(schema, value) {
-        yield `(${value} instanceof Uint8Array)`;
+        yield `${value} instanceof Uint8Array`;
         if (IsNumber(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
         if (IsNumber(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* Unknown(schema, value) {
-        yield '(true)';
+        yield 'true';
     }
     function* Void(schema, value) {
-        yield `(${value} === null)`;
+        if (index_2.TypeSystem.AllowVoidNull) {
+            yield `(${value} === undefined || ${value} === null)`;
+        }
+        else {
+            yield `${value} === undefined`;
+        }
     }
     function* UserDefined(schema, value) {
         const schema_key = `schema_key_${state_remote_custom_types.size}`;
         state_remote_custom_types.set(schema_key, schema);
-        yield `(custom('${schema[Types.Kind]}', '${schema_key}', ${value}))`;
+        yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
     }
     function* Visit(schema, value) {
         // Reference: Referenced schemas can originate from either additional schemas
@@ -362,7 +398,7 @@ var TypeCompiler;
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, schema, 'value');
             PushFunction(body);
-            yield `(${name}(${value}))`;
+            yield `${name}(${value})`;
             return;
         }
         const anySchema = schema;
@@ -371,6 +407,8 @@ var TypeCompiler;
                 return yield* Any(anySchema, value);
             case 'Array':
                 return yield* Array(anySchema, value);
+            case 'BigInt':
+                return yield* BigInt(anySchema, value);
             case 'Boolean':
                 return yield* Boolean(anySchema, value);
             case 'Constructor':
@@ -381,10 +419,14 @@ var TypeCompiler;
                 return yield* Function(anySchema, value);
             case 'Integer':
                 return yield* Integer(anySchema, value);
+            case 'Intersect':
+                return yield* Intersect(anySchema, value);
             case 'Literal':
                 return yield* Literal(anySchema, value);
             case 'Never':
                 return yield* Never(anySchema, value);
+            case 'Not':
+                return yield* Not(anySchema, value);
             case 'Null':
                 return yield* Null(anySchema, value);
             case 'Number':
@@ -401,6 +443,8 @@ var TypeCompiler;
                 return yield* Self(anySchema, value);
             case 'String':
                 return yield* String(anySchema, value);
+            case 'Symbol':
+                return yield* Symbol(anySchema, value);
             case 'Tuple':
                 return yield* Tuple(anySchema, value);
             case 'Undefined':
@@ -414,7 +458,7 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                if (!index_5.Custom.Has(anySchema[Types.Kind]))
+                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
                 return yield* UserDefined(anySchema, value);
         }
@@ -422,25 +466,14 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     // Compiler State
     // -------------------------------------------------------------------
-    const state_reference_map = new Map(); // tracks schemas with identifiers
     const state_local_variables = new Set(); // local variables and functions
     const state_local_function_names = new Set(); // local function names used call ref validators
     const state_remote_custom_types = new Map(); // remote custom types used during compilation
     function ResetCompiler() {
-        state_reference_map.clear();
         state_local_variables.clear();
         state_local_function_names.clear();
         state_remote_custom_types.clear();
     }
-    function AddReferences(schemas = []) {
-        for (const schema of schemas) {
-            if (!schema.$id)
-                throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
-            if (state_reference_map.has(schema.$id))
-                throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`);
-            state_reference_map.set(schema.$id, schema);
-        }
-    }
     function CreateExpression(schema, value) {
         return `(${[...Visit(schema, value)].join(' && ')})`;
     }
@@ -465,34 +498,39 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
-    function Build(schema, references = []) {
+    function Build(schema) {
         ResetCompiler();
-        AddReferences(references);
         const check = CreateFunction('check', schema, 'value');
         const locals = GetLocals();
         return `${locals.join('\n')}\nreturn ${check}`;
     }
+    /** Returns the generated validation code used to validate this type. */
+    function Code(schema) {
+        if (!Types.TypeGuard.TSchema(schema))
+            throw new TypeCompilerPreflightCheckError(schema);
+        return Build(schema);
+    }
+    TypeCompiler.Code = Code;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile(schema, references = []) {
-        index_3.TypeGuard.Assert(schema, references);
-        const code = Build(schema, references);
+    function Compile(schema) {
+        const code = Code(schema);
         const custom_schemas = new Map(state_remote_custom_types);
         const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
         const checkFunction = compiledFunction((kind, schema_key, value) => {
-            if (!index_5.Custom.Has(kind) || !custom_schemas.has(schema_key))
+            if (!Types.TypeRegistry.Has(kind) || !custom_schemas.has(schema_key))
                 return false;
             const schema = custom_schemas.get(schema_key);
-            const func = index_5.Custom.Get(kind);
+            const func = Types.TypeRegistry.Get(kind);
             return func(schema, value);
         }, (format, value) => {
-            if (!index_4.Format.Has(format))
+            if (!Types.FormatRegistry.Has(format))
                 return false;
-            const func = index_4.Format.Get(format);
+            const func = Types.FormatRegistry.Get(format);
             return func(value);
         }, (value) => {
-            return index_6.ValueHash.Create(value);
+            return hash_1.ValueHash.Create(value);
         });
-        return new TypeCheck(schema, references, checkFunction, code);
+        return new TypeCheck(schema, checkFunction, code);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/errors/errors.d.ts

@@ -4,51 +4,61 @@ export declare enum ValueErrorType {
     ArrayMinItems = 1,
     ArrayMaxItems = 2,
     ArrayUniqueItems = 3,
-    Boolean = 4,
-    Date = 5,
-    DateExclusiveMinimumTimestamp = 6,
-    DateExclusiveMaximumTimestamp = 7,
-    DateMinimumTimestamp = 8,
-    DateMaximumTimestamp = 9,
-    Function = 10,
-    Integer = 11,
-    IntegerMultipleOf = 12,
-    IntegerExclusiveMinimum = 13,
-    IntegerExclusiveMaximum = 14,
-    IntegerMinimum = 15,
-    IntegerMaximum = 16,
-    Literal = 17,
-    Never = 18,
-    Null = 19,
-    Number = 20,
-    NumberMultipleOf = 21,
-    NumberExclusiveMinimum = 22,
-    NumberExclusiveMaximum = 23,
-    NumberMinumum = 24,
-    NumberMaximum = 25,
-    Object = 26,
-    ObjectMinProperties = 27,
-    ObjectMaxProperties = 28,
-    ObjectAdditionalProperties = 29,
-    ObjectRequiredProperties = 30,
-    Promise = 31,
-    RecordKeyNumeric = 32,
-    RecordKeyString = 33,
-    String = 34,
-    StringMinLength = 35,
-    StringMaxLength = 36,
-    StringPattern = 37,
-    StringFormatUnknown = 38,
-    StringFormat = 39,
-    TupleZeroLength = 40,
-    TupleLength = 41,
-    Undefined = 42,
-    Union = 43,
-    Uint8Array = 44,
-    Uint8ArrayMinByteLength = 45,
-    Uint8ArrayMaxByteLength = 46,
-    Void = 47,
-    Custom = 48
+    BigInt = 4,
+    BigIntMultipleOf = 5,
+    BigIntExclusiveMinimum = 6,
+    BigIntExclusiveMaximum = 7,
+    BigIntMinimum = 8,
+    BigIntMaximum = 9,
+    Boolean = 10,
+    Date = 11,
+    DateExclusiveMinimumTimestamp = 12,
+    DateExclusiveMaximumTimestamp = 13,
+    DateMinimumTimestamp = 14,
+    DateMaximumTimestamp = 15,
+    Function = 16,
+    Integer = 17,
+    IntegerMultipleOf = 18,
+    IntegerExclusiveMinimum = 19,
+    IntegerExclusiveMaximum = 20,
+    IntegerMinimum = 21,
+    IntegerMaximum = 22,
+    Intersect = 23,
+    IntersectUnevaluatedProperties = 24,
+    Literal = 25,
+    Never = 26,
+    Not = 27,
+    Null = 28,
+    Number = 29,
+    NumberMultipleOf = 30,
+    NumberExclusiveMinimum = 31,
+    NumberExclusiveMaximum = 32,
+    NumberMinumum = 33,
+    NumberMaximum = 34,
+    Object = 35,
+    ObjectMinProperties = 36,
+    ObjectMaxProperties = 37,
+    ObjectAdditionalProperties = 38,
+    ObjectRequiredProperties = 39,
+    Promise = 40,
+    RecordKeyNumeric = 41,
+    RecordKeyString = 42,
+    String = 43,
+    StringMinLength = 44,
+    StringMaxLength = 45,
+    StringPattern = 46,
+    StringFormatUnknown = 47,
+    StringFormat = 48,
+    Symbol = 49,
+    TupleZeroLength = 50,
+    TupleLength = 51,
+    Undefined = 52,
+    Union = 53,
+    Uint8Array = 54,
+    Uint8ArrayMinByteLength = 55,
+    Uint8ArrayMaxByteLength = 56,
+    Void = 57,
+    Custom = 58
 }
 export interface ValueError {
     type: ValueErrorType;
@@ -63,5 +73,5 @@ export declare class ValueErrorsUnknownTypeError extends Error {
 }
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 export declare namespace ValueErrors {
-    function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): IterableIterator<ValueError>;
+    function Errors<T extends Types.TSchema>(schema: T, value: any): IterableIterator<ValueError>;
 }