@sinclair/typebox 0.29.6 → 0.30.0-dev-1

package/compiler/compiler.js

@@ -28,10 +28,11 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
+const index_1 = require("../system/index");
 const Types = require("../typebox");
-const index_1 = require("../errors/index");
-const index_2 = require("../system/index");
-const hash_1 = require("../value/hash");
+const ValueErrors = require("../errors/index");
+const ValueHash = require("../value/hash");
+const ValueGuard = require("../value/guard");
 // -------------------------------------------------------------------
 // TypeCheck
 // -------------------------------------------------------------------
@@ -48,7 +49,7 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return index_1.ValueErrors.Errors(this.schema, this.references, value);
+        return ValueErrors.Errors(this.schema, this.references, value);
     }
     /** Returns true if the value matches the compiled type. */
     Check(value) {
@@ -128,7 +129,7 @@ var Identifier;
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
 // -------------------------------------------------------------------
-// TypeCompiler
+// Errors
 // -------------------------------------------------------------------
 class TypeCompilerUnknownTypeError extends Error {
     constructor(schema) {
@@ -154,20 +155,8 @@ exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
 /** Compiles Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
-    // -------------------------------------------------------------------
-    // Guards
-    // -------------------------------------------------------------------
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    function IsNumber(value) {
-        return typeof value === 'number' && globalThis.Number.isFinite(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
     // ----------------------------------------------------------------------
-    // SchemaGuards
+    // Guards
     // ----------------------------------------------------------------------
     function IsAnyOrUnknown(schema) {
         return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown';
@@ -176,95 +165,110 @@ var TypeCompiler;
     // Polices
     // -------------------------------------------------------------------
     function IsExactOptionalProperty(value, key, expression) {
-        return index_2.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+        return index_1.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
     }
     function IsObjectCheck(value) {
-        return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+        return !index_1.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
     }
     function IsRecordCheck(value) {
-        return !index_2.TypeSystem.AllowArrayObjects
+        return !index_1.TypeSystem.AllowArrayObjects
             ? `(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))`;
     }
     function IsNumberCheck(value) {
-        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+        return !index_1.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
     }
     function IsVoidCheck(value) {
-        return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+        return index_1.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
     }
     // -------------------------------------------------------------------
     // Types
     // -------------------------------------------------------------------
-    function* Any(schema, references, value) {
+    function* TAny(schema, references, value) {
         yield 'true';
     }
-    function* Array(schema, references, value) {
+    function* TArray(schema, references, value) {
         yield `Array.isArray(${value})`;
-        if (IsNumber(schema.minItems))
+        const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
+        if (ValueGuard.IsNumber(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
-        if (IsNumber(schema.maxItems))
+        if (ValueGuard.IsNumber(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
-        if (schema.uniqueItems === true)
-            yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
-        const expression = CreateExpression(schema.items, references, 'value');
-        const parameter = CreateParameter('value', 'any');
-        yield `${value}.every((${parameter}) => ${expression})`;
+        const elementExpression = CreateExpression(schema.items, references, 'value');
+        yield `${value}.every((${parameter}) => ${elementExpression})`;
+        if (Types.TypeGuard.TSchema(schema.contains) || ValueGuard.IsNumber(schema.minContains) || ValueGuard.IsNumber(schema.maxContains)) {
+            const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never();
+            const checkExpression = CreateExpression(containsSchema, references, 'value');
+            const checkMinContains = ValueGuard.IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+            const checkMaxContains = ValueGuard.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})`;
+        }
+        if (schema.uniqueItems === true) {
+            const check = `const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true`;
+            const block = `const set = new Set(); for(const element of value) { ${check} }`;
+            yield `((${parameter}) => { ${block} )(${value})`;
+        }
     }
-    function* BigInt(schema, references, value) {
+    function* TAsyncIterator(schema, references, value) {
+        yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`;
+    }
+    function* TBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
-        if (IsBigInt(schema.multipleOf))
+        if (ValueGuard.IsBigInt(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
-        if (IsBigInt(schema.exclusiveMinimum))
+        if (ValueGuard.IsBigInt(schema.exclusiveMinimum))
             yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if (IsBigInt(schema.exclusiveMaximum))
+        if (ValueGuard.IsBigInt(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if (IsBigInt(schema.minimum))
+        if (ValueGuard.IsBigInt(schema.minimum))
             yield `${value} >= BigInt(${schema.minimum})`;
-        if (IsBigInt(schema.maximum))
+        if (ValueGuard.IsBigInt(schema.maximum))
             yield `${value} <= BigInt(${schema.maximum})`;
     }
-    function* Boolean(schema, references, value) {
+    function* TBoolean(schema, references, value) {
         yield `(typeof ${value} === 'boolean')`;
     }
-    function* Constructor(schema, references, value) {
+    function* TConstructor(schema, references, value) {
         yield* Visit(schema.returns, references, `${value}.prototype`);
     }
-    function* Date(schema, references, value) {
+    function* TDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if (IsNumber(schema.exclusiveMinimumTimestamp))
+        if (ValueGuard.IsNumber(schema.exclusiveMinimumTimestamp))
             yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if (IsNumber(schema.exclusiveMaximumTimestamp))
+        if (ValueGuard.IsNumber(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if (IsNumber(schema.minimumTimestamp))
+        if (ValueGuard.IsNumber(schema.minimumTimestamp))
             yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if (IsNumber(schema.maximumTimestamp))
+        if (ValueGuard.IsNumber(schema.maximumTimestamp))
             yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
     }
-    function* Function(schema, references, value) {
+    function* TFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
-    function* Integer(schema, references, value) {
+    function* TInteger(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
-        if (IsNumber(schema.multipleOf))
+        if (ValueGuard.IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
-        if (IsNumber(schema.exclusiveMinimum))
+        if (ValueGuard.IsNumber(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if (IsNumber(schema.exclusiveMaximum))
+        if (ValueGuard.IsNumber(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if (IsNumber(schema.minimum))
+        if (ValueGuard.IsNumber(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if (IsNumber(schema.maximum))
+        if (ValueGuard.IsNumber(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
     }
-    function* Intersect(schema, references, value) {
+    function* TIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
         if (schema.unevaluatedProperties === false) {
-            const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
             yield `(${check1} && ${check2})`;
         }
         else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
-            const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
+            const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
             yield `(${check1} && ${check2})`;
         }
@@ -272,7 +276,10 @@ var TypeCompiler;
             yield `(${check1})`;
         }
     }
-    function* Literal(schema, references, value) {
+    function* TIterator(schema, references, value) {
+        yield `(typeof value === 'object' && Symbol.iterator in ${value})`;
+    }
+    function* TLiteral(schema, references, value) {
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
@@ -280,36 +287,36 @@ var TypeCompiler;
             yield `(${value} === '${schema.const}')`;
         }
     }
-    function* Never(schema, references, value) {
+    function* TNever(schema, references, value) {
         yield `false`;
     }
-    function* Not(schema, references, value) {
+    function* TNot(schema, references, value) {
         const expression = CreateExpression(schema.not, references, value);
         yield `(!${expression})`;
     }
-    function* Null(schema, references, value) {
+    function* TNull(schema, references, value) {
         yield `(${value} === null)`;
     }
-    function* Number(schema, references, value) {
+    function* TNumber(schema, references, value) {
         yield IsNumberCheck(value);
-        if (IsNumber(schema.multipleOf))
+        if (ValueGuard.IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
-        if (IsNumber(schema.exclusiveMinimum))
+        if (ValueGuard.IsNumber(schema.exclusiveMinimum))
             yield `${value} > ${schema.exclusiveMinimum}`;
-        if (IsNumber(schema.exclusiveMaximum))
+        if (ValueGuard.IsNumber(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
-        if (IsNumber(schema.minimum))
+        if (ValueGuard.IsNumber(schema.minimum))
             yield `${value} >= ${schema.minimum}`;
-        if (IsNumber(schema.maximum))
+        if (ValueGuard.IsNumber(schema.maximum))
             yield `${value} <= ${schema.maximum}`;
     }
-    function* Object(schema, references, value) {
+    function* TObject(schema, references, value) {
         yield IsObjectCheck(value);
-        if (IsNumber(schema.minProperties))
+        if (ValueGuard.IsNumber(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if (IsNumber(schema.maxProperties))
+        if (ValueGuard.IsNumber(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        const knownKeys = Object.getOwnPropertyNames(schema.properties);
         for (const knownKey of knownKeys) {
             const memberExpression = MemberExpression.Encode(value, knownKey);
             const property = schema.properties[knownKey];
@@ -338,61 +345,60 @@ var TypeCompiler;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }
-    function* Promise(schema, references, value) {
+    function* TPromise(schema, references, value) {
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
-    function* Record(schema, references, value) {
+    function* TRecord(schema, references, value) {
         yield IsRecordCheck(value);
-        if (IsNumber(schema.minProperties))
+        if (ValueGuard.IsNumber(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if (IsNumber(schema.maxProperties))
+        if (ValueGuard.IsNumber(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const local = PushLocal(`new RegExp(/${patternKey}/)`);
+        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 expression = `(${local}.test(key) ? ${check1} : ${check2})`;
+        const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
-    function* Ref(schema, references, value) {
+    function* TRef(schema, references, value) {
         const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
         if (index === -1)
             throw new TypeCompilerDereferenceError(schema);
         const target = references[index];
-        // 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.
+        // 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);
     }
-    function* String(schema, references, value) {
+    function* TString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        if (IsNumber(schema.minLength))
+        if (ValueGuard.IsNumber(schema.minLength))
             yield `${value}.length >= ${schema.minLength}`;
-        if (IsNumber(schema.maxLength))
+        if (ValueGuard.IsNumber(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
         if (schema.pattern !== undefined) {
-            const local = PushLocal(`${new RegExp(schema.pattern)};`);
-            yield `${local}.test(${value})`;
+            const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
+            yield `${variable}.test(${value})`;
         }
         if (schema.format !== undefined) {
             yield `format('${schema.format}', ${value})`;
         }
     }
-    function* Symbol(schema, references, value) {
+    function* TSymbol(schema, references, value) {
         yield `(typeof ${value} === 'symbol')`;
     }
-    function* TemplateLiteral(schema, references, value) {
+    function* TTemplateLiteral(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
-        const local = PushLocal(`${new RegExp(schema.pattern)};`);
-        yield `${local}.test(${value})`;
+        const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
+        yield `${variable}.test(${value})`;
     }
-    function* This(schema, references, value) {
+    function* TThis(schema, references, value) {
         const func = CreateFunctionName(schema.$ref);
         yield `${func}(${value})`;
     }
-    function* Tuple(schema, references, value) {
+    function* TTuple(schema, references, value) {
         yield `Array.isArray(${value})`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
@@ -402,112 +408,114 @@ var TypeCompiler;
             yield `${expression}`;
         }
     }
-    function* Undefined(schema, references, value) {
+    function* TUndefined(schema, references, value) {
         yield `${value} === undefined`;
     }
-    function* Union(schema, references, value) {
+    function* TUnion(schema, references, value) {
         const expressions = schema.anyOf.map((schema) => CreateExpression(schema, references, value));
         yield `(${expressions.join(' || ')})`;
     }
-    function* Uint8Array(schema, references, value) {
+    function* TUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
-        if (IsNumber(schema.maxByteLength))
+        if (ValueGuard.IsNumber(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
-        if (IsNumber(schema.minByteLength))
+        if (ValueGuard.IsNumber(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
-    function* Unknown(schema, references, value) {
+    function* TUnknown(schema, references, value) {
         yield 'true';
     }
-    function* Void(schema, references, value) {
+    function* TVoid(schema, references, value) {
         yield IsVoidCheck(value);
     }
-    function* UserDefined(schema, references, value) {
-        const schema_key = `schema_key_${state.customs.size}`;
-        state.customs.set(schema_key, schema);
-        yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
+    function* TKind(schema, references, value) {
+        yield `kind('${schema[Types.Kind]}', ${value})`;
     }
-    function* Visit(schema, references, value, root = false) {
-        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    function* Visit(schema, references, value, useHoisting = true) {
+        const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
-        // Rule: Types with identifiers are hoisted into their own functions.
-        // The following will generate a function for the schema and yield the
-        // call to that function. This call is only made if NOT the root type
-        // which allows the generated function to yield its expression. The
-        // root argument is only true when making calls via CreateFunction().
-        // Note there is potential to omit the root argument and conditional
-        // by refactoring the logic below. Consider for review.
-        if (IsString(schema.$id)) {
-            const name = CreateFunctionName(schema.$id);
-            if (!state.functions.has(schema.$id)) {
-                state.functions.add(schema.$id);
-                const body = CreateFunction(name, schema, references, 'value');
-                PushFunction(body);
+        // ----------------------------------------------------------------------------------
+        // Hoisting
+        // ----------------------------------------------------------------------------------
+        if (useHoisting && ValueGuard.IsString(schema.$id)) {
+            const functionName = CreateFunctionName(schema.$id);
+            if (state.functions.has(functionName)) {
+                return yield `${functionName}(${value})`;
+            }
+            else {
+                const functionCode = CreateFunction(functionName, schema, references, 'value', false);
+                state.functions.set(functionName, functionCode);
+                return yield `${functionName}(${value})`;
             }
-            if (!root)
-                return yield `${name}(${value})`;
         }
+        // ----------------------------------------------------------------------------------
+        // Types
+        // ----------------------------------------------------------------------------------
         switch (schema_[Types.Kind]) {
             case 'Any':
-                return yield* Any(schema_, references_, value);
+                return yield* TAny(schema_, references_, value);
             case 'Array':
-                return yield* Array(schema_, references_, value);
+                return yield* TArray(schema_, references_, value);
+            case 'AsyncIterator':
+                return yield* TAsyncIterator(schema_, references_, value);
             case 'BigInt':
-                return yield* BigInt(schema_, references_, value);
+                return yield* TBigInt(schema_, references_, value);
             case 'Boolean':
-                return yield* Boolean(schema_, references_, value);
+                return yield* TBoolean(schema_, references_, value);
             case 'Constructor':
-                return yield* Constructor(schema_, references_, value);
+                return yield* TConstructor(schema_, references_, value);
             case 'Date':
-                return yield* Date(schema_, references_, value);
+                return yield* TDate(schema_, references_, value);
             case 'Function':
-                return yield* Function(schema_, references_, value);
+                return yield* TFunction(schema_, references_, value);
             case 'Integer':
-                return yield* Integer(schema_, references_, value);
+                return yield* TInteger(schema_, references_, value);
             case 'Intersect':
-                return yield* Intersect(schema_, references_, value);
+                return yield* TIntersect(schema_, references_, value);
+            case 'Iterator':
+                return yield* TIterator(schema_, references_, value);
             case 'Literal':
-                return yield* Literal(schema_, references_, value);
+                return yield* TLiteral(schema_, references_, value);
             case 'Never':
-                return yield* Never(schema_, references_, value);
+                return yield* TNever(schema_, references_, value);
             case 'Not':
-                return yield* Not(schema_, references_, value);
+                return yield* TNot(schema_, references_, value);
             case 'Null':
-                return yield* Null(schema_, references_, value);
+                return yield* TNull(schema_, references_, value);
             case 'Number':
-                return yield* Number(schema_, references_, value);
+                return yield* TNumber(schema_, references_, value);
             case 'Object':
-                return yield* Object(schema_, references_, value);
+                return yield* TObject(schema_, references_, value);
             case 'Promise':
-                return yield* Promise(schema_, references_, value);
+                return yield* TPromise(schema_, references_, value);
             case 'Record':
-                return yield* Record(schema_, references_, value);
+                return yield* TRecord(schema_, references_, value);
             case 'Ref':
-                return yield* Ref(schema_, references_, value);
+                return yield* TRef(schema_, references_, value);
             case 'String':
-                return yield* String(schema_, references_, value);
+                return yield* TString(schema_, references_, value);
             case 'Symbol':
-                return yield* Symbol(schema_, references_, value);
+                return yield* TSymbol(schema_, references_, value);
             case 'TemplateLiteral':
-                return yield* TemplateLiteral(schema_, references_, value);
+                return yield* TTemplateLiteral(schema_, references_, value);
             case 'This':
-                return yield* This(schema_, references_, value);
+                return yield* TThis(schema_, references_, value);
             case 'Tuple':
-                return yield* Tuple(schema_, references_, value);
+                return yield* TTuple(schema_, references_, value);
             case 'Undefined':
-                return yield* Undefined(schema_, references_, value);
+                return yield* TUndefined(schema_, references_, value);
             case 'Union':
-                return yield* Union(schema_, references_, value);
+                return yield* TUnion(schema_, references_, value);
             case 'Uint8Array':
-                return yield* Uint8Array(schema_, references_, value);
+                return yield* TUint8Array(schema_, references_, value);
             case 'Unknown':
-                return yield* Unknown(schema_, references_, value);
+                return yield* TUnknown(schema_, references_, value);
             case 'Void':
-                return yield* Void(schema_, references_, value);
+                return yield* TVoid(schema_, references_, value);
             default:
                 if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
-                return yield* UserDefined(schema_, references_, value);
+                return yield* TKind(schema_, references_, value);
         }
     }
     // -------------------------------------------------------------------
@@ -516,15 +524,29 @@ var TypeCompiler;
     // prettier-ignore
     const state = {
         language: 'javascript',
-        variables: new Set(),
-        functions: new Set(),
-        customs: new Map(), // custom type data
+        functions: new Map(),
+        variables: new Map(), // local variables
     };
+    // -------------------------------------------------------------------
+    // Compiler Factory
+    // -------------------------------------------------------------------
+    function CreateExpression(schema, references, value, useHoisting = true) {
+        return `(${[...Visit(schema, references, value, useHoisting)].join(' && ')})`;
+    }
     function CreateFunctionName($id) {
         return `check_${Identifier.Encode($id)}`;
     }
-    function CreateExpression(schema, references, value) {
-        return `(${[...Visit(schema, references, value)].join(' && ')})`;
+    function CreateVariable(expression) {
+        const variableName = `local_${state.variables.size}`;
+        state.variables.set(variableName, `const ${variableName} = ${expression}`);
+        return variableName;
+    }
+    function CreateFunction(name, schema, references, value, useHoisting = true) {
+        const [newline, pad] = ['\n', (length) => ''.padStart(length, ' ')];
+        const parameter = CreateParameter('value', 'any');
+        const returns = CreateReturns('boolean');
+        const expression = [...Visit(schema, references, value, useHoisting)].map((expression) => `${pad(4)}${expression}`).join(` &&${newline}`);
+        return `function ${name}(${parameter})${returns} {${newline}${pad(2)}return (${newline}${expression}${newline}${pad(2)})\n}`;
     }
     function CreateParameter(name, type) {
         const annotation = state.language === 'typescript' ? `: ${type}` : '';
@@ -533,71 +555,63 @@ var TypeCompiler;
     function CreateReturns(type) {
         return state.language === 'typescript' ? `: ${type}` : '';
     }
-    function CreateFunction(name, schema, references, value) {
-        const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n');
-        const parameter = CreateParameter('value', 'any');
-        const returns = CreateReturns('boolean');
-        return `function ${name}(${parameter})${returns} {\n  return (\n${expression}\n )\n}`;
-    }
-    function PushFunction(functionBody) {
-        state.variables.add(functionBody);
-    }
-    function PushLocal(expression) {
-        const local = `local_${state.variables.size}`;
-        state.variables.add(`const ${local} = ${expression}`);
-        return local;
-    }
-    function GetLocals() {
-        return [...state.variables.values()];
-    }
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
-    function Build(schema, references) {
-        const check = CreateFunction('check', schema, references, 'value'); // interior visit
-        const locals = GetLocals();
+    function Build(schema, references, options) {
+        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()];
         // prettier-ignore
-        return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
-            ? `${locals.join('\n')}\nreturn function check(${parameter})${returns} {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
-            : `${locals.join('\n')}\nreturn ${check}`;
+        const checkFunction = ValueGuard.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');
     }
     /** Returns the generated assertion code used to validate this type. */
-    function Code(schema, references = [], options = { language: 'javascript' }) {
+    function Code(...args) {
+        const defaults = { language: 'javascript' };
+        // prettier-ignore
+        const [schema, references, options] = (args.length === 2 && ValueGuard.IsArray(args[1]) ? [args[0], args[1], defaults] :
+            args.length === 2 && !ValueGuard.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();
-        state.customs.clear();
         if (!Types.TypeGuard.TSchema(schema))
             throw new TypeCompilerTypeGuardError(schema);
         for (const schema of references)
             if (!Types.TypeGuard.TSchema(schema))
                 throw new TypeCompilerTypeGuardError(schema);
-        return Build(schema, references);
+        return Build(schema, references, options);
     }
     TypeCompiler.Code = Code;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
-        const code = Code(schema, references, { language: 'javascript' });
-        const customs = new Map(state.customs);
-        const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
-        const checkFunction = compiledFunction((kind, schema_key, value) => {
-            if (!Types.TypeRegistry.Has(kind) || !customs.has(schema_key))
+        const generatedCode = Code(schema, references, { language: 'javascript' });
+        const compiledFunction = globalThis.Function('kind', 'format', 'hash', generatedCode);
+        function typeRegistryFunction(kind, value) {
+            if (!Types.TypeRegistry.Has(kind))
                 return false;
-            const schema = customs.get(schema_key);
-            const func = Types.TypeRegistry.Get(kind);
-            return func(schema, value);
-        }, (format, value) => {
+            const checkFunc = Types.TypeRegistry.Get(kind);
+            return checkFunc(schema, value);
+        }
+        function formatRegistryFunction(format, value) {
             if (!Types.FormatRegistry.Has(format))
                 return false;
-            const func = Types.FormatRegistry.Get(format);
-            return func(value);
-        }, (value) => {
-            return hash_1.ValueHash.Create(value);
-        });
-        return new TypeCheck(schema, references, checkFunction, code);
+            const checkFunc = Types.FormatRegistry.Get(format);
+            return checkFunc(value);
+        }
+        function valueHashFunction(value) {
+            return ValueHash.Hash(value);
+        }
+        const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, valueHashFunction);
+        return new TypeCheck(schema, references, checkFunction, generatedCode);
     }
     TypeCompiler.Compile = Compile;
 })(TypeCompiler || (exports.TypeCompiler = TypeCompiler = {}));