@sinclair/typebox 0.28.14 → 0.28.16

package/compiler/compiler.js

@@ -199,14 +199,15 @@ var TypeCompiler;
         yield 'true';
     }
     function* Array(schema, references, value) {
-        const expression = CreateExpression(schema.items, references, 'value');
+        yield `Array.isArray(${value})`;
         if (IsNumber(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         if (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 })())`;
-        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
+        const expression = CreateExpression(schema.items, references, 'value');
+        yield `${value}.every(value => ${expression})`;
     }
     function* BigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
@@ -358,9 +359,9 @@ var TypeCompiler;
         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. Consider for refactor.
+        // 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_local_function_names.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
@@ -392,7 +393,7 @@ var TypeCompiler;
         yield `${func}(${value})`;
     }
     function* Tuple(schema, references, value) {
-        yield `(Array.isArray(${value}))`;
+        yield `Array.isArray(${value})`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
         yield `(${value}.length === ${schema.maxItems})`;
@@ -426,19 +427,25 @@ var TypeCompiler;
         state_remote_custom_types.set(schema_key, schema);
         yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
     }
-    function* Visit(schema, references, value) {
+    function* Visit(schema, references, value, root = false) {
         const references_ = IsString(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
-        // Reference: Referenced schemas can originate from either additional schemas
-        // or inline in the schema itself. Ideally the recursive path should align to
-        // reference path. Consider for refactor.
-        if (IsString(schema.$id) && !state_local_function_names.has(schema.$id)) {
-            state_local_function_names.add(schema.$id);
+        // 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);
-            const body = CreateFunction(name, schema, references, 'value');
-            PushFunction(body);
-            yield `${name}(${value})`;
-            return;
+            if (!state_local_function_names.has(schema.$id)) {
+                state_local_function_names.add(schema.$id);
+                const body = CreateFunction(name, schema, references, 'value');
+                PushFunction(body);
+            }
+            if (!root)
+                return yield `${name}(${value})`;
         }
         switch (schema_[Types.Kind]) {
             case 'Any':
@@ -521,7 +528,7 @@ var TypeCompiler;
         return `check_${Identifier.Encode($id)}`;
     }
     function CreateFunction(name, schema, references, value) {
-        const expression = [...Visit(schema, references, value)].map((condition) => `    ${condition}`).join(' &&\n');
+        const expression = [...Visit(schema, references, value, true)].map((condition) => `    ${condition}`).join(' &&\n');
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
     function PushFunction(functionBody) {
@@ -540,9 +547,12 @@ var TypeCompiler;
     // -------------------------------------------------------------------
     function Build(schema, references) {
         ResetCompiler();
-        const check = CreateFunction('check', schema, references, 'value');
+        const check = CreateFunction('check', schema, references, 'value'); // interior visit
         const locals = GetLocals();
-        return `${locals.join('\n')}\nreturn ${check}`;
+        // prettier-ignore
+        return IsString(schema.$id) // ensure top level schemas with $id's are hoisted
+            ? `${locals.join('\n')}\nreturn function check(value) {\n  return ${CreateFunctionName(schema.$id)}(value)\n}`
+            : `${locals.join('\n')}\nreturn ${check}`;
     }
     /** Returns the generated assertion code used to validate this type. */
     function Code(schema, references = []) {
@@ -576,4 +586,4 @@ var TypeCompiler;
         return new TypeCheck(schema, references, checkFunction, code);
     }
     TypeCompiler.Compile = Compile;
-})(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));
+})(TypeCompiler || (exports.TypeCompiler = TypeCompiler = {}));

package/errors/errors.js

@@ -95,7 +95,7 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 56] = "Uint8ArrayMaxByteLength";
     ValueErrorType[ValueErrorType["Void"] = 57] = "Void";
     ValueErrorType[ValueErrorType["Custom"] = 58] = "Custom";
-})(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
+})(ValueErrorType || (exports.ValueErrorType = ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrorIterator
 // -------------------------------------------------------------------
@@ -609,4 +609,4 @@ var ValueErrors;
         return new ValueErrorIterator(iterator);
     }
     ValueErrors.Errors = Errors;
-})(ValueErrors = exports.ValueErrors || (exports.ValueErrors = {}));
+})(ValueErrors || (exports.ValueErrors = ValueErrors = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.14",
+  "version": "0.28.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -42,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.1.3"
   }
 }

package/readme.md

@@ -483,7 +483,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ ])                             │                             │   ],                           │
 │ const T = Type.Tuple([         │                             │   additionalItems: false,      │
 |   ...Type.Rest(A),             │                             │   minItems: 4,                 │
-|   ...Type.Test(B)              │                             │   maxItems: 4                  │
+|   ...Type.Rest(B)              │                             │   maxItems: 4                  │
 │ ])                             │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -870,7 +870,7 @@ const T = Type.Object({                              // const T = {
   z: Type.Boolean()                                  //   properties: {
 })                                                   //     x: { type: 'number' },
                                                      //     y: { type: 'string' },
-                                                     //     z: { type: 'string' },
+                                                     //     z: { type: 'string' }
                                                      //   }
                                                      // }
 
@@ -896,7 +896,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Rest Types
 
-Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination as well as for variadic functions.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well as for variadic functions.
 
 ```typescript
 // TypeScript
@@ -908,14 +908,14 @@ type C = [...T, number]                              // type C = [number, number
 type F = (...param: C) => void                       // type F = (
                                                      //   param0: number,
                                                      //   param1: number,
-                                                     //   param2: number,
+                                                     //   param2: number
                                                      // ) => void
 
 // TypeBox
 
 const T = Type.Tuple([                               // const T: TTuple<[
   Type.Number(),                                     //   TNumber,
-  Type.Number()                                      //   TNumber,
+  Type.Number()                                      //   TNumber
 ])                                                   // ]>
 
 const C = Type.Tuple([                               // const C: TTuple<[
@@ -1335,7 +1335,7 @@ console.log(C.Code())                                // return function check(va
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion polices. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
+The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion policies. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
 
 The TypeSystem module is provided as an optional import.
 
@@ -1462,35 +1462,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    230 ms' │ '      7 ms' │ '   32.86 x' │
-│ Literal_Number             │    1000    │ '    171 ms' │ '      4 ms' │ '   42.75 x' │
-│ Literal_Boolean            │    1000    │ '    148 ms' │ '      4 ms' │ '   37.00 x' │
-│ Primitive_Number           │    1000    │ '    160 ms' │ '      6 ms' │ '   26.67 x' │
-│ Primitive_String           │    1000    │ '    149 ms' │ '      6 ms' │ '   24.83 x' │
-│ Primitive_String_Pattern   │    1000    │ '    199 ms' │ '      9 ms' │ '   22.11 x' │
-│ Primitive_Boolean          │    1000    │ '    126 ms' │ '      3 ms' │ '   42.00 x' │
-│ Primitive_Null             │    1000    │ '    141 ms' │ '      4 ms' │ '   35.25 x' │
-│ Object_Unconstrained       │    1000    │ '   1105 ms' │ '     27 ms' │ '   40.93 x' │
-│ Object_Constrained         │    1000    │ '   1178 ms' │ '     22 ms' │ '   53.55 x' │
-│ Object_Vector3             │    1000    │ '    368 ms' │ '      8 ms' │ '   46.00 x' │
-│ Object_Box3D               │    1000    │ '   1668 ms' │ '     28 ms' │ '   59.57 x' │
-│ Tuple_Primitive            │    1000    │ '    446 ms' │ '     12 ms' │ '   37.17 x' │
-│ Tuple_Object               │    1000    │ '   1146 ms' │ '     15 ms' │ '   76.40 x' │
-│ Composite_Intersect        │    1000    │ '    661 ms' │ '     18 ms' │ '   36.72 x' │
-│ Composite_Union            │    1000    │ '    513 ms' │ '     17 ms' │ '   30.18 x' │
-│ Math_Vector4               │    1000    │ '    767 ms' │ '     10 ms' │ '   76.70 x' │
-│ Math_Matrix4               │    1000    │ '    396 ms' │ '     10 ms' │ '   39.60 x' │
-│ Array_Primitive_Number     │    1000    │ '    353 ms' │ '      8 ms' │ '   44.13 x' │
-│ Array_Primitive_String     │    1000    │ '    358 ms' │ '      5 ms' │ '   71.60 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    265 ms' │ '      3 ms' │ '   88.33 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1476 ms' │ '     19 ms' │ '   77.68 x' │
-│ Array_Object_Constrained   │    1000    │ '   1698 ms' │ '     20 ms' │ '   84.90 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    654 ms' │ '      9 ms' │ '   72.67 x' │
-│ Array_Tuple_Object         │    1000    │ '   1492 ms' │ '     15 ms' │ '   99.47 x' │
-│ Array_Composite_Intersect  │    1000    │ '   1045 ms' │ '     16 ms' │ '   65.31 x' │
-│ Array_Composite_Union      │    1000    │ '    702 ms' │ '     14 ms' │ '   50.14 x' │
-│ Array_Math_Vector4         │    1000    │ '   1016 ms' │ '     12 ms' │ '   84.67 x' │
-│ Array_Math_Matrix4         │    1000    │ '    621 ms' │ '      5 ms' │ '  124.20 x' │
+│ Literal_String             │    1000    │ '    220 ms' │ '      6 ms' │ '   36.67 x' │
+│ Literal_Number             │    1000    │ '    172 ms' │ '      4 ms' │ '   43.00 x' │
+│ Literal_Boolean            │    1000    │ '    162 ms' │ '      4 ms' │ '   40.50 x' │
+│ Primitive_Number           │    1000    │ '    161 ms' │ '      6 ms' │ '   26.83 x' │
+│ Primitive_String           │    1000    │ '    154 ms' │ '      4 ms' │ '   38.50 x' │
+│ Primitive_String_Pattern   │    1000    │ '    204 ms' │ '     10 ms' │ '   20.40 x' │
+│ Primitive_Boolean          │    1000    │ '    131 ms' │ '      4 ms' │ '   32.75 x' │
+│ Primitive_Null             │    1000    │ '    142 ms' │ '      5 ms' │ '   28.40 x' │
+│ Object_Unconstrained       │    1000    │ '   1263 ms' │ '     29 ms' │ '   43.55 x' │
+│ Object_Constrained         │    1000    │ '   1267 ms' │ '     24 ms' │ '   52.79 x' │
+│ Object_Vector3             │    1000    │ '    382 ms' │ '      7 ms' │ '   54.57 x' │
+│ Object_Box3D               │    1000    │ '   1723 ms' │ '     28 ms' │ '   61.54 x' │
+│ Tuple_Primitive            │    1000    │ '    495 ms' │ '     13 ms' │ '   38.08 x' │
+│ Tuple_Object               │    1000    │ '   1271 ms' │ '     16 ms' │ '   79.44 x' │
+│ Composite_Intersect        │    1000    │ '    656 ms' │ '     19 ms' │ '   34.53 x' │
+│ Composite_Union            │    1000    │ '    529 ms' │ '     18 ms' │ '   29.39 x' │
+│ Math_Vector4               │    1000    │ '    802 ms' │ '     14 ms' │ '   57.29 x' │
+│ Math_Matrix4               │    1000    │ '    411 ms' │ '      6 ms' │ '   68.50 x' │
+│ Array_Primitive_Number     │    1000    │ '    369 ms' │ '      6 ms' │ '   61.50 x' │
+│ Array_Primitive_String     │    1000    │ '    369 ms' │ '      4 ms' │ '   92.25 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    297 ms' │ '      3 ms' │ '   99.00 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1582 ms' │ '     20 ms' │ '   79.10 x' │
+│ Array_Object_Constrained   │    1000    │ '   1629 ms' │ '     19 ms' │ '   85.74 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    652 ms' │ '     12 ms' │ '   54.33 x' │
+│ Array_Tuple_Object         │    1000    │ '   1587 ms' │ '     16 ms' │ '   99.19 x' │
+│ Array_Composite_Intersect  │    1000    │ '   1051 ms' │ '     15 ms' │ '   70.07 x' │
+│ Array_Composite_Union      │    1000    │ '    733 ms' │ '     15 ms' │ '   48.87 x' │
+│ Array_Math_Vector4         │    1000    │ '   1071 ms' │ '     12 ms' │ '   89.25 x' │
+│ Array_Math_Matrix4         │    1000    │ '    636 ms' │ '      5 ms' │ '  127.20 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1504,37 +1504,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     22 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Literal_Boolean            │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Number           │  1000000   │ '     23 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_String           │  1000000   │ '     23 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    171 ms' │ '     42 ms' │ '     36 ms' │ '    1.17 x' │
-│ Primitive_Boolean          │  1000000   │ '     20 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_Null             │  1000000   │ '     21 ms' │ '     16 ms' │ '      8 ms' │ '    2.00 x' │
-│ Object_Unconstrained       │  1000000   │ '   1099 ms' │ '     31 ms' │ '     25 ms' │ '    1.24 x' │
-│ Object_Constrained         │  1000000   │ '   1224 ms' │ '     51 ms' │ '     36 ms' │ '    1.42 x' │
-│ Object_Vector3             │  1000000   │ '    420 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Object_Box3D               │  1000000   │ '   2012 ms' │ '     53 ms' │ '     43 ms' │ '    1.23 x' │
-│ Object_Recursive           │  1000000   │ '   5080 ms' │ '    320 ms' │ '    150 ms' │ '    2.13 x' │
-│ Tuple_Primitive            │  1000000   │ '    154 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Tuple_Object               │  1000000   │ '    749 ms' │ '     27 ms' │ '     18 ms' │ '    1.50 x' │
-│ Composite_Intersect        │  1000000   │ '    775 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│ Composite_Union            │  1000000   │ '    533 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Math_Vector4               │  1000000   │ '    275 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│ Math_Matrix4               │  1000000   │ '   1136 ms' │ '     37 ms' │ '     26 ms' │ '    1.42 x' │
-│ Array_Primitive_Number     │  1000000   │ '    316 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_String     │  1000000   │ '    239 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    151 ms' │ '     20 ms' │ '     15 ms' │ '    1.33 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5809 ms' │ '     64 ms' │ '     56 ms' │ '    1.14 x' │
-│ Array_Object_Constrained   │  1000000   │ '   6210 ms' │ '    123 ms' │ '    101 ms' │ '    1.22 x' │
-│ Array_Object_Recursive     │  1000000   │ '  21779 ms' │ '   1466 ms' │ '    548 ms' │ '    2.68 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    730 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3259 ms' │ '     63 ms' │ '     49 ms' │ '    1.29 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3276 ms' │ '     44 ms' │ '     34 ms' │ '    1.29 x' │
-│ Array_Composite_Union      │  1000000   │ '   2279 ms' │ '     64 ms' │ '     31 ms' │ '    2.06 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1139 ms' │ '     36 ms' │ '     23 ms' │ '    1.57 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4924 ms' │ '    110 ms' │ '     92 ms' │ '    1.20 x' │
+│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
+│ Literal_Number             │  1000000   │ '     21 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Literal_Boolean            │  1000000   │ '     18 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_Number           │  1000000   │ '     25 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_String           │  1000000   │ '     25 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    174 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
+│ Primitive_Boolean          │  1000000   │ '     22 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_Null             │  1000000   │ '     22 ms' │ '     16 ms' │ '      9 ms' │ '    1.78 x' │
+│ Object_Unconstrained       │  1000000   │ '   1065 ms' │ '     33 ms' │ '     25 ms' │ '    1.32 x' │
+│ Object_Constrained         │  1000000   │ '   1192 ms' │ '     53 ms' │ '     38 ms' │ '    1.39 x' │
+│ Object_Vector3             │  1000000   │ '    410 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Object_Box3D               │  1000000   │ '   1939 ms' │ '     54 ms' │ '     50 ms' │ '    1.08 x' │
+│ Object_Recursive           │  1000000   │ '   5248 ms' │ '    355 ms' │ '    149 ms' │ '    2.38 x' │
+│ Tuple_Primitive            │  1000000   │ '    163 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│ Tuple_Object               │  1000000   │ '    737 ms' │ '     29 ms' │ '     20 ms' │ '    1.45 x' │
+│ Composite_Intersect        │  1000000   │ '    761 ms' │ '     24 ms' │ '     15 ms' │ '    1.60 x' │
+│ Composite_Union            │  1000000   │ '    519 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
+│ Math_Vector4               │  1000000   │ '    247 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│ Math_Matrix4               │  1000000   │ '   1045 ms' │ '     39 ms' │ '     27 ms' │ '    1.44 x' │
+│ Array_Primitive_Number     │  1000000   │ '    256 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Array_Primitive_String     │  1000000   │ '    222 ms' │ '     21 ms' │ '     14 ms' │ '    1.50 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    149 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5473 ms' │ '     67 ms' │ '     59 ms' │ '    1.14 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5548 ms' │ '    130 ms' │ '    116 ms' │ '    1.12 x' │
+│ Array_Object_Recursive     │  1000000   │ '  21047 ms' │ '   1710 ms' │ '    584 ms' │ '    2.93 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    691 ms' │ '     35 ms' │ '     29 ms' │ '    1.21 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3075 ms' │ '     63 ms' │ '     50 ms' │ '    1.26 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3126 ms' │ '     44 ms' │ '     35 ms' │ '    1.26 x' │
+│ Array_Composite_Union      │  1000000   │ '   2086 ms' │ '     68 ms' │ '     33 ms' │ '    2.06 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1069 ms' │ '     38 ms' │ '     23 ms' │ '    1.65 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4559 ms' │ '    111 ms' │ '     88 ms' │ '    1.26 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1548,7 +1548,7 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '128.0 kb' │ ' 56.9 kb' │  '2.25 x'   │
+│ typebox/compiler     │ '128.0 kb' │ ' 57.0 kb' │  '2.25 x'   │
 │ typebox/errors       │ '111.6 kb' │ ' 49.1 kb' │  '2.27 x'   │
 │ typebox/system       │ ' 77.0 kb' │ ' 31.5 kb' │  '2.45 x'   │
 │ typebox/value        │ '177.7 kb' │ ' 76.8 kb' │  '2.31 x'   │

package/system/system.js

@@ -74,4 +74,4 @@ var TypeSystem;
         return format;
     }
     TypeSystem.Format = Format;
-})(TypeSystem = exports.TypeSystem || (exports.TypeSystem = {}));
+})(TypeSystem || (exports.TypeSystem = TypeSystem = {}));

package/typebox.js

@@ -72,7 +72,7 @@ var TypeRegistry;
         return map.get(kind);
     }
     TypeRegistry.Get = Get;
-})(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
+})(TypeRegistry || (exports.TypeRegistry = TypeRegistry = {}));
 /** A registry for user defined string formats */
 var FormatRegistry;
 (function (FormatRegistry) {
@@ -102,7 +102,7 @@ var FormatRegistry;
         return map.get(format);
     }
     FormatRegistry.Get = Get;
-})(FormatRegistry = exports.FormatRegistry || (exports.FormatRegistry = {}));
+})(FormatRegistry || (exports.FormatRegistry = FormatRegistry = {}));
 // --------------------------------------------------------------------------
 // TypeGuard
 // --------------------------------------------------------------------------
@@ -611,7 +611,7 @@ var TypeGuard;
                 (TKind(schema) && TypeRegistry.Has(schema[exports.Kind]))));
     }
     TypeGuard.TSchema = TSchema;
-})(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));
+})(TypeGuard || (exports.TypeGuard = TypeGuard = {}));
 // --------------------------------------------------------------------------
 // ExtendsUndefined
 // --------------------------------------------------------------------------
@@ -636,7 +636,7 @@ var ExtendsUndefined;
         return false;
     }
     ExtendsUndefined.Check = Check;
-})(ExtendsUndefined = exports.ExtendsUndefined || (exports.ExtendsUndefined = {}));
+})(ExtendsUndefined || (exports.ExtendsUndefined = ExtendsUndefined = {}));
 // --------------------------------------------------------------------------
 // TypeExtends
 // --------------------------------------------------------------------------
@@ -645,7 +645,7 @@ var TypeExtendsResult;
     TypeExtendsResult[TypeExtendsResult["Union"] = 0] = "Union";
     TypeExtendsResult[TypeExtendsResult["True"] = 1] = "True";
     TypeExtendsResult[TypeExtendsResult["False"] = 2] = "False";
-})(TypeExtendsResult = exports.TypeExtendsResult || (exports.TypeExtendsResult = {}));
+})(TypeExtendsResult || (exports.TypeExtendsResult = TypeExtendsResult = {}));
 var TypeExtends;
 (function (TypeExtends) {
     // --------------------------------------------------------------------------
@@ -1369,7 +1369,7 @@ var TypeExtends;
         return Visit(left, right);
     }
     TypeExtends.Extends = Extends;
-})(TypeExtends = exports.TypeExtends || (exports.TypeExtends = {}));
+})(TypeExtends || (exports.TypeExtends = TypeExtends = {}));
 // --------------------------------------------------------------------------
 // TypeClone
 // --------------------------------------------------------------------------
@@ -1406,7 +1406,7 @@ var TypeClone;
         return { ...Visit(schema), ...options };
     }
     TypeClone.Clone = Clone;
-})(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
+})(TypeClone || (exports.TypeClone = TypeClone = {}));
 // --------------------------------------------------------------------------
 // IndexedAccessor
 // --------------------------------------------------------------------------
@@ -1452,7 +1452,7 @@ var IndexedAccessor;
         return exports.Type.Union(keys.map((key) => Visit(schema, key.toString())), options);
     }
     IndexedAccessor.Resolve = Resolve;
-})(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
+})(IndexedAccessor || (exports.IndexedAccessor = IndexedAccessor = {}));
 // --------------------------------------------------------------------------
 // ObjectMap
 // --------------------------------------------------------------------------
@@ -1486,7 +1486,7 @@ var ObjectMap;
         return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
     }
     ObjectMap.Map = Map;
-})(ObjectMap = exports.ObjectMap || (exports.ObjectMap = {}));
+})(ObjectMap || (exports.ObjectMap = ObjectMap = {}));
 var KeyResolver;
 (function (KeyResolver) {
     function UnwrapPattern(key) {
@@ -1528,7 +1528,7 @@ var KeyResolver;
         return `^(${pattern.join('|')})$`;
     }
     KeyResolver.ResolvePattern = ResolvePattern;
-})(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
+})(KeyResolver || (exports.KeyResolver = KeyResolver = {}));
 // --------------------------------------------------------------------------
 // KeyArrayResolver
 // --------------------------------------------------------------------------
@@ -1551,7 +1551,7 @@ var KeyArrayResolver;
         return [];
     }
     KeyArrayResolver.Resolve = Resolve;
-})(KeyArrayResolver = exports.KeyArrayResolver || (exports.KeyArrayResolver = {}));
+})(KeyArrayResolver || (exports.KeyArrayResolver = KeyArrayResolver = {}));
 // --------------------------------------------------------------------------
 // UnionResolver
 // --------------------------------------------------------------------------
@@ -1572,7 +1572,7 @@ var UnionResolver;
         return exports.Type.Union([...Union(union)], { ...union });
     }
     UnionResolver.Resolve = Resolve;
-})(UnionResolver = exports.UnionResolver || (exports.UnionResolver = {}));
+})(UnionResolver || (exports.UnionResolver = UnionResolver = {}));
 // --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
@@ -1619,7 +1619,7 @@ var TemplateLiteralPattern;
         return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
     }
     TemplateLiteralPattern.Create = Create;
-})(TemplateLiteralPattern = exports.TemplateLiteralPattern || (exports.TemplateLiteralPattern = {}));
+})(TemplateLiteralPattern || (exports.TemplateLiteralPattern = TemplateLiteralPattern = {}));
 // --------------------------------------------------------------------------------------
 // TemplateLiteralResolver
 // --------------------------------------------------------------------------------------
@@ -1634,7 +1634,7 @@ var TemplateLiteralResolver;
         return exports.Type.Union(literals);
     }
     TemplateLiteralResolver.Resolve = Resolve;
-})(TemplateLiteralResolver = exports.TemplateLiteralResolver || (exports.TemplateLiteralResolver = {}));
+})(TemplateLiteralResolver || (exports.TemplateLiteralResolver = TemplateLiteralResolver = {}));
 // --------------------------------------------------------------------------------------
 // TemplateLiteralParser
 // --------------------------------------------------------------------------------------
@@ -1778,7 +1778,7 @@ var TemplateLiteralParser;
         return Parse(pattern.slice(1, pattern.length - 1));
     }
     TemplateLiteralParser.ParseExact = ParseExact;
-})(TemplateLiteralParser = exports.TemplateLiteralParser || (exports.TemplateLiteralParser = {}));
+})(TemplateLiteralParser || (exports.TemplateLiteralParser = TemplateLiteralParser = {}));
 // --------------------------------------------------------------------------------------
 // TemplateLiteralFinite
 // --------------------------------------------------------------------------------------
@@ -1819,7 +1819,7 @@ var TemplateLiteralFinite;
         throw Error(`TemplateLiteralFinite: Unknown expression type`);
     }
     TemplateLiteralFinite.Check = Check;
-})(TemplateLiteralFinite = exports.TemplateLiteralFinite || (exports.TemplateLiteralFinite = {}));
+})(TemplateLiteralFinite || (exports.TemplateLiteralFinite = TemplateLiteralFinite = {}));
 // --------------------------------------------------------------------------------------
 // TemplateLiteralGenerator
 // --------------------------------------------------------------------------------------
@@ -1854,7 +1854,7 @@ var TemplateLiteralGenerator;
         throw Error('TemplateLiteralGenerator: Unknown expression');
     }
     TemplateLiteralGenerator.Generate = Generate;
-})(TemplateLiteralGenerator = exports.TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = {}));
+})(TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = TemplateLiteralGenerator = {}));
 // ---------------------------------------------------------------------
 // TemplateLiteralDslParser
 // ---------------------------------------------------------------------
@@ -1902,7 +1902,7 @@ var TemplateLiteralDslParser;
         return [...ParseLiteral(template_dsl)];
     }
     TemplateLiteralDslParser.Parse = Parse;
-})(TemplateLiteralDslParser = exports.TemplateLiteralDslParser || (exports.TemplateLiteralDslParser = {}));
+})(TemplateLiteralDslParser || (exports.TemplateLiteralDslParser = TemplateLiteralDslParser = {}));
 // --------------------------------------------------------------------------
 // TypeOrdinal: Used for auto $id generation
 // --------------------------------------------------------------------------

package/value/cast.js

@@ -369,4 +369,4 @@ var ValueCast;
         return Visit(schema, references, clone_1.ValueClone.Clone(value));
     }
     ValueCast.Cast = Cast;
-})(ValueCast = exports.ValueCast || (exports.ValueCast = {}));
+})(ValueCast || (exports.ValueCast = ValueCast = {}));

package/value/check.js

@@ -489,4 +489,4 @@ var ValueCheck;
         return Visit(schema, references, value);
     }
     ValueCheck.Check = Check;
-})(ValueCheck = exports.ValueCheck || (exports.ValueCheck = {}));
+})(ValueCheck || (exports.ValueCheck = ValueCheck = {}));

package/value/clone.js

@@ -68,4 +68,4 @@ var ValueClone;
         }
     }
     ValueClone.Clone = Clone;
-})(ValueClone = exports.ValueClone || (exports.ValueClone = {}));
+})(ValueClone || (exports.ValueClone = ValueClone = {}));

package/value/convert.js

@@ -369,4 +369,4 @@ var ValueConvert;
         return Visit(schema, references, clone_1.ValueClone.Clone(value));
     }
     ValueConvert.Convert = Convert;
-})(ValueConvert = exports.ValueConvert || (exports.ValueConvert = {}));
+})(ValueConvert || (exports.ValueConvert = ValueConvert = {}));

package/value/create.js

@@ -477,4 +477,4 @@ var ValueCreate;
         return Visit(schema, references);
     }
     ValueCreate.Create = Create;
-})(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));
+})(ValueCreate || (exports.ValueCreate = ValueCreate = {}));

package/value/delta.js

@@ -201,4 +201,4 @@ var ValueDelta;
         return clone;
     }
     ValueDelta.Patch = Patch;
-})(ValueDelta = exports.ValueDelta || (exports.ValueDelta = {}));
+})(ValueDelta || (exports.ValueDelta = ValueDelta = {}));

package/value/equal.js

@@ -77,4 +77,4 @@ var ValueEqual;
         }
     }
     ValueEqual.Equal = Equal;
-})(ValueEqual = exports.ValueEqual || (exports.ValueEqual = {}));
+})(ValueEqual || (exports.ValueEqual = ValueEqual = {}));

package/value/hash.js

@@ -205,4 +205,4 @@ var ValueHash;
         return Hash;
     }
     ValueHash.Create = Create;
-})(ValueHash = exports.ValueHash || (exports.ValueHash = {}));
+})(ValueHash || (exports.ValueHash = ValueHash = {}));

package/value/is.js

@@ -50,4 +50,4 @@ var Is;
         return ArrayBuffer.isView(value);
     }
     Is.TypedArray = TypedArray;
-})(Is = exports.Is || (exports.Is = {}));
+})(Is || (exports.Is = Is = {}));

package/value/mutate.js

@@ -118,4 +118,4 @@ var ValueMutate;
         Visit(current, '', current, next);
     }
     ValueMutate.Mutate = Mutate;
-})(ValueMutate = exports.ValueMutate || (exports.ValueMutate = {}));
+})(ValueMutate || (exports.ValueMutate = ValueMutate = {}));

package/value/pointer.js

@@ -139,4 +139,4 @@ var ValuePointer;
         return current;
     }
     ValuePointer.Get = Get;
-})(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));
+})(ValuePointer || (exports.ValuePointer = ValuePointer = {}));

package/value/value.js

@@ -96,4 +96,4 @@ var Value;
         mutate_1.ValueMutate.Mutate(current, next);
     }
     Value.Mutate = Mutate;
-})(Value = exports.Value || (exports.Value = {}));
+})(Value || (exports.Value = Value = {}));