@sinclair/typebox 0.24.21 → 0.24.24

package/value/check.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCheck = void 0;
-const Types = require("../typebox");
+exports.ValueCheck = exports.ValueCheckInvalidTypeError = void 0;
+const index_1 = require("../guard/index");
+class ValueCheckInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueCheck: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueCheckInvalidTypeError = ValueCheckInvalidTypeError;
 var ValueCheck;
 (function (ValueCheck) {
     function Any(schema, references, value) {
@@ -244,53 +251,72 @@ var ValueCheck;
         return value === null;
     }
     function Visit(schema, references, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
-            case 'Any':
-                return Any(anySchema, anyReferences, value);
-            case 'Array':
-                return Array(anySchema, anyReferences, value);
-            case 'Boolean':
-                return Boolean(anySchema, anyReferences, value);
-            case 'Constructor':
-                return Constructor(anySchema, anyReferences, value);
-            case 'Function':
-                return Function(anySchema, anyReferences, value);
-            case 'Integer':
-                return Integer(anySchema, anyReferences, value);
-            case 'Literal':
-                return Literal(anySchema, anyReferences, value);
-            case 'Null':
-                return Null(anySchema, anyReferences, value);
-            case 'Number':
-                return Number(anySchema, anyReferences, value);
-            case 'Object':
-                return Object(anySchema, anyReferences, value);
-            case 'Promise':
-                return Promise(anySchema, anyReferences, value);
-            case 'Record':
-                return Record(anySchema, anyReferences, value);
-            case 'Ref':
-                return Ref(anySchema, anyReferences, value);
-            case 'Self':
-                return Self(anySchema, anyReferences, value);
-            case 'String':
-                return String(anySchema, anyReferences, value);
-            case 'Tuple':
-                return Tuple(anySchema, anyReferences, value);
-            case 'Undefined':
-                return Undefined(anySchema, anyReferences, value);
-            case 'Union':
-                return Union(anySchema, anyReferences, value);
-            case 'Uint8Array':
-                return Uint8Array(anySchema, anyReferences, value);
-            case 'Unknown':
-                return Unknown(anySchema, anyReferences, value);
-            case 'Void':
-                return Void(anySchema, anyReferences, value);
-            default:
-                throw new Error(`ValueCheck: Unknown schema kind '${schema[Types.Kind]}'`);
+        const refs = schema.$id === undefined ? references : [schema, ...references];
+        if (index_1.TypeGuard.TAny(schema)) {
+            return Any(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TArray(schema)) {
+            return Array(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TBoolean(schema)) {
+            return Boolean(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TConstructor(schema)) {
+            return Constructor(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TFunction(schema)) {
+            return Function(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TInteger(schema)) {
+            return Integer(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TLiteral(schema)) {
+            return Literal(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TNull(schema)) {
+            return Null(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TNumber(schema)) {
+            return Number(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TObject(schema)) {
+            return Object(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TPromise(schema)) {
+            return Promise(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TRecord(schema)) {
+            return Record(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TRef(schema)) {
+            return Ref(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TSelf(schema)) {
+            return Self(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TString(schema)) {
+            return String(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TTuple(schema)) {
+            return Tuple(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUndefined(schema)) {
+            return Undefined(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUnion(schema)) {
+            return Union(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUint8Array(schema)) {
+            return Uint8Array(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TUnknown(schema)) {
+            return Unknown(schema, refs, value);
+        }
+        else if (index_1.TypeGuard.TVoid(schema)) {
+            return Void(schema, refs, value);
+        }
+        else {
+            throw new ValueCheckInvalidTypeError(schema);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.d.ts

@@ -1,4 +1,8 @@
 import * as Types from '../typebox';
+export declare class ValueCreateInvalidTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
     function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;

package/value/create.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = void 0;
-const Types = require("../typebox");
+exports.ValueCreate = exports.ValueCreateInvalidTypeError = void 0;
+const index_1 = require("../guard/index");
+class ValueCreateInvalidTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateInvalidTypeError = ValueCreateInvalidTypeError;
 var ValueCreate;
 (function (ValueCreate) {
     function Any(schema, references) {
@@ -269,57 +276,72 @@ var ValueCreate;
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
     function Visit(schema, references) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
-            case 'Any':
-                return Any(anySchema, anyReferences);
-            case 'Array':
-                return Array(anySchema, anyReferences);
-            case 'Boolean':
-                return Boolean(anySchema, anyReferences);
-            case 'Constructor':
-                return Constructor(anySchema, anyReferences);
-            case 'Enum':
-                return Enum(anySchema, anyReferences);
-            case 'Function':
-                return Function(anySchema, anyReferences);
-            case 'Integer':
-                return Integer(anySchema, anyReferences);
-            case 'Literal':
-                return Literal(anySchema, anyReferences);
-            case 'Null':
-                return Null(anySchema, anyReferences);
-            case 'Number':
-                return Number(anySchema, anyReferences);
-            case 'Object':
-                return Object(anySchema, anyReferences);
-            case 'Promise':
-                return Promise(anySchema, anyReferences);
-            case 'Record':
-                return Record(anySchema, anyReferences);
-            case 'Rec':
-                return Recursive(anySchema, anyReferences);
-            case 'Ref':
-                return Ref(anySchema, anyReferences);
-            case 'Self':
-                return Self(anySchema, anyReferences);
-            case 'String':
-                return String(anySchema, anyReferences);
-            case 'Tuple':
-                return Tuple(anySchema, anyReferences);
-            case 'Undefined':
-                return Undefined(anySchema, anyReferences);
-            case 'Union':
-                return Union(anySchema, anyReferences);
-            case 'Uint8Array':
-                return Uint8Array(anySchema, anyReferences);
-            case 'Unknown':
-                return Unknown(anySchema, anyReferences);
-            case 'Void':
-                return Void(anySchema, anyReferences);
-            default:
-                throw new Error(`ValueCreate.Visit: Unknown schema kind '${schema[Types.Kind]}'`);
+        const refs = schema.$id === undefined ? references : [schema, ...references];
+        if (index_1.TypeGuard.TAny(schema)) {
+            return Any(schema, refs);
+        }
+        else if (index_1.TypeGuard.TArray(schema)) {
+            return Array(schema, refs);
+        }
+        else if (index_1.TypeGuard.TBoolean(schema)) {
+            return Boolean(schema, refs);
+        }
+        else if (index_1.TypeGuard.TConstructor(schema)) {
+            return Constructor(schema, refs);
+        }
+        else if (index_1.TypeGuard.TFunction(schema)) {
+            return Function(schema, refs);
+        }
+        else if (index_1.TypeGuard.TInteger(schema)) {
+            return Integer(schema, refs);
+        }
+        else if (index_1.TypeGuard.TLiteral(schema)) {
+            return Literal(schema, refs);
+        }
+        else if (index_1.TypeGuard.TNull(schema)) {
+            return Null(schema, refs);
+        }
+        else if (index_1.TypeGuard.TNumber(schema)) {
+            return Number(schema, refs);
+        }
+        else if (index_1.TypeGuard.TObject(schema)) {
+            return Object(schema, refs);
+        }
+        else if (index_1.TypeGuard.TPromise(schema)) {
+            return Promise(schema, refs);
+        }
+        else if (index_1.TypeGuard.TRecord(schema)) {
+            return Record(schema, refs);
+        }
+        else if (index_1.TypeGuard.TRef(schema)) {
+            return Ref(schema, refs);
+        }
+        else if (index_1.TypeGuard.TSelf(schema)) {
+            return Self(schema, refs);
+        }
+        else if (index_1.TypeGuard.TString(schema)) {
+            return String(schema, refs);
+        }
+        else if (index_1.TypeGuard.TTuple(schema)) {
+            return Tuple(schema, refs);
+        }
+        else if (index_1.TypeGuard.TUndefined(schema)) {
+            return Undefined(schema, refs);
+        }
+        else if (index_1.TypeGuard.TUnion(schema)) {
+            return Union(schema, refs);
+        }
+        else if (index_1.TypeGuard.TUint8Array(schema)) {
+            return Uint8Array(schema, refs);
+        }
+        else if (index_1.TypeGuard.TUnknown(schema)) {
+            return Unknown(schema, refs);
+        }
+        else if (index_1.TypeGuard.TVoid(schema)) {
+            return Void(schema, refs);
+        }
+        else {
+            throw new ValueCreateInvalidTypeError(schema);
         }
     }
     ValueCreate.Visit = Visit;

package/value/index.d.ts

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

package/value/index.js

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

package/value/value.d.ts

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

package/value/value.js

@@ -28,7 +28,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
-const errors_1 = require("./errors");
+const index_1 = require("../errors/index");
 const cast_1 = require("./cast");
 const create_1 = require("./create");
 const check_1 = require("./check");
@@ -52,7 +52,7 @@ var Value;
     Value.Cast = Cast;
     function* Errors(...args) {
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-        yield* errors_1.ValueErrors.Errors(schema, references, value);
+        yield* index_1.ValueErrors.Errors(schema, references, value);
     }
     Value.Errors = Errors;
 })(Value = exports.Value || (exports.Value = {}));

package/value/errors.d.ts

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

package/value/errors.js

@@ -1,305 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueErrors = void 0;
-const Types = require("../typebox");
-var ValueErrors;
-(function (ValueErrors) {
-    function* Any(schema, references, path, value) { }
-    function* Array(schema, references, path, value) {
-        if (!globalThis.Array.isArray(value)) {
-            return yield { schema, path, value, message: `Expected array` };
-        }
-        if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
-            yield { schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
-        }
-        if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
-            yield { schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
-        }
-        if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
-            yield { schema, path, value, message: `Expected array elements to be unique` };
-        }
-        for (let i = 0; i < value.length; i++) {
-            yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
-        }
-    }
-    function* Boolean(schema, references, path, value) {
-        if (!(typeof value === 'boolean')) {
-            return yield { schema, path, value, message: `Expected boolean` };
-        }
-    }
-    function* Constructor(schema, references, path, value) {
-        yield* Visit(schema.returns, references, path, value);
-    }
-    function* Function(schema, references, path, value) {
-        if (!(typeof value === 'function')) {
-            return yield { schema, path, value, message: `Expected function` };
-        }
-    }
-    function* Integer(schema, references, path, value) {
-        if (!(typeof value === 'number')) {
-            return yield { schema, path, value, message: `Expected number` };
-        }
-        if (!globalThis.Number.isInteger(value)) {
-            yield { schema, path, value, message: `Expected integer` };
-        }
-        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
-            yield { schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
-        }
-        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
-            yield { schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
-        }
-        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
-            yield { schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
-        }
-        if (schema.minimum && !(value >= schema.minimum)) {
-            yield { schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
-        }
-        if (schema.maximum && !(value <= schema.maximum)) {
-            yield { schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
-        }
-    }
-    function* Literal(schema, references, path, value) {
-        if (!(value === schema.const)) {
-            const error = typeof schema.const === 'string' ? `'${schema.const}'` : schema.const;
-            return yield { schema, path, value, message: `Expected ${error}` };
-        }
-    }
-    function* Null(schema, references, path, value) {
-        if (!(value === null)) {
-            return yield { schema, path, value, message: `Expected null` };
-        }
-    }
-    function* Number(schema, references, path, value) {
-        if (!(typeof value === 'number')) {
-            return yield { schema, path, value, message: `Expected number` };
-        }
-        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
-            yield { schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
-        }
-        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
-            yield { schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
-        }
-        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
-            yield { schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
-        }
-        if (schema.minimum && !(value >= schema.minimum)) {
-            yield { schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
-        }
-        if (schema.maximum && !(value <= schema.maximum)) {
-            yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
-        }
-    }
-    function* Object(schema, references, path, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { schema, path, value, message: `Expected object` };
-        }
-        if (schema.minProperties !== undefined && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
-            yield { schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
-        }
-        if (schema.maxProperties !== undefined && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
-            yield { schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
-        }
-        const propertyKeys = globalThis.Object.keys(schema.properties);
-        if (schema.additionalProperties === false) {
-            for (const propKey of globalThis.Object.keys(value)) {
-                if (!propertyKeys.includes(propKey)) {
-                    yield { schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
-                }
-            }
-        }
-        for (const propertyKey of propertyKeys) {
-            const propertySchema = schema.properties[propertyKey];
-            if (schema.required && schema.required.includes(propertyKey)) {
-                yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey]);
-            }
-            else {
-                if (value[propertyKey] !== undefined) {
-                    yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey]);
-                }
-            }
-        }
-    }
-    function* Promise(schema, references, path, value) {
-        if (!(typeof value === 'object' && typeof value.then === 'function')) {
-            yield { schema, path, value, message: `Expected Promise` };
-        }
-    }
-    function* Record(schema, references, path, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { schema, path, value, message: `Expected object` };
-        }
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
-            const message = keyPattern === '^(0|[1-9][0-9]*)$' ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
-            return yield { schema, path, value, message };
-        }
-        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
-        }
-    }
-    function* Ref(schema, references, path, value) {
-        const reference = references.find((reference) => reference.$id === schema.$ref);
-        if (reference === undefined)
-            throw new Error(`ValueErrors.Ref: Cannot find schema with $id '${schema.$ref}'.`);
-        yield* Visit(reference, references, path, value);
-    }
-    function* Self(schema, references, path, value) {
-        const reference = references.find((reference) => reference.$id === schema.$ref);
-        if (reference === undefined)
-            throw new Error(`ValueErrors.Self: Cannot find schema with $id '${schema.$ref}'.`);
-        yield* Visit(reference, references, path, value);
-    }
-    function* String(schema, references, path, value) {
-        if (!(typeof value === 'string')) {
-            return yield { schema, path, value, message: 'Expected string' };
-        }
-        if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
-            yield { schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
-        }
-        if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
-            yield { schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
-        }
-        if (schema.pattern !== undefined) {
-            const regex = new RegExp(schema.pattern);
-            if (!regex.test(value)) {
-                yield { schema, path, value, message: `Expected string to match pattern ${schema.pattern}` };
-            }
-        }
-    }
-    function* Tuple(schema, references, path, value) {
-        if (!globalThis.Array.isArray(value)) {
-            return yield { schema, path, value, message: 'Expected Array' };
-        }
-        if (schema.items === undefined && !(value.length === 0)) {
-            return yield { schema, path, value, message: 'Expected tuple to have 0 elements' };
-        }
-        if (!(value.length === schema.maxItems)) {
-            yield { schema, path, value, message: `Expected tuple to have ${schema.maxItems} elements` };
-        }
-        if (!schema.items) {
-            return;
-        }
-        for (let i = 0; i < schema.items.length; i++) {
-            yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
-        }
-    }
-    function* Undefined(schema, references, path, value) {
-        if (!(value === undefined)) {
-            yield { schema, path, value, message: `Expected undefined` };
-        }
-    }
-    function* Union(schema, references, path, value) {
-        const errors = [];
-        for (const inner of schema.anyOf) {
-            const variantErrors = [...Visit(inner, references, path, value)];
-            if (variantErrors.length === 0)
-                return;
-            errors.push(...variantErrors);
-        }
-        for (const error of errors) {
-            yield error;
-        }
-        if (errors.length > 0) {
-            yield { schema, path, value, message: 'Expected value of union' };
-        }
-    }
-    function* Uint8Array(schema, references, path, value) {
-        if (!(value instanceof globalThis.Uint8Array)) {
-            return yield { schema, path, value, message: `Expected Uint8Array` };
-        }
-        if (schema.maxByteLength && !(value.length <= schema.maxByteLength)) {
-            yield { schema, path, value, message: `Expected Uint8Array to have a byte length less or equal to ${schema.maxByteLength}` };
-        }
-        if (schema.minByteLength && !(value.length >= schema.minByteLength)) {
-            yield { schema, path, value, message: `Expected Uint8Array to have a byte length greater or equal to ${schema.maxByteLength}` };
-        }
-    }
-    function* Unknown(schema, references, path, value) { }
-    function* Void(schema, references, path, value) {
-        if (!(value === null)) {
-            return yield { schema, path, value, message: `Expected null` };
-        }
-    }
-    function* Visit(schema, references, path, value) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
-            case 'Any':
-                return yield* Any(anySchema, anyReferences, path, value);
-            case 'Array':
-                return yield* Array(anySchema, anyReferences, path, value);
-            case 'Boolean':
-                return yield* Boolean(anySchema, anyReferences, path, value);
-            case 'Constructor':
-                return yield* Constructor(anySchema, anyReferences, path, value);
-            case 'Function':
-                return yield* Function(anySchema, anyReferences, path, value);
-            case 'Integer':
-                return yield* Integer(anySchema, anyReferences, path, value);
-            case 'Literal':
-                return yield* Literal(anySchema, anyReferences, path, value);
-            case 'Null':
-                return yield* Null(anySchema, anyReferences, path, value);
-            case 'Number':
-                return yield* Number(anySchema, anyReferences, path, value);
-            case 'Object':
-                return yield* Object(anySchema, anyReferences, path, value);
-            case 'Promise':
-                return yield* Promise(anySchema, anyReferences, path, value);
-            case 'Record':
-                return yield* Record(anySchema, anyReferences, path, value);
-            case 'Ref':
-                return yield* Ref(anySchema, anyReferences, path, value);
-            case 'Self':
-                return yield* Self(anySchema, anyReferences, path, value);
-            case 'String':
-                return yield* String(anySchema, anyReferences, path, value);
-            case 'Tuple':
-                return yield* Tuple(anySchema, anyReferences, path, value);
-            case 'Undefined':
-                return yield* Undefined(anySchema, anyReferences, path, value);
-            case 'Union':
-                return yield* Union(anySchema, anyReferences, path, value);
-            case 'Uint8Array':
-                return yield* Uint8Array(anySchema, anyReferences, path, value);
-            case 'Unknown':
-                return yield* Unknown(anySchema, anyReferences, path, value);
-            case 'Void':
-                return yield* Void(anySchema, anyReferences, path, value);
-            default:
-                throw new Error(`ValueErrors: Unknown schema kind '${schema[Types.Kind]}'`);
-        }
-    }
-    function* Errors(schema, references, value) {
-        yield* Visit(schema, references, '', value);
-    }
-    ValueErrors.Errors = Errors;
-})(ValueErrors = exports.ValueErrors || (exports.ValueErrors = {}));