typebox 1.1.36 → 1.1.38

package/build/compile/code.mjs

@@ -45,8 +45,8 @@ function FunctionSection(build) {
 // ------------------------------------------------------------------
 function ExportSection(build) {
     const body = build.UseUnevaluated()
-        ? `const context = new CheckContext({}, {}); return ${build.Call()}`
-        : `return ${build.Call()}`;
+        ? `const context = new CheckContext({}, {}); return ${build.Entry()}`
+        : `return ${build.Entry()}`;
     return [
         Separator(),
         TsIgnore(),

package/build/compile/validator.d.mts

@@ -1,16 +1,14 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
+import { BuildResult, EvaluateResult } from '../schema/index.mjs';
 export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
-    private readonly context;
-    private readonly type;
-    private readonly isAccelerated;
     private readonly hasCodec;
-    private readonly code;
-    private readonly check;
+    private readonly buildResult;
+    private readonly evaluateResult;
     /** Constructs a Validator with the given Context and Type. */
     constructor(context: Context, type: Type);
     /** Constructs a Validator with the given arguments. */
-    constructor(context: Context, type: Type, isEvaluated: boolean, hasCodec: boolean, code: string, check: (value: unknown) => boolean);
+    constructor(hasCodec: boolean, buildResult: BuildResult, evaluateResult: EvaluateResult);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
     /** Returns the Context for this validator. */
@@ -21,6 +19,8 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Code(): string;
     /** Performs a type-guard check on the provided value. */
     Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
@@ -31,12 +31,13 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Create(): Encode;
     /** Creates defaults using the Validator type. */
     Default(value: unknown): unknown;
-    /** Clones this validator. */
-    Clone(): Validator<Context, Type>;
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value: unknown): Encode;
     /** Decodes a value */
     Decode(value: unknown): Decode;
     /** Encodes a value */
     Encode(value: unknown): Encode;
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone(): Validator<Context, Type>;
 }

package/build/compile/validator.mjs

@@ -1,10 +1,9 @@
 // deno-fmt-ignore-file
 import { Settings } from '../system/settings/index.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
-import { Environment } from '../system/environment/index.mjs';
 import { Base } from '../type/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
-import { Build } from '../schema/index.mjs';
+import { Build, BuildResult, EvaluateResult } from '../schema/index.mjs';
 // ------------------------------------------------------------------
 // Validator<...>
 // ------------------------------------------------------------------
@@ -13,27 +12,24 @@ export class Validator extends Base {
     constructor(...args) {
         super();
         const matched = Arguments.Match(args, {
-            6: (context, type, isEvalulated, hasCodec, code, check) => [context, type, isEvalulated, hasCodec, code, check],
+            3: (hasCodec, buildResult, evaluateResult) => [hasCodec, buildResult, evaluateResult],
             2: (context, type) => [context, type]
         });
-        if (matched.length === 6) {
-            const [context, type, isEvaluated, hasCodec, code, check] = matched;
-            this.context = context;
-            this.type = type;
-            this.isAccelerated = isEvaluated;
+        // Note: The Base type requires this Validator to be Clone, but where we cannot safely clone
+        // the BuildResult or the EvaluateResult. For now we pass the Validator constructor a shared 
+        // reference of BuildResult and EvaluateResult to mitigate re-compile on Clone. We must remove 
+        // this overload when Base is removed (memory-gc-ref)
+        if (matched.length === 3 && matched[1] instanceof BuildResult && matched[2] instanceof EvaluateResult) {
+            const [hasCodec, buildResult, evaluateResult] = matched;
             this.hasCodec = hasCodec;
-            this.code = code;
-            this.check = check;
+            this.buildResult = buildResult;
+            this.evaluateResult = evaluateResult;
         }
         else {
             const [context, type] = matched;
-            const result = Build(context, type).Evaluate();
             this.hasCodec = HasCodec(context, type);
-            this.context = context;
-            this.type = type;
-            this.isAccelerated = result.IsAccelerated;
-            this.code = result.Code;
-            this.check = result.Check;
+            this.buildResult = Build(context, type);
+            this.evaluateResult = this.buildResult.Evaluate();
         }
     }
     // ----------------------------------------------------------------
@@ -41,76 +37,85 @@ export class Validator extends Base {
     // ----------------------------------------------------------------
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
-        return this.isAccelerated;
+        return this.evaluateResult.IsAccelerated();
     }
     // ----------------------------------------------------------------
-    // Context | Type
+    // Context & Type
     // ----------------------------------------------------------------
     /** Returns the Context for this validator. */
     Context() {
-        return this.context;
+        return this.buildResult.Context();
     }
     /** Returns the underlying Type used to construct this Validator. */
     Type() {
-        return this.type;
+        return this.buildResult.Schema();
     }
     // ----------------------------------------------------------------
     // Code
     // ----------------------------------------------------------------
     /** Returns the generated code for this validator. */
     Code() {
-        return this.code;
+        return this.evaluateResult.Code();
     }
     // ----------------------------------------------------------------
-    // Base<...>
+    // Standard Validator
     // ----------------------------------------------------------------
     /** Performs a type-guard check on the provided value. */
     Check(value) {
-        return this.check(value);
+        return this.evaluateResult.Check(value);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        const checked = this.Check(value);
+        if (checked)
+            return value;
+        if (Settings.Get().correctiveParse)
+            return Parser(this.Context(), this.Type(), value);
+        throw new ParseError(value, this.Errors(value));
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        if (Environment.CanEvaluate() && this.check(value))
+        if (this.IsAccelerated() && this.Check(value))
             return [];
-        return Errors(this.context, this.type, value);
+        return Errors(this.Context(), this.Type(), value);
     }
+    // ----------------------------------------------------------------
+    // Value.* Operations
+    // ----------------------------------------------------------------
     /** Cleans a value using the Validator type. */
     Clean(value) {
-        return Clean(this.context, this.type, value);
+        return Clean(this.Context(), this.Type(), value);
     }
     /** Converts a value using the Validator type. */
     Convert(value) {
-        return Convert(this.context, this.type, value);
+        return Convert(this.Context(), this.Type(), value);
     }
     /** Creates a value using the Validator type. */
     Create() {
-        return Create(this.context, this.type);
+        return Create(this.Context(), this.Type());
     }
     /** Creates defaults using the Validator type. */
     Default(value) {
-        return Default(this.context, this.type, value);
-    }
-    /** Clones this validator. */
-    Clone() {
-        return new Validator(this.context, this.type, this.isAccelerated, this.hasCodec, this.code, this.check);
-    }
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value) {
-        const checked = this.Check(value);
-        if (checked)
-            return value;
-        if (Settings.Get().correctiveParse)
-            return Parser(this.context, this.type, value);
-        throw new ParseError(value, this.Errors(value));
+        return Default(this.Context(), this.Type(), value);
     }
     /** Decodes a value */
     Decode(value) {
-        const result = this.hasCodec ? Decode(this.context, this.type, value) : this.Parse(value);
+        const result = this.hasCodec ? Decode(this.Context(), this.Type(), value) : this.Parse(value);
         return result;
     }
     /** Encodes a value */
     Encode(value) {
-        const result = this.hasCodec ? Encode(this.context, this.type, value) : this.Parse(value);
+        const result = this.hasCodec ? Encode(this.Context(), this.Type(), value) : this.Parse(value);
         return result;
     }
+    // ----------------------------------------------------------------
+    // Deprecations
+    // ----------------------------------------------------------------
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone() {
+        return new Validator(this.hasCodec, this.buildResult, this.evaluateResult);
+    }
 }

package/build/guard/guard.d.mts

@@ -49,6 +49,8 @@ export declare function Every<T>(value: T[], offset: number, callback: (value: T
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Takes the left-most element from an array and dispatches to the true arm, or the false arm if empty */
 export declare function TakeLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export declare function IsUnsafePropertyKey(key: PropertyKey): boolean;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
     [_ in Key]: unknown;
@@ -57,7 +59,7 @@ export declare function HasPropertyKey<Key extends PropertyKey>(value: object, k
 export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
 /** Returns object entries as `[string, Value][]` */
 export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
 export declare function Keys(value: Record<PropertyKey, unknown>): string[];
 /** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
 export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];

package/build/guard/guard.mjs

@@ -169,10 +169,13 @@ export function TakeLeft(array, true_, false_) {
 // --------------------------------------------------------------------------
 // Object
 // --------------------------------------------------------------------------
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export function IsUnsafePropertyKey(key) {
+    return IsEqual(key, '__proto__') || IsEqual(key, 'constructor') || IsEqual(key, 'prototype');
+}
 /** Returns true if this value has this property key */
 export function HasPropertyKey(value, key) {
-    const isProtoField = IsEqual(key, '__proto__') || IsEqual(key, 'constructor');
-    return isProtoField ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
+    return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
 }
 /** Returns object entries as `[RegExp, Value][]` */
 export function EntriesRegExp(value) {
@@ -182,7 +185,7 @@ export function EntriesRegExp(value) {
 export function Entries(value) {
     return Object.entries(value);
 }
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
 export function Keys(value) {
     return Object.getOwnPropertyNames(value);
 }

package/build/schema/build.d.mts

@@ -1,19 +1,23 @@
 import * as Engine from './engine/index.mjs';
 import * as Schema from './types/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
-export interface EvaluateResult {
-    IsAccelerated: boolean;
-    Code: string;
-    Check: CheckFunction;
+export declare class EvaluateResult {
+    private readonly isAccelerated;
+    private readonly code;
+    private readonly check;
+    constructor(isAccelerated: boolean, code: string, check: CheckFunction);
+    IsAccelerated(): boolean;
+    Code(): string;
+    Check(value: unknown): boolean;
 }
 export declare class BuildResult {
     private readonly context;
     private readonly schema;
     private readonly external;
     private readonly functions;
-    private readonly call;
+    private readonly entry;
     private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
+    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], entry: string, useUnevaluated: boolean);
     /** Returns the Context used for this build */
     Context(): Record<PropertyKey, Schema.XSchema>;
     /** Returns the Schema used for this build */
@@ -25,7 +29,7 @@ export declare class BuildResult {
     /** Returns check functions */
     Functions(): string[];
     /** Return entry function call. */
-    Call(): string;
+    Entry(): string;
     /** Evaluates the build into a validation function */
     Evaluate(): EvaluateResult;
 }

package/build/schema/build.mjs

@@ -12,8 +12,8 @@ import * as Engine from './engine/index.mjs';
 function CreateCode(build) {
     const functions = build.Functions().join(';\n');
     const statements = build.UseUnevaluated()
-        ? ['const context = new CheckContext({}, {})', `return ${build.Call()}`]
-        : [`return ${build.Call()}`];
+        ? ['const context = new CheckContext({}, {})', `return ${build.Entry()}`]
+        : [`return ${build.Entry()}`];
     return `${functions}; return (value) => { ${statements.join('; ')} }`;
 }
 // ------------------------------------------------------------------
@@ -40,15 +40,34 @@ function CreateCheck(build, code) {
         : CreateDynamicCheck(build);
 }
 // ------------------------------------------------------------------
+// EvaluateResult
+// ------------------------------------------------------------------
+export class EvaluateResult {
+    constructor(isAccelerated, code, check) {
+        this.isAccelerated = isAccelerated;
+        this.code = code;
+        this.check = check;
+    }
+    IsAccelerated() {
+        return this.isAccelerated;
+    }
+    Code() {
+        return this.code;
+    }
+    Check(value) {
+        return this.check(value);
+    }
+}
+// ------------------------------------------------------------------
 // BuildResult
 // ------------------------------------------------------------------
 export class BuildResult {
-    constructor(context, schema, external, functions, call, useUnevaluated) {
+    constructor(context, schema, external, functions, entry, useUnevaluated) {
         this.context = context;
         this.schema = schema;
         this.external = external;
         this.functions = functions;
-        this.call = call;
+        this.entry = entry;
         this.useUnevaluated = useUnevaluated;
     }
     /** Returns the Context used for this build */
@@ -72,14 +91,14 @@ export class BuildResult {
         return this.functions;
     }
     /** Return entry function call. */
-    Call() {
-        return this.call;
+    Entry() {
+        return this.entry;
     }
     /** Evaluates the build into a validation function */
     Evaluate() {
-        const Code = CreateCode(this);
-        const Check = CreateCheck(this, Code);
-        return { IsAccelerated: Environment.CanEvaluate(), Code, Check };
+        const code = CreateCode(this);
+        const check = CreateCheck(this, code);
+        return new EvaluateResult(Environment.CanEvaluate(), code, check);
     }
 }
 /** Builds a schema into a optimized runtime validator */

package/build/schema/compile.d.mts

@@ -2,8 +2,8 @@ import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
 export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
-    private readonly build;
-    private readonly result;
+    private readonly buildResult;
+    private readonly evaluateResult;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;

package/build/schema/compile.mjs

@@ -9,31 +9,31 @@ import { ParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.build = Build.Build(context, schema);
-        this.result = this.build.Evaluate();
+        this.buildResult = Build.Build(context, schema);
+        this.evaluateResult = this.buildResult.Evaluate();
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
-        return this.result.IsAccelerated;
+        return this.evaluateResult.IsAccelerated();
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.build.Schema();
+        return this.buildResult.Schema();
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
-        return this.result.Check(value);
+        return this.evaluateResult.Check(value);
     }
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value) {
-        if (this.result.Check(value))
+        if (this.evaluateResult.Check(value))
             return value;
-        const [_result, errors] = Errors(this.build.Context(), this.build.Schema(), value);
-        throw new ParseError(this.build.Schema(), value, errors);
+        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        throw new ParseError(this.buildResult.Schema(), value, errors);
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        return Errors(this.build.Context(), this.build.Schema(), value);
+        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
     }
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/engine/additionalProperties.mjs

@@ -104,7 +104,7 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
     return isAdditionalProperties || context.AddError({
         keyword: 'additionalProperties',
         schemaPath,
-        instancePath: instancePath,
+        instancePath,
         params: { additionalProperties },
     });
 }

package/build/schema/pointer/pointer.mjs

@@ -11,6 +11,14 @@ function AssertCanSet(value) {
     if (!Guard.IsObject(value))
         throw Error('Cannot set value');
 }
+function AssertIndex(index) {
+    if (Guard.IsUnsafePropertyKey(index))
+        throw Error('Pointer contains unsafe property key');
+}
+function AssertIndices(indices) {
+    for (const index of indices)
+        AssertIndex(index);
+}
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
@@ -27,7 +35,7 @@ function HasIndex(index, value) {
     return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
 }
 function GetIndex(index, value) {
-    return Guard.IsObject(value) ? value[index] : undefined;
+    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
 }
 function GetIndices(indices, value) {
     return indices.reduce((value, index) => GetIndex(index, value), value);
@@ -70,6 +78,7 @@ export function Get(value, pointer) {
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
     AssertNotRoot(indices);
+    AssertIndices(indices);
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);
@@ -83,6 +92,7 @@ export function Set(value, pointer, next) {
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
     AssertNotRoot(indices);
+    AssertIndices(indices);
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);

package/build/value/clone/clone.mjs

@@ -18,15 +18,16 @@ function FromClassInstance(value) {
 // ------------------------------------------------------------------
 function FromObjectInstance(value) {
     const result = {};
-    for (const key of Object.getOwnPropertyNames(value)) {
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         result[key] = Clone(value[key]);
     }
-    for (const key of Object.getOwnPropertySymbols(value)) {
+    for (const key of Guard.Symbols(value)) {
         result[key] = Clone(value[key]);
     }
     return result;
 }
-Object.create({});
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------

package/build/value/delta/diff.mjs

@@ -37,6 +37,8 @@ function* FromObject(path, left, right) {
     for (const key of rightKeys) {
         if (Guard.HasPropertyKey(left, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         yield CreateInsert(`${path}/${key}`, right[key]);
     }
     // ----------------------------------------------------------------
@@ -45,6 +47,8 @@ function* FromObject(path, left, right) {
     for (const key of leftKeys) {
         if (!Guard.HasPropertyKey(right, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         if (Equal(left, right))
             continue;
         yield* FromValue(`${path}/${key}`, left[key], right[key]);
@@ -55,6 +59,8 @@ function* FromObject(path, left, right) {
     for (const key of leftKeys) {
         if (Guard.HasPropertyKey(right, key))
             continue;
+        if (Guard.IsUnsafePropertyKey(key))
+            continue;
         yield CreateDelete(`${path}/${key}`);
     }
 }

package/build/value/mutate/from_object.mjs

@@ -3,6 +3,16 @@ import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { FromValue } from './from_value.mjs';
+// ------------------------------------------------------------------
+// AssertKey
+// ------------------------------------------------------------------
+function AssertKey(key) {
+    if (Guard.IsUnsafePropertyKey(key))
+        throw Error('Attempted to Mutate with unsafe property key');
+}
+// ------------------------------------------------------------------
+// AssertKey
+// ------------------------------------------------------------------
 export function FromObject(root, path, current, next) {
     if (!Guard.IsObjectNotArray(current)) {
         Pointer.Set(root, path, Clone(next));
@@ -11,16 +21,19 @@ export function FromObject(root, path, current, next) {
         const currentKeys = Guard.Keys(current);
         const nextKeys = Guard.Keys(next);
         for (const currentKey of currentKeys) {
+            AssertKey(currentKey);
             if (!nextKeys.includes(currentKey)) {
                 delete current[currentKey];
             }
         }
         for (const nextKey of nextKeys) {
+            AssertKey(nextKey);
             if (!currentKeys.includes(nextKey)) {
                 current[nextKey] = next[nextKey];
             }
         }
         for (const nextKey of nextKeys) {
+            AssertKey(nextKey);
             FromValue(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
         }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.36",
+  "version": "1.1.38",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -52,7 +52,7 @@ type T = Type.Static<typeof T>              // type T = {
 
 TypeBox is a runtime type system that creates in-memory JSON Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type system that can be statically checked by TypeScript and validated at runtime using standard JSON Schema.
 
-This library is designed to allow JSON Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST, RPC and MCP services to help validate data received over the wire.
+This library is designed to allow JSON Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License: MIT
 
@@ -281,29 +281,29 @@ The following table shows compile performance for various JSON Schema structures
 ┌──────────────────────┬─────────────┬─────────────┐
 │ Compile              │ TB1X        │ AJV8        │
 ├──────────────────────┼─────────────┼─────────────┤
-│ Boolean              │ 28.4K ops/s │    7K ops/s │
-│ Number               │ 21.8K ops/s │  7.7K ops/s │
-│ String               │ 47.8K ops/s │  7.3K ops/s │
-│ Null                 │ 35.6K ops/s │  7.8K ops/s │
-│ Literal_String       │ 28.6K ops/s │  6.3K ops/s │
-│ Literal_Number       │ 46.6K ops/s │  6.2K ops/s │
-│ Literal_Boolean      │ 40.8K ops/s │  6.6K ops/s │
-│ Pattern              │ 29.7K ops/s │  4.9K ops/s │
-│ Object_Open          │  6.8K ops/s │  1.1K ops/s │
-│ Object_Close         │  7.4K ops/s │   833 ops/s │
-│ Object_Vector3       │ 19.4K ops/s │  2.1K ops/s │
-│ Object_Basis3        │    6K ops/s │   895 ops/s │
-│ Intersect_And        │   12K ops/s │  3.5K ops/s │
-│ Intersect_Structural │  8.4K ops/s │  1.1K ops/s │
-│ Union_Or             │ 18.2K ops/s │  2.5K ops/s │
-│ Union_Structural     │ 10.9K ops/s │  1.3K ops/s │
-│ Tuple_Values         │  7.3K ops/s │  1.6K ops/s │
-│ Tuple_Objects        │  1.9K ops/s │   339 ops/s │
-│ Array_Numbers_4      │ 29.9K ops/s │  3.4K ops/s │
-│ Array_Numbers_8      │ 20.3K ops/s │  3.4K ops/s │
-│ Array_Numbers_16     │ 29.4K ops/s │  3.3K ops/s │
-│ Array_Objects_Open   │  6.3K ops/s │   684 ops/s │
-│ Array_Objects_Close  │  7.3K ops/s │   762 ops/s │
+│ Boolean              │ 29.2K ops/s │  7.1K ops/s │
+│ Number               │ 34.5K ops/s │  7.6K ops/s │
+│ String               │ 48.9K ops/s │  8.7K ops/s │
+│ Null                 │ 39.6K ops/s │  7.6K ops/s │
+│ Literal_String       │ 46.8K ops/s │  6.8K ops/s │
+│ Literal_Number       │ 48.3K ops/s │  7.4K ops/s │
+│ Literal_Boolean      │ 48.8K ops/s │  7.3K ops/s │
+│ Pattern              │ 32.5K ops/s │  6.1K ops/s │
+│ Object_Open          │  6.6K ops/s │  1.4K ops/s │
+│ Object_Close         │  7.6K ops/s │    1K ops/s │
+│ Object_Vector3       │ 20.8K ops/s │  2.8K ops/s │
+│ Object_Basis3        │  7.5K ops/s │    1K ops/s │
+│ Intersect_And        │   23K ops/s │  3.9K ops/s │
+│ Intersect_Structural │  8.7K ops/s │  1.2K ops/s │
+│ Union_Or             │ 17.9K ops/s │  3.4K ops/s │
+│ Union_Structural     │ 11.3K ops/s │  2.1K ops/s │
+│ Tuple_Values         │  9.6K ops/s │  2.1K ops/s │
+│ Tuple_Objects        │  2.1K ops/s │   350 ops/s │
+│ Array_Numbers_4      │ 33.6K ops/s │  4.2K ops/s │
+│ Array_Numbers_8      │   39K ops/s │  3.7K ops/s │
+│ Array_Numbers_16     │ 29.6K ops/s │  3.8K ops/s │
+│ Array_Objects_Open   │  7.7K ops/s │   833 ops/s │
+│ Array_Objects_Close  │  7.6K ops/s │   860 ops/s │
 └──────────────────────┴─────────────┴─────────────┘
 ```
 
@@ -314,29 +314,29 @@ The following tables shows validation performance for various JSON Schema struct
 ┌──────────────────────┬──────────────┬──────────────┐
 │ Validate             │ TB1X         │ AJV8         │
 ├──────────────────────┼──────────────┼──────────────┤
-│ Boolean              │ 164.1M ops/s │ 181.5M ops/s │
-│ Number               │   107M ops/s │  50.2M ops/s │
-│ String               │ 102.2M ops/s │  61.9M ops/s │
-│ Null                 │ 112.1M ops/s │  48.2M ops/s │
-│ Literal_String       │ 102.8M ops/s │  61.5M ops/s │
-│ Literal_Number       │ 109.1M ops/s │  46.4M ops/s │
-│ Literal_Boolean      │ 109.6M ops/s │  63.3M ops/s │
-│ Pattern              │  24.7M ops/s │  20.3M ops/s │
-│ Object_Open          │  75.4M ops/s │  37.3M ops/s │
-│ Object_Close         │  35.9M ops/s │  21.9M ops/s │
-│ Object_Vector3       │  77.6M ops/s │  47.4M ops/s │
-│ Object_Basis3        │    37M ops/s │  24.3M ops/s │
-│ Intersect_And        │  93.3M ops/s │  61.1M ops/s │
-│ Intersect_Structural │    83M ops/s │  36.4M ops/s │
-│ Union_Or             │  99.7M ops/s │   8.6M ops/s │
-│ Union_Structural     │  81.3M ops/s │  43.5M ops/s │
-│ Tuple_Values         │  72.4M ops/s │  41.7M ops/s │
-│ Tuple_Objects        │  32.6M ops/s │  22.4M ops/s │
-│ Array_Numbers_4      │  94.1M ops/s │  42.8M ops/s │
-│ Array_Numbers_8      │  90.6M ops/s │  42.3M ops/s │
-│ Array_Numbers_16     │  77.5M ops/s │  40.2M ops/s │
-│ Array_Objects_Open   │  26.3M ops/s │  19.6M ops/s │
-│ Array_Objects_Close  │   9.1M ops/s │    10M ops/s │
+│ Boolean              │ 192.2M ops/s │ 189.5M ops/s │
+│ Number               │ 112.4M ops/s │    61M ops/s │
+│ String               │ 113.7M ops/s │  64.1M ops/s │
+│ Null                 │ 112.8M ops/s │  64.9M ops/s │
+│ Literal_String       │   108M ops/s │  62.9M ops/s │
+│ Literal_Number       │ 113.5M ops/s │  63.2M ops/s │
+│ Literal_Boolean      │ 109.2M ops/s │  64.1M ops/s │
+│ Pattern              │  26.5M ops/s │  22.4M ops/s │
+│ Object_Open          │    78M ops/s │  47.2M ops/s │
+│ Object_Close         │  38.6M ops/s │  27.6M ops/s │
+│ Object_Vector3       │    91M ops/s │  51.3M ops/s │
+│ Object_Basis3        │  41.1M ops/s │  27.4M ops/s │
+│ Intersect_And        │ 107.6M ops/s │  59.9M ops/s │
+│ Intersect_Structural │  83.6M ops/s │  46.3M ops/s │
+│ Union_Or             │    95M ops/s │   7.9M ops/s │
+│ Union_Structural     │  84.5M ops/s │  52.3M ops/s │
+│ Tuple_Values         │  74.7M ops/s │    53M ops/s │
+│ Tuple_Objects        │  32.9M ops/s │  22.3M ops/s │
+│ Array_Numbers_4      │  93.3M ops/s │  55.1M ops/s │
+│ Array_Numbers_8      │  90.3M ops/s │  50.8M ops/s │
+│ Array_Numbers_16     │  76.8M ops/s │  39.6M ops/s │
+│ Array_Objects_Open   │  28.7M ops/s │  20.4M ops/s │
+│ Array_Objects_Close  │  10.3M ops/s │  10.8M ops/s │
 └──────────────────────┴──────────────┴──────────────┘
 ```