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

package/build/require/compiler/compiler.js

@@ -1,4 +1,5 @@
 "use strict";
+
 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 +14,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 +25,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 +52,9 @@ class TypeCheck {
     }
 }
 exports.TypeCheck = TypeCheck;
+// ------------------------------------------------------------------
+// Character
+// ------------------------------------------------------------------
 var Character;
 (function (Character) {
     function DollarSign(code) {
@@ -62,6 +74,9 @@ var Character;
     }
     Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
+// ------------------------------------------------------------------
+// MemberExpression
+// ------------------------------------------------------------------
 var MemberExpression;
 (function (MemberExpression) {
     function IsFirstCharacterNumeric(value) {
@@ -88,6 +103,9 @@ var MemberExpression;
     }
     MemberExpression.Encode = Encode;
 })(MemberExpression || (MemberExpression = {}));
+// ------------------------------------------------------------------
+// Identifier
+// ------------------------------------------------------------------
 var Identifier;
 (function (Identifier) {
     function Encode($id) {
@@ -105,6 +123,9 @@ var Identifier;
     }
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
+// ------------------------------------------------------------------
+// LiteralString
+// ------------------------------------------------------------------
 var LiteralString;
 (function (LiteralString) {
     function Escape(content) {
@@ -112,6 +133,9 @@ var LiteralString;
     }
     LiteralString.Escape = Escape;
 })(LiteralString || (LiteralString = {}));
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
@@ -126,6 +150,9 @@ class TypeCompilerTypeGuardError extends Error {
     }
 }
 exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
+// ------------------------------------------------------------------
+// Policy
+// ------------------------------------------------------------------
 var Policy;
 (function (Policy) {
     function IsExactOptionalProperty(value, key, expression) {
@@ -151,11 +178,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 +371,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 +400,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 +441,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 +522,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 +560,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 +597,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,5 @@
 "use strict";
+
 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,5 @@
 "use strict";
+
 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 +12,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 +81,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 +91,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 +113,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 +143,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 +155,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 +265,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 +457,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 +554,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,10 @@
 "use strict";
+
 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 +138,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;
 }

package/build/require/errors/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetErrorFunction = exports.GetErrorFunction = exports.DefaultErrorFunction = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = exports.ValueErrorIterator = exports.Errors = void 0;
 var errors_1 = require("./errors");

package/build/require/index.js

@@ -1,8 +1,12 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
 exports.Type = exports.Void = exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
 exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = void 0;
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 var index_1 = require("./type/symbols/index");
 Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return index_1.Kind; } });
 Object.defineProperty(exports, "Hint", { enumerable: true, get: function () { return index_1.Hint; } });
@@ -25,6 +29,9 @@ Object.defineProperty(exports, "ValueGuard", { enumerable: true, get: function (
 var type_1 = require("./type/clone/type");
 Object.defineProperty(exports, "CloneType", { enumerable: true, get: function () { return type_1.CloneType; } });
 Object.defineProperty(exports, "CloneRest", { enumerable: true, get: function () { return type_1.CloneRest; } });
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
 var index_5 = require("./type/any/index");
 Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return index_5.Any; } });
 var index_6 = require("./type/array/index");
@@ -166,6 +173,9 @@ var index_62 = require("./type/unsafe/index");
 Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return index_62.Unsafe; } });
 var index_63 = require("./type/void/index");
 Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return index_63.Void; } });
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
 var index_64 = require("./type/type/index");
 Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return index_64.Type; } });
 Object.defineProperty(exports, "JsonTypeBuilder", { enumerable: true, get: function () { return index_64.JsonTypeBuilder; } });

package/build/require/system/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeSystemDuplicateTypeKind = exports.TypeSystemDuplicateFormat = exports.TypeSystem = exports.TypeSystemPolicy = void 0;
 var policy_1 = require("./policy");

package/build/require/system/policy.d.ts

@@ -1,11 +1,21 @@
 export declare namespace TypeSystemPolicy {
+    /** Shared assertion routines used by the value and errors modules */
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     let ExactOptionalPropertyTypes: boolean;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     let AllowArrayObject: boolean;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
     let AllowNaN: boolean;
+    /** Sets whether `null` should validate for void types. The default is `false` */
     let AllowNullVoid: boolean;
+    /** Asserts this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value: Record<keyof any, unknown>, key: string): boolean;
+    /** Asserts this value using the AllowArrayObjects policy */
     function IsObjectLike(value: unknown): value is Record<keyof any, unknown>;
+    /** Asserts this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value: unknown): value is Record<keyof any, unknown>;
+    /** Asserts this value using the AllowNaN policy */
     function IsNumberLike(value: unknown): value is number;
+    /** Asserts this value using the AllowVoidNull policy */
     function IsVoidLike(value: unknown): value is void;
 }

package/build/require/system/policy.js

@@ -1,31 +1,45 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeSystemPolicy = void 0;
 const index_1 = require("../value/guard/index");
 var TypeSystemPolicy;
 (function (TypeSystemPolicy) {
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy
+    // ------------------------------------------------------------------
+    /** Shared assertion routines used by the value and errors modules */
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
     TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
     TypeSystemPolicy.AllowArrayObject = false;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
     TypeSystemPolicy.AllowNaN = false;
+    /** Sets whether `null` should validate for void types. The default is `false` */
     TypeSystemPolicy.AllowNullVoid = false;
+    /** Asserts this value using the ExactOptionalPropertyTypes policy */
     function IsExactOptionalProperty(value, key) {
         return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
     }
     TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    /** Asserts this value using the AllowArrayObjects policy */
     function IsObjectLike(value) {
         const isObject = (0, index_1.IsObject)(value);
         return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !(0, index_1.IsArray)(value);
     }
     TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    /** Asserts this value as a record using the AllowArrayObjects policy */
     function IsRecordLike(value) {
         return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
     }
     TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    /** Asserts this value using the AllowNaN policy */
     function IsNumberLike(value) {
         const isNumber = (0, index_1.IsNumber)(value);
         return TypeSystemPolicy.AllowNaN ? isNumber : isNumber && Number.isFinite(value);
     }
     TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    /** Asserts this value using the AllowVoidNull policy */
     function IsVoidLike(value) {
         const isUndefined = (0, index_1.IsUndefined)(value);
         return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;

package/build/require/system/system.d.ts

@@ -4,7 +4,10 @@ export declare class TypeSystemDuplicateTypeKind extends Error {
 export declare class TypeSystemDuplicateFormat extends Error {
     constructor(kind: string);
 }
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
 export declare namespace TypeSystem {
+    /** Creates a new type */
     function Type<Type, Options = Record<PropertyKey, unknown>>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => import("../type/unsafe/unsafe").TUnsafe<Type>;
+    /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
 }

package/build/require/system/system.js

@@ -1,9 +1,13 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeSystem = exports.TypeSystemDuplicateFormat = exports.TypeSystemDuplicateTypeKind = void 0;
 const index_1 = require("../type/registry/index");
 const index_2 = require("../type/unsafe/index");
 const index_3 = require("../type/symbols/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class TypeSystemDuplicateTypeKind extends Error {
     constructor(kind) {
         super(`Duplicate type kind '${kind}' detected`);
@@ -16,8 +20,13 @@ class TypeSystemDuplicateFormat extends Error {
     }
 }
 exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
+// ------------------------------------------------------------------
+// TypeSystem
+// ------------------------------------------------------------------
+/** Creates user defined types and formats and provides overrides for value checking behaviours */
 var TypeSystem;
 (function (TypeSystem) {
+    /** Creates a new type */
     function Type(kind, check) {
         if (index_1.TypeRegistry.Has(kind))
             throw new TypeSystemDuplicateTypeKind(kind);
@@ -25,6 +34,7 @@ var TypeSystem;
         return (options = {}) => (0, index_2.Unsafe)({ ...options, [index_3.Kind]: kind });
     }
     TypeSystem.Type = Type;
+    /** Creates a new string format */
     function Format(format, check) {
         if (index_1.FormatRegistry.Has(format))
             throw new TypeSystemDuplicateFormat(format);

package/build/require/type/any/any.d.ts

@@ -4,4 +4,5 @@ export interface TAny extends TSchema {
     [Kind]: 'Any';
     static: any;
 }
+/** `[Json]` Creates an Any type */
 export declare function Any(options?: SchemaOptions): TAny;

package/build/require/type/any/any.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Any = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates an Any type */
 function Any(options = {}) {
     return { ...options, [index_1.Kind]: 'Any' };
 }

package/build/require/type/any/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/array/array.d.ts

@@ -2,11 +2,17 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import { Kind } from '../symbols/index';
 export interface ArrayOptions extends SchemaOptions {
+    /** The minimum number of items in this array */
     minItems?: number;
+    /** The maximum number of items in this array */
     maxItems?: number;
+    /** Should this schema contain unique items */
     uniqueItems?: boolean;
+    /** A schema for which some elements should match */
     contains?: TSchema;
+    /** A minimum number of contains schema matches */
     minContains?: number;
+    /** A maximum number of contains schema matches */
     maxContains?: number;
 }
 export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
@@ -15,4 +21,5 @@ export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptio
     type: 'array';
     items: T;
 }
+/** `[Json]` Creates an Array type */
 export declare function Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;

package/build/require/type/array/array.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Array = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[Json]` Creates an Array type */
 function Array(schema, options = {}) {
     return {
         ...options,

package/build/require/type/array/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/async-iterator/async-iterator.d.ts

@@ -7,4 +7,5 @@ export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
     type: 'AsyncIterator';
     items: T;
 }
+/** `[JavaScript]` Creates a AsyncIterator type */
 export declare function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;

package/build/require/type/async-iterator/async-iterator.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncIterator = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[JavaScript]` Creates a AsyncIterator type */
 function AsyncIterator(items, options = {}) {
     return {
         ...options,

package/build/require/type/async-iterator/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);