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

package/build/import/compiler/compiler.d.mts

@@ -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/import/compiler/compiler.mjs

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { TransformEncode, TransformDecode, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform/index.mjs';
 import { IsArray, IsString, IsNumber, IsBigInt } from '../value/guard/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -10,6 +37,9 @@ import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { Never } from '../type/never/index.mjs';
+// ------------------------------------------------------------------
+// TypeCheck
+// ------------------------------------------------------------------
 export class TypeCheck {
     schema;
     references;
@@ -23,20 +53,25 @@ export class TypeCheck {
         this.code = code;
         this.hasTransform = 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 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 TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
         return this.hasTransform ? TransformDecode(this.schema, this.references, value) : value;
     }
+    /** Encodes a value or throws if error */
     Encode(value) {
         const encoded = this.hasTransform ? TransformEncode(this.schema, this.references, value) : value;
         if (!this.checkFunc(encoded))
@@ -44,6 +79,9 @@ export class TypeCheck {
         return encoded;
     }
 }
+// ------------------------------------------------------------------
+// Character
+// ------------------------------------------------------------------
 var Character;
 (function (Character) {
     function DollarSign(code) {
@@ -63,6 +101,9 @@ var Character;
     }
     Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
+// ------------------------------------------------------------------
+// MemberExpression
+// ------------------------------------------------------------------
 var MemberExpression;
 (function (MemberExpression) {
     function IsFirstCharacterNumeric(value) {
@@ -89,6 +130,9 @@ var MemberExpression;
     }
     MemberExpression.Encode = Encode;
 })(MemberExpression || (MemberExpression = {}));
+// ------------------------------------------------------------------
+// Identifier
+// ------------------------------------------------------------------
 var Identifier;
 (function (Identifier) {
     function Encode($id) {
@@ -106,6 +150,9 @@ var Identifier;
     }
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
+// ------------------------------------------------------------------
+// LiteralString
+// ------------------------------------------------------------------
 var LiteralString;
 (function (LiteralString) {
     function Escape(content) {
@@ -113,6 +160,9 @@ var LiteralString;
     }
     LiteralString.Escape = Escape;
 })(LiteralString || (LiteralString = {}));
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class TypeCompilerUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -127,6 +177,9 @@ export class TypeCompilerTypeGuardError extends Error {
         this.schema = schema;
     }
 }
+// ------------------------------------------------------------------
+// Policy
+// ------------------------------------------------------------------
 export var Policy;
 (function (Policy) {
     function IsExactOptionalProperty(value, key, expression) {
@@ -152,11 +205,18 @@ export var Policy;
     }
     Policy.IsVoidLike = IsVoidLike;
 })(Policy || (Policy = {}));
+/** Compiles Types for Runtime Type Checking */
 export var TypeCompiler;
 (function (TypeCompiler) {
+    // ----------------------------------------------------------------
+    // Guards
+    // ----------------------------------------------------------------
     function IsAnyOrUnknown(schema) {
         return schema[Kind] === 'Any' || schema[Kind] === 'Unknown';
     }
+    // ----------------------------------------------------------------
+    // Types
+    // ----------------------------------------------------------------
     function* TAny(schema, references, value) {
         yield 'true';
     }
@@ -338,6 +398,8 @@ export var TypeCompiler;
     }
     function* TRef(schema, references, value) {
         const target = 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);
@@ -365,6 +427,7 @@ export 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) {
@@ -405,6 +468,9 @@ export var TypeCompiler;
     function* Visit(schema, references, value, useHoisting = true) {
         const references_ = IsString(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
+        // --------------------------------------------------------------
+        // Hoisting
+        // --------------------------------------------------------------
         if (useHoisting && IsString(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
@@ -483,12 +549,19 @@ export 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(' && ')})`;
     }
@@ -514,24 +587,31 @@ export 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 = IsString(schema.$id)
+        // prettier-ignore
+        const checkFunction = 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 && IsArray(args[1]) ? [args[0], args[1], defaults] :
             args.length === 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();
@@ -544,6 +624,7 @@ export 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/import/compiler/index.mjs

@@ -1,2 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
 export { TypeCompiler, TypeCheck, TypeCompilerTypeGuardError, TypeCompilerUnknownTypeError } from './compiler.mjs';

package/build/import/errors/errors.d.mts

@@ -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/import/errors/errors.mjs

@@ -1,3 +1,30 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../value/guard/index.mjs';
 import { TypeSystemPolicy } from '../system/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
@@ -8,6 +35,9 @@ import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
 import { Never } from '../type/never/index.mjs';
+// --------------------------------------------------------------------------
+// ValueErrorType
+// --------------------------------------------------------------------------
 export var ValueErrorType;
 (function (ValueErrorType) {
     ValueErrorType[ValueErrorType["ArrayContains"] = 0] = "ArrayContains";
@@ -74,6 +104,9 @@ export var ValueErrorType;
     ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
     ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
 })(ValueErrorType || (ValueErrorType = {}));
+// --------------------------------------------------------------------------
+// ValueErrors
+// --------------------------------------------------------------------------
 export class ValueErrorsUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -81,12 +114,21 @@ export class ValueErrorsUnknownTypeError extends Error {
         this.schema = schema;
     }
 }
+// --------------------------------------------------------------------------
+// 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
+// --------------------------------------------------------------------------
 export class ValueErrorIterator {
     iterator;
     constructor(iterator) {
@@ -95,14 +137,21 @@ export 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;
     }
 }
+// --------------------------------------------------------------------------
+// Create
+// --------------------------------------------------------------------------
 function Create(type, schema, path, value) {
     return { type, schema, path, value, message: GetErrorFunction()(schema, type) };
 }
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
 function* TAny(schema, references, path, value) { }
 function* TArray(schema, references, path, value) {
     if (!IsArray(value)) {
@@ -117,6 +166,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 = Hash(element);
         if (set.has(hashed)) {
@@ -128,6 +178,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;
     }
@@ -237,7 +288,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
             }
         }
     }
@@ -429,7 +480,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) {
@@ -526,6 +577,7 @@ function* Visit(schema, references, path, value) {
             return yield* TKind(schema_, references_, path, value);
     }
 }
+/** Returns an iterator for each error in this value. */
 export 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/import/errors/function.d.mts

@@ -1,6 +1,9 @@
 import { TSchema } from '../type/schema/index.mjs';
 import { ValueErrorType } from './errors.mjs';
+/** 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/import/errors/function.mjs

@@ -1,5 +1,33 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 import { Kind } from '../type/symbols/index.mjs';
 import { ValueErrorType } from './errors.mjs';
+/** Creates an error message using en-US as the default locale */
 export function DefaultErrorFunction(schema, errorType) {
     switch (errorType) {
         case ValueErrorType.ArrayContains:
@@ -132,10 +160,13 @@ export function DefaultErrorFunction(schema, errorType) {
             return 'Unknown error type';
     }
 }
+/** Manages error message providers */
 let errorFunction = DefaultErrorFunction;
+/** Sets the error function used to generate error messages */
 export function SetErrorFunction(callback) {
     errorFunction = callback;
 }
+/** Gets the error function used to generate error messages */
 export function GetErrorFunction() {
     return errorFunction;
 }

package/build/import/errors/index.mjs

@@ -1,2 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export { Errors, ValueErrorIterator, ValueErrorType, ValueErrorsUnknownTypeError } from './errors.mjs';
 export { DefaultErrorFunction, GetErrorFunction, SetErrorFunction } from './function.mjs';

package/build/import/index.d.mts

@@ -24,7 +24,7 @@ export { Increment, type Assert, type AssertType, type AssertRest, type AssertPr
 export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index.mjs';
 export { InstanceType, type TInstanceType } from './type/instance-type/index.mjs';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index.mjs';
-export { Intersect, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
+export { Intersect, IntersectEvaluated, type TIntersect, type IntersectOptions } from './type/intersect/index.mjs';
 export { Iterator, type TIterator } from './type/iterator/index.mjs';
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
@@ -60,7 +60,7 @@ export { Transform, type TTransform, type TransformOptions, type TransformFuncti
 export { Tuple, type TTuple } from './type/tuple/index.mjs';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index.mjs';
 export { Undefined, type TUndefined } from './type/undefined/index.mjs';
-export { Union, type TUnion } from './type/union/index.mjs';
+export { Union, UnionEvaluated, type TUnion } from './type/union/index.mjs';
 export { Unknown, type TUnknown } from './type/unknown/index.mjs';
 export { Unsafe, type TUnsafe } from './type/unsafe/index.mjs';
 export { Void, type TVoid } from './type/void/index.mjs';

package/build/import/index.mjs

@@ -1,8 +1,41 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+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.
+
+---------------------------------------------------------------------------*/
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 export { Kind, Hint, ReadonlyKind, OptionalKind, TransformKind } from './type/symbols/index.mjs';
 export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact, PatternString, PatternStringExact } from './type/patterns/index.mjs';
 export { TypeRegistry, FormatRegistry } from './type/registry/index.mjs';
 export { TypeGuard, ValueGuard } from './type/guard/index.mjs';
 export { CloneType, CloneRest } from './type/clone/type.mjs';
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
 export { Any } from './type/any/index.mjs';
 export { Array } from './type/array/index.mjs';
 export { AsyncIterator } from './type/async-iterator/index.mjs';
@@ -24,7 +57,7 @@ export { Increment } from './type/helpers/index.mjs';
 export { Index, IndexPropertyKeys, IndexFromMappedKey } from './type/indexed/index.mjs';
 export { InstanceType } from './type/instance-type/index.mjs';
 export { Integer } from './type/integer/index.mjs';
-export { Intersect } from './type/intersect/index.mjs';
+export { Intersect, IntersectEvaluated } from './type/intersect/index.mjs';
 export { Iterator } from './type/iterator/index.mjs';
 export { Intrinsic, IntrinsicFromMappedKey, Capitalize, Lowercase, Uncapitalize, Uppercase } from './type/intrinsic/index.mjs';
 export { KeyOf, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index.mjs';
@@ -58,8 +91,11 @@ export { Transform, TransformDecodeBuilder, TransformEncodeBuilder } from './typ
 export { Tuple } from './type/tuple/index.mjs';
 export { Uint8Array } from './type/uint8array/index.mjs';
 export { Undefined } from './type/undefined/index.mjs';
-export { Union } from './type/union/index.mjs';
+export { Union, UnionEvaluated } from './type/union/index.mjs';
 export { Unknown } from './type/unknown/index.mjs';
 export { Unsafe } from './type/unsafe/index.mjs';
 export { Void } from './type/void/index.mjs';
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
 export { Type, JsonTypeBuilder, JavaScriptTypeBuilder } from './type/type/index.mjs';

package/build/import/system/index.mjs

@@ -1,2 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@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.
+
+---------------------------------------------------------------------------*/
 export { TypeSystemPolicy } from './policy.mjs';
 export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system.mjs';