@sinclair/typebox 0.26.0-dev.4 → 0.26.0-dev.5

package/errors/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+exports.ValueErrors = exports.ValueErrorsDereferenceError = exports.ValueErrorsUnknownTypeError = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 /*--------------------------------------------------------------------------
 
 @sinclair/typebox/errors
@@ -123,24 +123,58 @@ class ValueErrorsUnknownTypeError extends Error {
     }
 }
 exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
+class ValueErrorsDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueErrors: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueErrorsDereferenceError = ValueErrorsDereferenceError;
 /** Provides functionality to generate a sequence of errors against a TypeBox type.  */
 var ValueErrors;
 (function (ValueErrors) {
+    // ----------------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------------
+    function IsObject(value) {
+        const result = typeof value === 'object' && value !== null;
+        return index_1.TypeSystem.AllowArrayObjects ? result : result && !globalThis.Array.isArray(value);
+    }
+    function IsRecordObject(value) {
+        return IsObject(value) && !(value instanceof globalThis.Date) && !(value instanceof globalThis.Uint8Array);
+    }
     function IsBigInt(value) {
         return typeof value === 'bigint';
     }
     function IsNumber(value) {
-        return typeof value === 'number' && globalThis.isFinite(value);
+        const result = typeof value === 'number';
+        return index_1.TypeSystem.AllowNaN ? result : result && globalThis.Number.isFinite(value);
+    }
+    function IsInteger(value) {
+        return globalThis.Number.isInteger(value);
     }
-    function* Any(schema, path, value) { }
-    function* Array(schema, path, value) {
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsVoid(value) {
+        const result = value === undefined;
+        return index_1.TypeSystem.AllowVoidNull ? result || value === null : result;
+    }
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    // ----------------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------------
+    function* Any(schema, references, path, value) { }
+    function* Array(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
             return yield { type: ValueErrorType.Array, schema, path, value, message: `Expected array` };
         }
-        if (IsNumber(schema.minItems) && !(value.length >= schema.minItems)) {
+        if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
             yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
         }
-        if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
+        if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
             yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
         }
         // prettier-ignore
@@ -156,85 +190,85 @@ var ValueErrors;
             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, `${path}/${i}`, value[i]);
+            yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
         }
     }
-    function* BigInt(schema, path, value) {
-        if (!(typeof value === 'bigint')) {
+    function* BigInt(schema, references, path, value) {
+        if (!IsBigInt(value)) {
             return yield { type: ValueErrorType.BigInt, schema, path, value, message: `Expected bigint` };
         }
-        if (IsBigInt(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === globalThis.BigInt(0))) {
             yield { type: ValueErrorType.BigIntMultipleOf, schema, path, value, message: `Expected bigint to be a multiple of ${schema.multipleOf}` };
         }
-        if (IsBigInt(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
             yield { type: ValueErrorType.BigIntExclusiveMinimum, schema, path, value, message: `Expected bigint to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (IsBigInt(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
             yield { type: ValueErrorType.BigIntExclusiveMaximum, schema, path, value, message: `Expected bigint to be less than ${schema.exclusiveMaximum}` };
         }
-        if (IsBigInt(schema.minimum) && !(value >= schema.minimum)) {
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
             yield { type: ValueErrorType.BigIntMinimum, schema, path, value, message: `Expected bigint to be greater or equal to ${schema.minimum}` };
         }
-        if (IsBigInt(schema.maximum) && !(value <= schema.maximum)) {
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
             yield { type: ValueErrorType.BigIntMaximum, schema, path, value, message: `Expected bigint to be less or equal to ${schema.maximum}` };
         }
     }
-    function* Boolean(schema, path, value) {
+    function* Boolean(schema, references, path, value) {
         if (!(typeof value === 'boolean')) {
             return yield { type: ValueErrorType.Boolean, schema, path, value, message: `Expected boolean` };
         }
     }
-    function* Constructor(schema, path, value) {
-        yield* Visit(schema.returns, path, value.prototype);
+    function* Constructor(schema, references, path, value) {
+        yield* Visit(schema.returns, references, path, value.prototype);
     }
-    function* Date(schema, path, value) {
+    function* Date(schema, references, path, value) {
         if (!(value instanceof globalThis.Date)) {
             return yield { type: ValueErrorType.Date, schema, path, value, message: `Expected Date object` };
         }
         if (!globalThis.isFinite(value.getTime())) {
             return yield { type: ValueErrorType.Date, schema, path, value, message: `Invalid Date` };
         }
-        if (IsNumber(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+        if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
             yield { type: ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (IsNumber(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+        if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
             yield { type: ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less than ${schema.exclusiveMaximum}` };
         }
-        if (IsNumber(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+        if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
             yield { type: ValueErrorType.DateMinimumTimestamp, schema, path, value, message: `Expected Date timestamp to be greater or equal to ${schema.minimum}` };
         }
-        if (IsNumber(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+        if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
             yield { type: ValueErrorType.DateMaximumTimestamp, schema, path, value, message: `Expected Date timestamp to be less or equal to ${schema.maximum}` };
         }
     }
-    function* Function(schema, path, value) {
+    function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {
             return yield { type: ValueErrorType.Function, schema, path, value, message: `Expected function` };
         }
     }
-    function* Integer(schema, path, value) {
-        if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
+    function* Integer(schema, references, path, value) {
+        if (!IsInteger(value)) {
             return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
         }
-        if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
         }
-        if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
             yield { type: ValueErrorType.IntegerExclusiveMinimum, schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
             yield { type: ValueErrorType.IntegerExclusiveMaximum, schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
         }
-        if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
             yield { type: ValueErrorType.IntegerMinimum, schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
         }
-        if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
             yield { type: ValueErrorType.IntegerMaximum, schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
         }
     }
-    function* Intersect(schema, path, value) {
+    function* Intersect(schema, references, path, value) {
         for (const subschema of schema.allOf) {
-            const next = Visit(subschema, path, value).next();
+            const next = Visit(subschema, references, path, value).next();
             if (!next.done) {
                 yield next.value;
                 yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` };
@@ -255,7 +289,7 @@ var ValueErrors;
             const valueKeys = globalThis.Object.getOwnPropertyNames(value);
             for (const valueKey of valueKeys) {
                 if (!schemaKeys.includes(valueKey)) {
-                    const next = Visit(schema.unevaluatedProperties, `${path}/${valueKey}`, value[valueKey]).next();
+                    const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
                     if (!next.done) {
                         yield next.value;
                         yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Invalid additional property` };
@@ -265,122 +299,101 @@ var ValueErrors;
             }
         }
     }
-    function* Literal(schema, path, value) {
+    function* Literal(schema, references, path, value) {
         if (!(value === schema.const)) {
             const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
             return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` };
         }
     }
-    function* Never(schema, path, value) {
+    function* Never(schema, references, path, value) {
         yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` };
     }
-    function* Not(schema, path, value) {
-        if (Visit(schema.allOf[0].not, path, value).next().done === true) {
+    function* Not(schema, references, path, value) {
+        if (Visit(schema.allOf[0].not, references, path, value).next().done === true) {
             yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` };
         }
-        yield* Visit(schema.allOf[1], path, value);
+        yield* Visit(schema.allOf[1], references, path, value);
     }
-    function* Null(schema, path, value) {
+    function* Null(schema, references, path, value) {
         if (!(value === null)) {
             return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` };
         }
     }
-    function* Number(schema, path, value) {
-        if (index_1.TypeSystem.AllowNaN) {
-            if (!(typeof value === 'number')) {
-                return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
-            }
-        }
-        else {
-            if (!(typeof value === 'number' && globalThis.Number.isFinite(value))) {
-                return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
-            }
+    function* Number(schema, references, path, value) {
+        if (!IsNumber(value)) {
+            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
         }
-        if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+        if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
         }
-        if (IsNumber(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+        if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
             yield { type: ValueErrorType.NumberExclusiveMinimum, schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
         }
-        if (IsNumber(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+        if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
             yield { type: ValueErrorType.NumberExclusiveMaximum, schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
         }
-        if (IsNumber(schema.minimum) && !(value >= schema.minimum)) {
+        if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
             yield { type: ValueErrorType.NumberMaximum, schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
         }
-        if (IsNumber(schema.maximum) && !(value <= schema.maximum)) {
+        if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
             yield { type: ValueErrorType.NumberMinumum, schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
         }
     }
-    function* Object(schema, path, value) {
-        if (index_1.TypeSystem.AllowArrayObjects) {
-            if (!(typeof value === 'object' && value !== null)) {
-                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
-            }
-        }
-        else {
-            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
-            }
+    function* Object(schema, references, path, value) {
+        if (!IsObject(value)) {
+            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
         }
         const requiredKeys = globalThis.Array.isArray(schema.required) ? schema.required : [];
-        const schemaKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-        const valueKeys = globalThis.Object.getOwnPropertyNames(value);
-        for (const schemaKey of schemaKeys) {
-            const property = schema.properties[schemaKey];
-            if (schema.required && schema.required.includes(schemaKey)) {
-                yield* Visit(property, `${path}/${schemaKey}`, value[schemaKey]);
-                if (Types.ExtendsUndefined.Check(schema) && !(schemaKey in value)) {
-                    yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${schemaKey}`, value: undefined, message: `Expected required property` };
+        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        const unknownKeys = globalThis.Object.getOwnPropertyNames(value);
+        for (const knownKey of knownKeys) {
+            const property = schema.properties[knownKey];
+            if (schema.required && schema.required.includes(knownKey)) {
+                yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
+                if (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+                    yield { type: ValueErrorType.ObjectRequiredProperties, schema: property, path: `${path}/${knownKey}`, value: undefined, message: `Expected required property` };
                 }
             }
             else {
-                if (schemaKey in value) {
-                    yield* Visit(property, `${path}/${schemaKey}`, value[schemaKey]);
+                if (knownKey in value) {
+                    yield* Visit(property, references, `${path}/${knownKey}`, value[knownKey]);
                 }
             }
         }
         for (const requiredKey of requiredKeys) {
-            if (valueKeys.includes(requiredKey))
+            if (unknownKeys.includes(requiredKey))
                 continue;
             yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` };
         }
         if (schema.additionalProperties === false) {
-            for (const valueKey of valueKeys) {
-                if (!schemaKeys.includes(valueKey)) {
+            for (const valueKey of unknownKeys) {
+                if (!knownKeys.includes(valueKey)) {
                     yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${valueKey}`, value: value[valueKey], message: `Unexpected property` };
                 }
             }
         }
         if (typeof schema.additionalProperties === 'object') {
-            for (const valueKey of valueKeys) {
-                if (schemaKeys.includes(valueKey))
+            for (const valueKey of unknownKeys) {
+                if (knownKeys.includes(valueKey))
                     continue;
-                yield* Visit(schema.additionalProperties, `${path}/${valueKey}`, value[valueKey]);
+                yield* Visit(schema.additionalProperties, references, `${path}/${valueKey}`, value[valueKey]);
             }
         }
     }
-    function* Promise(schema, path, value) {
+    function* Promise(schema, references, path, value) {
         if (!(typeof value === 'object' && typeof value.then === 'function')) {
             yield { type: ValueErrorType.Promise, schema, path, value, message: `Expected Promise` };
         }
     }
-    function* Record(schema, path, value) {
-        if (index_1.TypeSystem.AllowArrayObjects) {
-            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
-                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
-            }
-        }
-        else {
-            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
-                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
-            }
+    function* Record(schema, references, path, value) {
+        if (!IsRecordObject(value)) {
+            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected record object` };
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
@@ -391,23 +404,31 @@ var ValueErrors;
             return yield { type, schema, path, value, message };
         }
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            yield* Visit(valueSchema, `${path}/${propKey}`, propValue);
+            yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
         }
     }
-    function* Ref(schema, path, value) {
-        yield* Visit(Types.ReferenceRegistry.DerefOne(schema), path, value);
+    function* Ref(schema, references, path, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueErrorsDereferenceError(schema);
+        const target = references[index];
+        yield* Visit(target, references, path, value);
     }
-    function* Self(schema, path, value) {
-        yield* Visit(Types.ReferenceRegistry.DerefOne(schema), path, value);
+    function* Self(schema, references, path, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueErrorsDereferenceError(schema);
+        const target = references[index];
+        yield* Visit(target, references, path, value);
     }
-    function* String(schema, path, value) {
-        if (!(typeof value === 'string')) {
+    function* String(schema, references, path, value) {
+        if (!IsString(value)) {
             return yield { type: ValueErrorType.String, schema, path, value, message: 'Expected string' };
         }
-        if (IsNumber(schema.minLength) && !(value.length >= schema.minLength)) {
+        if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
             yield { type: ValueErrorType.StringMinLength, schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
         }
-        if (IsNumber(schema.maxLength) && !(value.length <= schema.maxLength)) {
+        if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
             yield { type: ValueErrorType.StringMaxLength, schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
         }
         if (schema.pattern !== undefined) {
@@ -428,12 +449,12 @@ var ValueErrors;
             }
         }
     }
-    function* Symbol(schema, path, value) {
+    function* Symbol(schema, references, path, value) {
         if (!(typeof value === 'symbol')) {
             return yield { type: ValueErrorType.Symbol, schema, path, value, message: 'Expected symbol' };
         }
     }
-    function* Tuple(schema, path, value) {
+    function* Tuple(schema, references, path, value) {
         if (!globalThis.Array.isArray(value)) {
             return yield { type: ValueErrorType.Array, schema, path, value, message: 'Expected Array' };
         }
@@ -447,18 +468,18 @@ var ValueErrors;
             return;
         }
         for (let i = 0; i < schema.items.length; i++) {
-            yield* Visit(schema.items[i], `${path}/${i}`, value[i]);
+            yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
         }
     }
-    function* Undefined(schema, path, value) {
+    function* Undefined(schema, references, path, value) {
         if (!(value === undefined)) {
             yield { type: ValueErrorType.Undefined, schema, path, value, message: `Expected undefined` };
         }
     }
-    function* Union(schema, path, value) {
+    function* Union(schema, references, path, value) {
         const errors = [];
         for (const inner of schema.anyOf) {
-            const variantErrors = [...Visit(inner, path, value)];
+            const variantErrors = [...Visit(inner, references, path, value)];
             if (variantErrors.length === 0)
                 return;
             errors.push(...variantErrors);
@@ -470,101 +491,96 @@ var ValueErrors;
             yield { type: ValueErrorType.Union, schema, path, value, message: 'Expected value of union' };
         }
     }
-    function* Uint8Array(schema, path, value) {
+    function* Uint8Array(schema, references, path, value) {
         if (!(value instanceof globalThis.Uint8Array)) {
             return yield { type: ValueErrorType.Uint8Array, schema, path, value, message: `Expected Uint8Array` };
         }
-        if (IsNumber(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+        if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
             yield { type: ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
         }
-        if (IsNumber(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+        if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
             yield { type: ValueErrorType.Uint8ArrayMinByteLength, schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
         }
     }
-    function* Unknown(schema, path, value) { }
-    function* Void(schema, path, value) {
-        if (index_1.TypeSystem.AllowVoidNull) {
-            if (!(value === undefined || value === null)) {
-                return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null or undefined` };
-            }
-        }
-        else {
-            if (!(value === undefined)) {
-                return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected undefined` };
-            }
+    function* Unknown(schema, references, path, value) { }
+    function* Void(schema, references, path, value) {
+        if (!IsVoid(value)) {
+            return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected void` };
         }
     }
-    function* UserDefined(schema, path, value) {
+    function* UserDefined(schema, references, path, value) {
         const check = Types.TypeRegistry.Get(schema[Types.Kind]);
         if (!check(schema, value)) {
             return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
         }
     }
-    function* Visit(schema, path, value) {
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
+    function* Visit(schema, references, path, value) {
+        const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema_[Types.Kind]) {
             case 'Any':
-                return yield* Any(anySchema, path, value);
+                return yield* Any(schema_, references_, path, value);
             case 'Array':
-                return yield* Array(anySchema, path, value);
+                return yield* Array(schema_, references_, path, value);
             case 'BigInt':
-                return yield* BigInt(anySchema, path, value);
+                return yield* BigInt(schema_, references_, path, value);
             case 'Boolean':
-                return yield* Boolean(anySchema, path, value);
+                return yield* Boolean(schema_, references_, path, value);
             case 'Constructor':
-                return yield* Constructor(anySchema, path, value);
+                return yield* Constructor(schema_, references_, path, value);
             case 'Date':
-                return yield* Date(anySchema, path, value);
+                return yield* Date(schema_, references_, path, value);
             case 'Function':
-                return yield* Function(anySchema, path, value);
+                return yield* Function(schema_, references_, path, value);
             case 'Integer':
-                return yield* Integer(anySchema, path, value);
+                return yield* Integer(schema_, references_, path, value);
             case 'Intersect':
-                return yield* Intersect(anySchema, path, value);
+                return yield* Intersect(schema_, references_, path, value);
             case 'Literal':
-                return yield* Literal(anySchema, path, value);
+                return yield* Literal(schema_, references_, path, value);
             case 'Never':
-                return yield* Never(anySchema, path, value);
+                return yield* Never(schema_, references_, path, value);
             case 'Not':
-                return yield* Not(anySchema, path, value);
+                return yield* Not(schema_, references_, path, value);
             case 'Null':
-                return yield* Null(anySchema, path, value);
+                return yield* Null(schema_, references_, path, value);
             case 'Number':
-                return yield* Number(anySchema, path, value);
+                return yield* Number(schema_, references_, path, value);
             case 'Object':
-                return yield* Object(anySchema, path, value);
+                return yield* Object(schema_, references_, path, value);
             case 'Promise':
-                return yield* Promise(anySchema, path, value);
+                return yield* Promise(schema_, references_, path, value);
             case 'Record':
-                return yield* Record(anySchema, path, value);
+                return yield* Record(schema_, references_, path, value);
             case 'Ref':
-                return yield* Ref(anySchema, path, value);
+                return yield* Ref(schema_, references_, path, value);
             case 'Self':
-                return yield* Self(anySchema, path, value);
+                return yield* Self(schema_, references_, path, value);
             case 'String':
-                return yield* String(anySchema, path, value);
+                return yield* String(schema_, references_, path, value);
             case 'Symbol':
-                return yield* Symbol(anySchema, path, value);
+                return yield* Symbol(schema_, references_, path, value);
             case 'Tuple':
-                return yield* Tuple(anySchema, path, value);
+                return yield* Tuple(schema_, references_, path, value);
             case 'Undefined':
-                return yield* Undefined(anySchema, path, value);
+                return yield* Undefined(schema_, references_, path, value);
             case 'Union':
-                return yield* Union(anySchema, path, value);
+                return yield* Union(schema_, references_, path, value);
             case 'Uint8Array':
-                return yield* Uint8Array(anySchema, path, value);
+                return yield* Uint8Array(schema_, references_, path, value);
             case 'Unknown':
-                return yield* Unknown(anySchema, path, value);
+                return yield* Unknown(schema_, references_, path, value);
             case 'Void':
-                return yield* Void(anySchema, path, value);
+                return yield* Void(schema_, references_, path, value);
             default:
-                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                     throw new ValueErrorsUnknownTypeError(schema);
-                return yield* UserDefined(anySchema, path, value);
+                return yield* UserDefined(schema_, references_, path, value);
         }
     }
-    function Errors(schema, value) {
-        return new ValueErrorIterator(Visit(schema, '', value));
+    function Errors(schema, references, value) {
+        const iterator = Visit(schema, references, '', value);
+        return new ValueErrorIterator(iterator);
     }
     ValueErrors.Errors = Errors;
 })(ValueErrors = exports.ValueErrors || (exports.ValueErrors = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.0-dev.4",
+  "version": "0.26.0-dev.5",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",