@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-17

package/build/import/value/value/value.d.mts

@@ -3,27 +3,51 @@ import { Edit } from '../delta/index.mjs';
 import { ValueErrorIterator } from '../../errors/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index.mjs';
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, value: unknown): Static<T>;
+/** Creates a value from the given type and references */
 export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+/** Creates a value from the given type */
 export declare function Create<T extends TSchema>(schema: T): Static<T>;
+/** Returns true if the value matches the given type and references */
 export declare function Check<T extends TSchema>(schema: T, references: TSchema[], value: unknown): value is Static<T>;
+/** Returns true if the value matches the given type */
 export declare function Check<T extends TSchema>(schema: T, value: unknown): value is Static<T>;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
 export declare function Convert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** Converts any type mismatched values to their target type if a reasonable conversion is possibl. */
 export declare function Convert<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
+/** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Decodes a value or throws if error */
 export declare function Decode<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;
+/** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;
+/** Returns true if left and right values are structurally equal */
 export declare function Equal<T>(left: T, right: unknown): right is T;
+/** Returns edits to transform the current value into the next value */
 export declare function Diff(current: unknown, next: unknown): Edit[];
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
 export declare function Hash(value: unknown): bigint;
+/** Returns a new value with edits applied to the given value */
 export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 export declare function Mutate(current: Mutable, next: Mutable): void;

package/build/import/value/value/value.mjs

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 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.
+
+---------------------------------------------------------------------------*/
 import { TransformDecode, TransformEncode, TransformDecodeCheckError, TransformEncodeCheckError } from '../transform/index.mjs';
 import { Mutate as MutateValue } from '../mutate/index.mjs';
 import { Hash as HashValue } from '../hash/index.mjs';
@@ -11,33 +38,42 @@ import { Check as CheckValue } from '../check/index.mjs';
 import { Default as DefaultValue } from '../default/index.mjs';
 import { Diff as DiffValue, Patch as PatchValue } from '../delta/index.mjs';
 import { Errors as ValueErrors } from '../../errors/index.mjs';
+/** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export function Cast(...args) {
     return CastValue.apply(CastValue, args);
 }
+/** Creates a value from the given type */
 export function Create(...args) {
     return CreateValue.apply(CreateValue, args);
 }
+/** Returns true if the value matches the given type */
 export function Check(...args) {
     return CheckValue.apply(CheckValue, args);
 }
+/** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export function Clean(...args) {
     return CleanValue.apply(CleanValue, args);
 }
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible */
 export function Convert(...args) {
     return ConvertValue.apply(ConvertValue, args);
 }
+/** Returns a structural clone of the given value */
 export function Clone(value) {
     return CloneValue(value);
 }
+/** Decodes a value or throws if error */
 export function Decode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     if (!Check(schema, references, value))
         throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
     return TransformDecode(schema, references, value);
 }
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(...args) {
     return DefaultValue.apply(DefaultValue, args);
 }
+/** Encodes a value or throws if error */
 export function Encode(...args) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
     const encoded = TransformEncode(schema, references, value);
@@ -45,21 +81,27 @@ export function Encode(...args) {
         throw new TransformEncodeCheckError(schema, value, Errors(schema, references, value).First());
     return encoded;
 }
+/** Returns an iterator for each error in this value. */
 export function Errors(...args) {
     return ValueErrors.apply(ValueErrors, args);
 }
+/** Returns true if left and right values are structurally equal */
 export function Equal(left, right) {
     return EqualValue(left, right);
 }
+/** Returns edits to transform the current value into the next value */
 export function Diff(current, next) {
     return DiffValue(current, next);
 }
+/** Returns a FNV1A-64 non cryptographic hash of the given value */
 export function Hash(value) {
     return HashValue(value);
 }
+/** Returns a new value with edits applied to the given value */
 export function Patch(current, edits) {
     return PatchValue(current, edits);
 }
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references. */
 export function Mutate(current, next) {
     MutateValue(current, next);
 }

package/build/require/compiler/compiler.d.ts

@@ -9,10 +9,15 @@ export declare class TypeCheck<T extends TSchema> {
     private readonly code;
     private readonly hasTransform;
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
+    /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
+    /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Static<T>;
+    /** Decodes a value or throws if error */
     Decode(value: unknown): StaticDecode<T>;
+    /** Encodes a value or throws if error */
     Encode(value: unknown): StaticEncode<T>;
 }
 export declare class TypeCompilerUnknownTypeError extends Error {
@@ -34,8 +39,12 @@ export type TypeCompilerLanguageOption = 'typescript' | 'javascript';
 export interface TypeCompilerCodegenOptions {
     language?: TypeCompilerLanguageOption;
 }
+/** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
+    /** Generates the code used to assert this type and returns it as a string */
     function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string;
+    /** Generates the code used to assert this type and returns it as a string */
     function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
+    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
 }

package/build/require/compiler/compiler.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 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.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
 const index_1 = require("../value/transform/index");
@@ -13,6 +40,9 @@ const index_8 = require("../type/registry/index");
 const index_9 = require("../type/keyof/index");
 const extends_undefined_1 = require("../type/extends/extends-undefined");
 const index_10 = require("../type/never/index");
+// ------------------------------------------------------------------
+// TypeCheck
+// ------------------------------------------------------------------
 class TypeCheck {
     constructor(schema, references, checkFunc, code) {
         this.schema = schema;
@@ -21,20 +51,25 @@ class TypeCheck {
         this.code = code;
         this.hasTransform = (0, index_1.HasTransform)(schema, references);
     }
+    /** Returns the generated assertion code used to validate this type. */
     Code() {
         return this.code;
     }
+    /** Returns an iterator for each error in this value. */
     Errors(value) {
         return (0, index_3.Errors)(this.schema, this.references, value);
     }
+    /** Returns true if the value matches the compiled type. */
     Check(value) {
         return this.checkFunc(value);
     }
+    /** Decodes a value or throws if error */
     Decode(value) {
         if (!this.checkFunc(value))
             throw new index_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
         return this.hasTransform ? (0, index_1.TransformDecode)(this.schema, this.references, value) : value;
     }
+    /** Encodes a value or throws if error */
     Encode(value) {
         const encoded = this.hasTransform ? (0, index_1.TransformEncode)(this.schema, this.references, value) : value;
         if (!this.checkFunc(encoded))
@@ -43,6 +78,9 @@ class TypeCheck {
     }
 }
 exports.TypeCheck = TypeCheck;
+// ------------------------------------------------------------------
+// Character
+// ------------------------------------------------------------------
 var Character;
 (function (Character) {
     function DollarSign(code) {
@@ -62,6 +100,9 @@ var Character;
     }
     Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
+// ------------------------------------------------------------------
+// MemberExpression
+// ------------------------------------------------------------------
 var MemberExpression;
 (function (MemberExpression) {
     function IsFirstCharacterNumeric(value) {
@@ -88,6 +129,9 @@ var MemberExpression;
     }
     MemberExpression.Encode = Encode;
 })(MemberExpression || (MemberExpression = {}));
+// ------------------------------------------------------------------
+// Identifier
+// ------------------------------------------------------------------
 var Identifier;
 (function (Identifier) {
     function Encode($id) {
@@ -105,6 +149,9 @@ var Identifier;
     }
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
+// ------------------------------------------------------------------
+// LiteralString
+// ------------------------------------------------------------------
 var LiteralString;
 (function (LiteralString) {
     function Escape(content) {
@@ -112,6 +159,9 @@ var LiteralString;
     }
     LiteralString.Escape = Escape;
 })(LiteralString || (LiteralString = {}));
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
@@ -126,6 +176,9 @@ class TypeCompilerTypeGuardError extends Error {
     }
 }
 exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
+// ------------------------------------------------------------------
+// Policy
+// ------------------------------------------------------------------
 var Policy;
 (function (Policy) {
     function IsExactOptionalProperty(value, key, expression) {
@@ -151,11 +204,18 @@ var Policy;
     }
     Policy.IsVoidLike = IsVoidLike;
 })(Policy || (exports.Policy = Policy = {}));
+/** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
+    // ----------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------
     function IsAnyOrUnknown(schema) {
         return schema[index_7.Kind] === 'Any' || schema[index_7.Kind] === 'Unknown';
     }
+    // ----------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------
     function* TAny(schema, references, value) {
         yield 'true';
     }
@@ -337,6 +397,8 @@ var TypeCompiler;
     }
     function* TRef(schema, references, value) {
         const target = (0, index_5.Deref)(schema, references);
+        // Reference: If we have seen this reference before we can just yield and return the function call.
+        // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
         if (state.functions.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
@@ -364,6 +426,7 @@ var TypeCompiler;
         yield `${variable}.test(${value})`;
     }
     function* TThis(schema, references, value) {
+        // Note: This types are assured to be hoisted prior to this call. Just yield the function.
         yield `${CreateFunctionName(schema.$ref)}(${value})`;
     }
     function* TTuple(schema, references, value) {
@@ -404,6 +467,9 @@ var TypeCompiler;
     function* Visit(schema, references, value, useHoisting = true) {
         const references_ = (0, index_2.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
+        // --------------------------------------------------------------
+        // Hoisting
+        // --------------------------------------------------------------
         if (useHoisting && (0, index_2.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
@@ -482,12 +548,19 @@ var TypeCompiler;
                 return yield* TKind(schema_, references_, value);
         }
     }
+    // ----------------------------------------------------------------
+    // Compiler State
+    // ----------------------------------------------------------------
+    // prettier-ignore
     const state = {
-        language: 'javascript',
-        functions: new Map(),
-        variables: new Map(),
-        instances: new Map()
+        language: 'javascript', // target language
+        functions: new Map(), // local functions
+        variables: new Map(), // local variables
+        instances: new Map() // exterior kind instances
     };
+    // ----------------------------------------------------------------
+    // Compiler Factory
+    // ----------------------------------------------------------------
     function CreateExpression(schema, references, value, useHoisting = true) {
         return `(${[...Visit(schema, references, value, useHoisting)].join(' && ')})`;
     }
@@ -513,24 +586,31 @@ var TypeCompiler;
     function CreateReturns(type) {
         return state.language === 'typescript' ? `: ${type}` : '';
     }
+    // ----------------------------------------------------------------
+    // Compile
+    // ----------------------------------------------------------------
     function Build(schema, references, options) {
-        const functionCode = CreateFunction('check', schema, references, 'value');
+        const functionCode = CreateFunction('check', schema, references, 'value'); // will populate functions and variables
         const parameter = CreateParameter('value', 'any');
         const returns = CreateReturns('boolean');
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
-        const checkFunction = (0, index_2.IsString)(schema.$id)
+        // prettier-ignore
+        const checkFunction = (0, index_2.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
             ? `return function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
             : `return ${functionCode}`;
         return [...variables, ...functions, checkFunction].join('\n');
     }
+    /** Generates the code used to assert this type and returns it as a string */
     function Code(...args) {
         const defaults = { language: 'javascript' };
+        // prettier-ignore
         const [schema, references, options] = (args.length === 2 && (0, index_2.IsArray)(args[1]) ? [args[0], args[1], defaults] :
             args.length === 2 && !(0, index_2.IsArray)(args[1]) ? [args[0], [], args[1]] :
                 args.length === 3 ? [args[0], args[1], args[2]] :
                     args.length === 1 ? [args[0], [], defaults] :
                         [null, [], defaults]);
+        // compiler-reset
         state.language = options.language;
         state.variables.clear();
         state.functions.clear();
@@ -543,6 +623,7 @@ var TypeCompiler;
         return Build(schema, references, options);
     }
     TypeCompiler.Code = Code;
+    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
     function Compile(schema, references = []) {
         const generatedCode = Code(schema, references, { language: 'javascript' });
         const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);

package/build/require/compiler/index.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 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.TypeCompilerUnknownTypeError = exports.TypeCompilerTypeGuardError = exports.TypeCheck = exports.TypeCompiler = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");

package/build/require/errors/errors.d.ts

@@ -79,7 +79,10 @@ export declare class ValueErrorIterator {
     private readonly iterator;
     constructor(iterator: IterableIterator<ValueError>);
     [Symbol.iterator](): IterableIterator<ValueError>;
+    /** Returns the first value error or undefined if no errors */
     First(): ValueError | undefined;
 }
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
+/** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;

package/build/require/errors/errors.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/errors
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 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.Errors = exports.ValueErrorIterator = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const index_1 = require("../value/guard/index");
@@ -11,6 +38,9 @@ const index_5 = require("../value/deref/index");
 const index_6 = require("../value/hash/index");
 const index_7 = require("../type/symbols/index");
 const index_8 = require("../type/never/index");
+// --------------------------------------------------------------------------
+// ValueErrorType
+// --------------------------------------------------------------------------
 var ValueErrorType;
 (function (ValueErrorType) {
     ValueErrorType[ValueErrorType["ArrayContains"] = 0] = "ArrayContains";
@@ -77,6 +107,9 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
     ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
 })(ValueErrorType || (exports.ValueErrorType = ValueErrorType = {}));
+// --------------------------------------------------------------------------
+// ValueErrors
+// --------------------------------------------------------------------------
 class ValueErrorsUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
@@ -84,12 +117,21 @@ class ValueErrorsUnknownTypeError extends Error {
     }
 }
 exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
+// --------------------------------------------------------------------------
+// EscapeKey
+// --------------------------------------------------------------------------
 function EscapeKey(key) {
-    return key.replace(/~/g, '~0').replace(/\//g, '~1');
+    return key.replace(/~/g, '~0').replace(/\//g, '~1'); // RFC6901 Path
 }
+// --------------------------------------------------------------------------
+// Guards
+// --------------------------------------------------------------------------
 function IsDefined(value) {
     return value !== undefined;
 }
+// --------------------------------------------------------------------------
+// ValueErrorIterator
+// --------------------------------------------------------------------------
 class ValueErrorIterator {
     constructor(iterator) {
         this.iterator = iterator;
@@ -97,15 +139,22 @@ class ValueErrorIterator {
     [Symbol.iterator]() {
         return this.iterator;
     }
+    /** Returns the first value error or undefined if no errors */
     First() {
         const next = this.iterator.next();
         return next.done ? undefined : next.value;
     }
 }
 exports.ValueErrorIterator = ValueErrorIterator;
+// --------------------------------------------------------------------------
+// Create
+// --------------------------------------------------------------------------
 function Create(type, schema, path, value) {
     return { type, schema, path, value, message: (0, function_1.GetErrorFunction)()(schema, type) };
 }
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
 function* TAny(schema, references, path, value) { }
 function* TArray(schema, references, path, value) {
     if (!(0, index_1.IsArray)(value)) {
@@ -120,6 +169,7 @@ function* TArray(schema, references, path, value) {
     for (let i = 0; i < value.length; i++) {
         yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
     }
+    // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
         const hashed = (0, index_6.Hash)(element);
         if (set.has(hashed)) {
@@ -131,6 +181,7 @@ function* TArray(schema, references, path, value) {
     } return true; })())) {
         yield Create(ValueErrorType.ArrayUniqueItems, schema, path, value);
     }
+    // contains
     if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
     }
@@ -240,7 +291,7 @@ function* TIntersect(schema, references, path, value) {
             if (!keyCheck.test(valueKey)) {
                 const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
                 if (!next.done)
-                    yield next.value;
+                    yield next.value; // yield interior
             }
         }
     }
@@ -432,7 +483,7 @@ function* TUnion(schema, references, path, value) {
     for (const subschema of schema.anyOf) {
         const errors = [...Visit(subschema, references, path, value)];
         if (errors.length === 0)
-            return;
+            return; // matched
         count += errors.length;
     }
     if (count > 0) {
@@ -529,6 +580,7 @@ function* Visit(schema, references, path, value) {
             return yield* TKind(schema_, references_, path, value);
     }
 }
+/** Returns an iterator for each error in this value. */
 function Errors(...args) {
     const iterator = args.length === 3 ? Visit(args[0], args[1], '', args[2]) : Visit(args[0], [], '', args[1]);
     return new ValueErrorIterator(iterator);

package/build/require/errors/function.d.ts

@@ -1,6 +1,9 @@
 import { TSchema } from '../type/schema/index';
 import { ValueErrorType } from './errors';
+/** Creates an error message using en-US as the default locale */
 export declare function DefaultErrorFunction(schema: TSchema, errorType: ValueErrorType): string;
 export type ErrorFunction = (schema: TSchema, type: ValueErrorType) => string;
+/** Sets the error function used to generate error messages */
 export declare function SetErrorFunction(callback: ErrorFunction): void;
+/** Gets the error function used to generate error messages */
 export declare function GetErrorFunction(): ErrorFunction;

package/build/require/errors/function.js

@@ -1,8 +1,36 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 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.GetErrorFunction = exports.SetErrorFunction = exports.DefaultErrorFunction = void 0;
 const index_1 = require("../type/symbols/index");
 const errors_1 = require("./errors");
+/** Creates an error message using en-US as the default locale */
 function DefaultErrorFunction(schema, errorType) {
     switch (errorType) {
         case errors_1.ValueErrorType.ArrayContains:
@@ -136,11 +164,14 @@ function DefaultErrorFunction(schema, errorType) {
     }
 }
 exports.DefaultErrorFunction = DefaultErrorFunction;
+/** Manages error message providers */
 let errorFunction = DefaultErrorFunction;
+/** Sets the error function used to generate error messages */
 function SetErrorFunction(callback) {
     errorFunction = callback;
 }
 exports.SetErrorFunction = SetErrorFunction;
+/** Gets the error function used to generate error messages */
 function GetErrorFunction() {
     return errorFunction;
 }