@sinclair/typebox 0.31.28 → 0.32.0-dev-1

package/compiler/compiler.d.ts

@@ -1,31 +1,38 @@
-import { ValueErrorIterator } from '../errors/errors';
-import * as Types from '../typebox';
+import { ValueErrorIterator } from '../errors/index';
+import type { TSchema } from '../type/schema/index';
+import type { Static, StaticDecode, StaticEncode } from '../type/static/index';
 export type CheckFunction = (value: unknown) => boolean;
-export declare class TypeCheck<T extends Types.TSchema> {
+export declare class TypeCheck<T extends TSchema> {
     private readonly schema;
     private readonly references;
     private readonly checkFunc;
     private readonly code;
     private readonly hasTransform;
-    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
+    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 Types.Static<T>;
-    /** Decodes a value or throws if error */
-    Decode(value: unknown): Types.StaticDecode<T>;
-    /** Encodes a value or throws if error */
-    Encode(value: unknown): Types.StaticEncode<T>;
+    Check(value: unknown): value is Static<T>;
+    /**
+     * Decodes a value or throws if error
+     * @deprecated Use raw `Decode` from `Value` module
+     */
+    Decode(value: unknown): StaticDecode<T>;
+    /**
+     * Encodes a value or throws if error
+     * @deprecated Use raw `Encode` from `Value` module
+     */
+    Encode(value: unknown): StaticEncode<T>;
 }
-export declare class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
+export declare class TypeCompilerUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
 }
-export declare class TypeCompilerTypeGuardError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
+export declare class TypeCompilerTypeGuardError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
 }
 export declare namespace Policy {
     function IsExactOptionalProperty(value: string, key: string, expression: string): string;
@@ -41,9 +48,9 @@ export interface TypeCompilerCodegenOptions {
 /** 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 Types.TSchema>(schema: T, references: Types.TSchema[], options?: TypeCompilerCodegenOptions): 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 Types.TSchema>(schema: T, options?: TypeCompilerCodegenOptions): 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 Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
+    function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -28,23 +28,28 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
-const transform_1 = require("../value/transform");
-const guard_1 = require("../value/guard");
-const errors_1 = require("../errors/errors");
-const index_1 = require("../system/index");
-const deref_1 = require("../value/deref");
-const hash_1 = require("../value/hash");
-const Types = require("../typebox");
-// -------------------------------------------------------------------
+const index_1 = require("../value/transform/index");
+const index_2 = require("../value/guard/index");
+const index_3 = require("../errors/index");
+const index_4 = require("../system/index");
+const index_5 = require("../value/deref/index");
+const index_6 = require("../value/hash/index");
+const index_7 = require("../type/symbols/index");
+const type_1 = require("../type/guard/type");
+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;
         this.references = references;
         this.checkFunc = checkFunc;
         this.code = code;
-        this.hasTransform = transform_1.HasTransform.Has(schema, references);
+        this.hasTransform = (0, index_1.HasTransform)(schema, references);
     }
     /** Returns the generated assertion code used to validate this type. */
     Code() {
@@ -52,30 +57,36 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return (0, errors_1.Errors)(this.schema, this.references, 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 */
+    /**
+     * Decodes a value or throws if error
+     * @deprecated Use raw `Decode` from `Value` module
+     */
     Decode(value) {
         if (!this.checkFunc(value))
-            throw new transform_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
-        return this.hasTransform ? transform_1.DecodeTransform.Decode(this.schema, this.references, value) : value;
+            throw new index_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
+        return this.hasTransform ? (0, index_1.Decode)(this.schema, this.references, value) : value;
     }
-    /** Encodes a value or throws if error */
+    /**
+     * Encodes a value or throws if error
+     * @deprecated Use raw `Encode` from `Value` module
+     */
     Encode(value) {
-        const encoded = this.hasTransform ? transform_1.EncodeTransform.Encode(this.schema, this.references, value) : value;
+        const encoded = this.hasTransform ? (0, index_1.Encode)(this.schema, this.references, value) : value;
         if (!this.checkFunc(encoded))
-            throw new transform_1.TransformEncodeCheckError(this.schema, value, this.Errors(value).First());
+            throw new index_1.TransformEncodeCheckError(this.schema, value, this.Errors(value).First());
         return encoded;
     }
 }
 exports.TypeCheck = TypeCheck;
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Character
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 var Character;
 (function (Character) {
     function DollarSign(code) {
@@ -95,9 +106,9 @@ var Character;
     }
     Character.IsNumeric = IsNumeric;
 })(Character || (Character = {}));
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // MemberExpression
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 var MemberExpression;
 (function (MemberExpression) {
     function IsFirstCharacterNumeric(value) {
@@ -124,9 +135,9 @@ var MemberExpression;
     }
     MemberExpression.Encode = Encode;
 })(MemberExpression || (MemberExpression = {}));
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Identifier
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 var Identifier;
 (function (Identifier) {
     function Encode($id) {
@@ -144,9 +155,9 @@ var Identifier;
     }
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // LiteralString
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 var LiteralString;
 (function (LiteralString) {
     function Escape(content) {
@@ -154,80 +165,80 @@ var LiteralString;
     }
     LiteralString.Escape = Escape;
 })(LiteralString || (LiteralString = {}));
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Errors
-// -------------------------------------------------------------------
-class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
+// ------------------------------------------------------------------
+class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
     }
 }
 exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
-class TypeCompilerTypeGuardError extends Types.TypeBoxError {
+class TypeCompilerTypeGuardError extends Error {
     constructor(schema) {
         super('Preflight validation check failed to guard for the given schema');
         this.schema = schema;
     }
 }
 exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Policy
-// -------------------------------------------------------------------
+// ------------------------------------------------------------------
 var Policy;
 (function (Policy) {
     function IsExactOptionalProperty(value, key, expression) {
-        return index_1.TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+        return index_4.TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
     }
     Policy.IsExactOptionalProperty = IsExactOptionalProperty;
     function IsObjectLike(value) {
-        return !index_1.TypeSystemPolicy.AllowArrayObject ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+        return !index_4.TypeSystemPolicy.AllowArrayObject ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
     }
     Policy.IsObjectLike = IsObjectLike;
     function IsRecordLike(value) {
-        return !index_1.TypeSystemPolicy.AllowArrayObject
+        return !index_4.TypeSystemPolicy.AllowArrayObject
             ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
             : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
     }
     Policy.IsRecordLike = IsRecordLike;
     function IsNumberLike(value) {
-        return !index_1.TypeSystemPolicy.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+        return !index_4.TypeSystemPolicy.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
     }
     Policy.IsNumberLike = IsNumberLike;
     function IsVoidLike(value) {
-        return index_1.TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+        return index_4.TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
     }
     Policy.IsVoidLike = IsVoidLike;
 })(Policy || (exports.Policy = Policy = {}));
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
-    // ----------------------------------------------------------------------
+    // ----------------------------------------------------------------
     // Guards
-    // ----------------------------------------------------------------------
+    // ----------------------------------------------------------------
     function IsAnyOrUnknown(schema) {
-        return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown';
+        return schema[index_7.Kind] === 'Any' || schema[index_7.Kind] === 'Unknown';
     }
-    // -------------------------------------------------------------------
+    // ----------------------------------------------------------------
     // Types
-    // -------------------------------------------------------------------
+    // ----------------------------------------------------------------
     function* TAny(schema, references, value) {
         yield 'true';
     }
     function* TArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
-        if ((0, guard_1.IsNumber)(schema.maxItems))
+        if ((0, index_2.IsNumber)(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
-        if ((0, guard_1.IsNumber)(schema.minItems))
+        if ((0, index_2.IsNumber)(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if (Types.TypeGuard.TSchema(schema.contains) || (0, guard_1.IsNumber)(schema.minContains) || (0, guard_1.IsNumber)(schema.maxContains)) {
-            const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never();
+        if ((0, type_1.TSchema)(schema.contains) || (0, index_2.IsNumber)(schema.minContains) || (0, index_2.IsNumber)(schema.maxContains)) {
+            const containsSchema = (0, type_1.TSchema)(schema.contains) ? schema.contains : (0, index_10.Never)();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
-            const checkMinContains = (0, guard_1.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
-            const checkMaxContains = (0, guard_1.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+            const checkMinContains = (0, index_2.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = (0, index_2.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
             const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
             const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(' && ');
             yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
@@ -243,15 +254,15 @@ var TypeCompiler;
     }
     function* TBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if ((0, guard_1.IsBigInt)(schema.exclusiveMaximum))
+        if ((0, index_2.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if ((0, guard_1.IsBigInt)(schema.exclusiveMinimum))
+        if ((0, index_2.IsBigInt)(schema.exclusiveMinimum))
             yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if ((0, guard_1.IsBigInt)(schema.maximum))
+        if ((0, index_2.IsBigInt)(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
-        if ((0, guard_1.IsBigInt)(schema.minimum))
+        if ((0, index_2.IsBigInt)(schema.minimum))
             yield `${value} >= BigInt(${schema.minimum})`;
-        if ((0, guard_1.IsBigInt)(schema.multipleOf))
+        if ((0, index_2.IsBigInt)(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
     function* TBoolean(schema, references, value) {
@@ -262,15 +273,15 @@ var TypeCompiler;
     }
     function* TDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if ((0, guard_1.IsNumber)(schema.exclusiveMaximumTimestamp))
+        if ((0, index_2.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if ((0, guard_1.IsNumber)(schema.exclusiveMinimumTimestamp))
+        if ((0, index_2.IsNumber)(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if ((0, guard_1.IsNumber)(schema.maximumTimestamp))
+        if ((0, index_2.IsNumber)(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
-        if ((0, guard_1.IsNumber)(schema.minimumTimestamp))
+        if ((0, index_2.IsNumber)(schema.minimumTimestamp))
             yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if ((0, guard_1.IsNumber)(schema.multipleOfTimestamp))
+        if ((0, index_2.IsNumber)(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
     function* TFunction(schema, references, value) {
@@ -278,26 +289,26 @@ var TypeCompiler;
     }
     function* TInteger(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
-        if ((0, guard_1.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_2.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, guard_1.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_2.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, guard_1.IsNumber)(schema.maximum))
+        if ((0, index_2.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, guard_1.IsNumber)(schema.minimum))
+        if ((0, index_2.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, guard_1.IsNumber)(schema.multipleOf))
+        if ((0, index_2.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* TIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
         if (schema.unevaluatedProperties === false) {
-            const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfStringResolvePattern)(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
             yield `(${check1} && ${check2})`;
         }
-        else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-            const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
+        else if ((0, type_1.TSchema)(schema.unevaluatedProperties)) {
+            const keyCheck = CreateVariable(`${new RegExp((0, index_9.KeyOfStringResolvePattern)(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
             yield `(${check1} && ${check2})`;
         }
@@ -328,22 +339,22 @@ var TypeCompiler;
     }
     function* TNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
-        if ((0, guard_1.IsNumber)(schema.exclusiveMaximum))
+        if ((0, index_2.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if ((0, guard_1.IsNumber)(schema.exclusiveMinimum))
+        if ((0, index_2.IsNumber)(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if ((0, guard_1.IsNumber)(schema.maximum))
+        if ((0, index_2.IsNumber)(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
-        if ((0, guard_1.IsNumber)(schema.minimum))
+        if ((0, index_2.IsNumber)(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if ((0, guard_1.IsNumber)(schema.multipleOf))
+        if ((0, index_2.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
     function* TObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
-        if ((0, guard_1.IsNumber)(schema.minProperties))
+        if ((0, index_2.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, guard_1.IsNumber)(schema.maxProperties))
+        if ((0, index_2.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
@@ -351,7 +362,7 @@ var TypeCompiler;
             const property = schema.properties[knownKey];
             if (schema.required && schema.required.includes(knownKey)) {
                 yield* Visit(property, references, memberExpression);
-                if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property))
+                if ((0, extends_undefined_1.ExtendsUndefinedCheck)(property) || IsAnyOrUnknown(property))
                     yield `('${knownKey}' in ${value})`;
             }
             else {
@@ -379,19 +390,19 @@ var TypeCompiler;
     }
     function* TRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
-        if ((0, guard_1.IsNumber)(schema.minProperties))
+        if ((0, index_2.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if ((0, guard_1.IsNumber)(schema.maxProperties))
+        if ((0, index_2.IsNumber)(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`${new RegExp(patternKey)}`);
         const check1 = CreateExpression(patternSchema, references, 'value');
-        const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true';
+        const check2 = (0, type_1.TSchema)(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true';
         const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
     function* TRef(schema, references, value) {
-        const target = (0, deref_1.Deref)(schema, references);
+        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))
@@ -400,9 +411,9 @@ var TypeCompiler;
     }
     function* TString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if ((0, guard_1.IsNumber)(schema.maxLength))
+        if ((0, index_2.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
-        if ((0, guard_1.IsNumber)(schema.minLength))
+        if ((0, index_2.IsNumber)(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
         if (schema.pattern !== undefined) {
             const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
@@ -443,9 +454,9 @@ var TypeCompiler;
     }
     function* TUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if ((0, guard_1.IsNumber)(schema.maxByteLength))
+        if ((0, index_2.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if ((0, guard_1.IsNumber)(schema.minByteLength))
+        if ((0, index_2.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
     function* TUnknown(schema, references, value) {
@@ -457,15 +468,15 @@ var TypeCompiler;
     function* TKind(schema, references, value) {
         const instance = state.instances.size;
         state.instances.set(instance, schema);
-        yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`;
+        yield `kind('${schema[index_7.Kind]}', ${instance}, ${value})`;
     }
     function* Visit(schema, references, value, useHoisting = true) {
-        const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
+        const references_ = (0, index_2.IsString)(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
-        // ----------------------------------------------------------------------------------
+        // --------------------------------------------------------------
         // Hoisting
-        // ----------------------------------------------------------------------------------
-        if (useHoisting && (0, guard_1.IsString)(schema.$id)) {
+        // --------------------------------------------------------------
+        if (useHoisting && (0, index_2.IsString)(schema.$id)) {
             const functionName = CreateFunctionName(schema.$id);
             if (state.functions.has(functionName)) {
                 return yield `${functionName}(${value})`;
@@ -476,7 +487,7 @@ var TypeCompiler;
                 return yield `${functionName}(${value})`;
             }
         }
-        switch (schema_[Types.Kind]) {
+        switch (schema_[index_7.Kind]) {
             case 'Any':
                 return yield* TAny(schema_, references_, value);
             case 'Array':
@@ -538,24 +549,24 @@ var TypeCompiler;
             case 'Void':
                 return yield* TVoid(schema_, references_, value);
             default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                if (!index_8.TypeRegistry.Has(schema_[index_7.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
                 return yield* TKind(schema_, references_, value);
         }
     }
-    // -------------------------------------------------------------------
+    // ----------------------------------------------------------------
     // Compiler State
-    // -------------------------------------------------------------------
+    // ----------------------------------------------------------------
     // prettier-ignore
     const state = {
-        language: 'javascript',
-        functions: new Map(),
-        variables: 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(' && ')})`;
     }
@@ -581,9 +592,9 @@ var TypeCompiler;
     function CreateReturns(type) {
         return state.language === 'typescript' ? `: ${type}` : '';
     }
-    // -------------------------------------------------------------------
+    // ----------------------------------------------------------------
     // Compile
-    // -------------------------------------------------------------------
+    // ----------------------------------------------------------------
     function Build(schema, references, options) {
         const functionCode = CreateFunction('check', schema, references, 'value'); // will populate functions and variables
         const parameter = CreateParameter('value', 'any');
@@ -591,7 +602,7 @@ var TypeCompiler;
         const functions = [...state.functions.values()];
         const variables = [...state.variables.values()];
         // prettier-ignore
-        const checkFunction = (0, guard_1.IsString)(schema.$id) // ensure top level schemas with $id's are hoisted
+        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');
@@ -600,8 +611,8 @@ var TypeCompiler;
     function Code(...args) {
         const defaults = { language: 'javascript' };
         // prettier-ignore
-        const [schema, references, options] = (args.length === 2 && (0, guard_1.IsArray)(args[1]) ? [args[0], args[1], defaults] :
-            args.length === 2 && !(0, guard_1.IsArray)(args[1]) ? [args[0], [], args[1]] :
+        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]);
@@ -610,10 +621,10 @@ var TypeCompiler;
         state.variables.clear();
         state.functions.clear();
         state.instances.clear();
-        if (!Types.TypeGuard.TSchema(schema))
+        if (!(0, type_1.TSchema)(schema))
             throw new TypeCompilerTypeGuardError(schema);
         for (const schema of references)
-            if (!Types.TypeGuard.TSchema(schema))
+            if (!(0, type_1.TSchema)(schema))
                 throw new TypeCompilerTypeGuardError(schema);
         return Build(schema, references, options);
     }
@@ -624,20 +635,20 @@ var TypeCompiler;
         const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);
         const instances = new Map(state.instances);
         function typeRegistryFunction(kind, instance, value) {
-            if (!Types.TypeRegistry.Has(kind) || !instances.has(instance))
+            if (!index_8.TypeRegistry.Has(kind) || !instances.has(instance))
                 return false;
-            const checkFunc = Types.TypeRegistry.Get(kind);
+            const checkFunc = index_8.TypeRegistry.Get(kind);
             const schema = instances.get(instance);
             return checkFunc(schema, value);
         }
         function formatRegistryFunction(format, value) {
-            if (!Types.FormatRegistry.Has(format))
+            if (!index_8.FormatRegistry.Has(format))
                 return false;
-            const checkFunc = Types.FormatRegistry.Get(format);
+            const checkFunc = index_8.FormatRegistry.Get(format);
             return checkFunc(value);
         }
         function hashFunction(value) {
-            return (0, hash_1.Hash)(value);
+            return (0, index_6.Hash)(value);
         }
         const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, hashFunction);
         return new TypeCheck(schema, references, checkFunction, generatedCode);

package/errors/errors.d.ts

@@ -1,4 +1,4 @@
-import * as Types from '../typebox';
+import type { TSchema } from '../type/schema/index';
 export declare enum ValueErrorType {
     ArrayContains = 0,
     ArrayMaxContains = 1,
@@ -66,14 +66,14 @@ export declare enum ValueErrorType {
 }
 export interface ValueError {
     type: ValueErrorType;
-    schema: Types.TSchema;
+    schema: TSchema;
     path: string;
     value: unknown;
     message: string;
 }
-export declare class ValueErrorsUnknownTypeError extends Types.TypeBoxError {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
+export declare class ValueErrorsUnknownTypeError extends Error {
+    readonly schema: TSchema;
+    constructor(schema: TSchema);
 }
 export declare function EscapeKey(key: string): string;
 export declare class ValueErrorIterator {
@@ -84,6 +84,6 @@ export declare class ValueErrorIterator {
     First(): ValueError | undefined;
 }
 /** Returns an iterator for each error in this value. */
-export declare function Errors<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): ValueErrorIterator;
+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 Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
+export declare function Errors<T extends TSchema>(schema: T, value: unknown): ValueErrorIterator;