@sinclair/typebox 0.27.8 → 0.28.0

package/compiler/compiler.js

@@ -249,24 +249,19 @@ var TypeCompiler;
             yield `${value} <= ${schema.maximum}`;
     }
     function* Intersect(schema, references, value) {
-        if (schema.unevaluatedProperties === undefined) {
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
-            yield `${expressions.join(' && ')}`;
+        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 check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
+            yield `${check1} && ${check2}`;
         }
-        else if (schema.unevaluatedProperties === false) {
-            // prettier-ignore
-            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
-            const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`;
-            yield `${expressions.join(' && ')} && ${expression1}`;
+        else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+            const keyCheck = PushLocal(`${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}`;
         }
-        else if (typeof schema.unevaluatedProperties === 'object') {
-            // prettier-ignore
-            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
-            const expression1 = CreateExpression(schema.unevaluatedProperties, references, 'value[key]');
-            const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`;
-            yield `${expressions.join(' && ')} && ${expression2}`;
+        else {
+            yield `${check1}`;
         }
     }
     function* Literal(schema, references, value) {
@@ -345,11 +340,12 @@ var TypeCompiler;
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
         if (IsNumber(schema.maxProperties))
             yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const local = PushLocal(`new RegExp(/${keyPattern}/)`);
-        yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
-        const expression = CreateExpression(valueSchema, references, 'value');
-        yield `Object.values(${value}).every(value => ${expression})`;
+        const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const local = PushLocal(`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})`;
+        yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
     function* Ref(schema, references, value) {
         const index = references.findIndex((foreign) => foreign.$id === schema.$ref);

package/errors/errors.js

@@ -273,8 +273,8 @@ var ValueErrors;
         }
     }
     function* Intersect(schema, references, path, value) {
-        for (const subschema of schema.allOf) {
-            const next = Visit(subschema, references, path, value).next();
+        for (const inner of schema.allOf) {
+            const next = Visit(inner, references, path, value).next();
             if (!next.done) {
                 yield next.value;
                 yield { type: ValueErrorType.Intersect, schema, path, value, message: `Expected all sub schemas to be valid` };
@@ -282,19 +282,17 @@ var ValueErrors;
             }
         }
         if (schema.unevaluatedProperties === false) {
-            const schemaKeys = Types.KeyResolver.Resolve(schema);
-            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
-            for (const valueKey of valueKeys) {
-                if (!schemaKeys.includes(valueKey)) {
+            const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+            for (const valueKey of globalThis.Object.getOwnPropertyNames(value)) {
+                if (!keyCheck.test(valueKey)) {
                     yield { type: ValueErrorType.IntersectUnevaluatedProperties, schema, path: `${path}/${valueKey}`, value, message: `Unexpected property` };
                 }
             }
         }
         if (typeof schema.unevaluatedProperties === 'object') {
-            const schemaKeys = Types.KeyResolver.Resolve(schema);
-            const valueKeys = globalThis.Object.getOwnPropertyNames(value);
-            for (const valueKey of valueKeys) {
-                if (!schemaKeys.includes(valueKey)) {
+            const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+            for (const valueKey of globalThis.Object.getOwnPropertyNames(value)) {
+                if (!keyCheck.test(valueKey)) {
                     const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
                     if (!next.done) {
                         yield next.value;
@@ -407,16 +405,21 @@ var ValueErrors;
         if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             yield { type: ValueErrorType.ObjectMaxProperties, schema, path, value, message: `Expected object to have less than ${schema.minProperties} properties` };
         }
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
-            const numeric = keyPattern === Types.PatternNumberExact;
-            const type = numeric ? ValueErrorType.RecordKeyNumeric : ValueErrorType.RecordKeyString;
-            const message = numeric ? 'Expected all object property keys to be numeric' : 'Expected all object property keys to be strings';
-            return yield { type, schema, path, value, message };
-        }
-        for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            yield* Visit(valueSchema, references, `${path}/${propKey}`, propValue);
+        const [patternKey, patternSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        const regex = new RegExp(patternKey);
+        for (const [propertyKey, propertyValue] of globalThis.Object.entries(value)) {
+            if (regex.test(propertyKey)) {
+                yield* Visit(patternSchema, references, `${path}/${propertyKey}`, propertyValue);
+                continue;
+            }
+            if (typeof schema.additionalProperties === 'object') {
+                yield* Visit(schema.additionalProperties, references, `${path}/${propertyKey}`, propertyValue);
+            }
+            if (schema.additionalProperties === false) {
+                const propertyPath = `${path}/${propertyKey}`;
+                const message = `Unexpected property '${propertyPath}'`;
+                return yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: propertyPath, value: propertyValue, message };
+            }
         }
     }
     function* Ref(schema, references, path, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.27.8",
+  "version": "0.28.0",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -81,7 +81,8 @@ License MIT
   - [References](#types-references)
   - [Recursive](#types-recursive)
   - [Conditional](#types-conditional)
-  - [Template Literal](#types-template-literal)
+  - [Template](#types-template-literal)
+  - [Indexed](#types-indexed)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -276,6 +277,14 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Index(          │ type T = {                  │ const T = {                    │
+│   Type.Object({                │   x: number,                │   type: number                 │
+│     x: Type.Number(),          │   y: string                 │ }                              │
+│     y: Type.String()           │ }['x']                      │                                │
+│   }), ['x']                    │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ enum Foo {                     │ enum Foo {                  │ const T = {                    │
 │   A,                           │   A,                        │   anyOf: [{                    │
 │   B                            │   B                         │     type: 'number',            │
@@ -830,6 +839,24 @@ type R = Static<typeof R>                            // type R = {
                                                      // }
 ```
 
+<a name='types-indexed'></a>
+
+### Indexed Access Types
+
+Indexed Access types are supported with `Type.Index`
+
+```typescript
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number
+  y: Type.String(),                                  //   y: string
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
+
+const A = Type.Index(T, ['x'])                       // type A = T['x']
+
+const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
+```
+
 <a name='types-unsafe'></a>
 
 ### Unsafe
@@ -1309,7 +1336,7 @@ TypeSystem.AllowNaN = true
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0. 
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.12.0 running on Node 20.0.0.
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1323,35 +1350,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    257 ms' │ '      8 ms' │ '   32.13 x' │
-│ Literal_Number             │    1000    │ '    203 ms' │ '      4 ms' │ '   50.75 x' │
-│ Literal_Boolean            │    1000    │ '    183 ms' │ '      4 ms' │ '   45.75 x' │
-│ Primitive_Number           │    1000    │ '    174 ms' │ '      8 ms' │ '   21.75 x' │
-│ Primitive_String           │    1000    │ '    158 ms' │ '      9 ms' │ '   17.56 x' │
-│ Primitive_String_Pattern   │    1000    │ '    213 ms' │ '     13 ms' │ '   16.38 x' │
-│ Primitive_Boolean          │    1000    │ '    136 ms' │ '      6 ms' │ '   22.67 x' │
-│ Primitive_Null             │    1000    │ '    144 ms' │ '      6 ms' │ '   24.00 x' │
-│ Object_Unconstrained       │    1000    │ '   1176 ms' │ '     38 ms' │ '   30.95 x' │
-│ Object_Constrained         │    1000    │ '   1181 ms' │ '     31 ms' │ '   38.10 x' │
-│ Object_Vector3             │    1000    │ '    387 ms' │ '      8 ms' │ '   48.38 x' │
-│ Object_Box3D               │    1000    │ '   1693 ms' │ '     25 ms' │ '   67.72 x' │
-│ Tuple_Primitive            │    1000    │ '    470 ms' │ '     15 ms' │ '   31.33 x' │
-│ Tuple_Object               │    1000    │ '   1206 ms' │ '     17 ms' │ '   70.94 x' │
-│ Composite_Intersect        │    1000    │ '    567 ms' │ '     20 ms' │ '   28.35 x' │
-│ Composite_Union            │    1000    │ '    515 ms' │ '     21 ms' │ '   24.52 x' │
-│ Math_Vector4               │    1000    │ '    787 ms' │ '     10 ms' │ '   78.70 x' │
-│ Math_Matrix4               │    1000    │ '    386 ms' │ '      8 ms' │ '   48.25 x' │
-│ Array_Primitive_Number     │    1000    │ '    349 ms' │ '      7 ms' │ '   49.86 x' │
-│ Array_Primitive_String     │    1000    │ '    336 ms' │ '      4 ms' │ '   84.00 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    284 ms' │ '      3 ms' │ '   94.67 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1704 ms' │ '     19 ms' │ '   89.68 x' │
-│ Array_Object_Constrained   │    1000    │ '   1456 ms' │ '     18 ms' │ '   80.89 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    792 ms' │ '     15 ms' │ '   52.80 x' │
-│ Array_Tuple_Object         │    1000    │ '   1552 ms' │ '     17 ms' │ '   91.29 x' │
-│ Array_Composite_Intersect  │    1000    │ '    744 ms' │ '     18 ms' │ '   41.33 x' │
-│ Array_Composite_Union      │    1000    │ '    783 ms' │ '     15 ms' │ '   52.20 x' │
-│ Array_Math_Vector4         │    1000    │ '   1093 ms' │ '     14 ms' │ '   78.07 x' │
-│ Array_Math_Matrix4         │    1000    │ '    684 ms' │ '      6 ms' │ '  114.00 x' │
+│ Literal_String             │    1000    │ '    243 ms' │ '      8 ms' │ '   30.38 x' │
+│ Literal_Number             │    1000    │ '    195 ms' │ '      5 ms' │ '   39.00 x' │
+│ Literal_Boolean            │    1000    │ '    162 ms' │ '      4 ms' │ '   40.50 x' │
+│ Primitive_Number           │    1000    │ '    168 ms' │ '      6 ms' │ '   28.00 x' │
+│ Primitive_String           │    1000    │ '    164 ms' │ '      5 ms' │ '   32.80 x' │
+│ Primitive_String_Pattern   │    1000    │ '    214 ms' │ '      9 ms' │ '   23.78 x' │
+│ Primitive_Boolean          │    1000    │ '    132 ms' │ '      4 ms' │ '   33.00 x' │
+│ Primitive_Null             │    1000    │ '    148 ms' │ '      4 ms' │ '   37.00 x' │
+│ Object_Unconstrained       │    1000    │ '   1158 ms' │ '     30 ms' │ '   38.60 x' │
+│ Object_Constrained         │    1000    │ '   1263 ms' │ '     25 ms' │ '   50.52 x' │
+│ Object_Vector3             │    1000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
+│ Object_Box3D               │    1000    │ '   1932 ms' │ '     27 ms' │ '   71.56 x' │
+│ Tuple_Primitive            │    1000    │ '    478 ms' │ '     14 ms' │ '   34.14 x' │
+│ Tuple_Object               │    1000    │ '   1232 ms' │ '     14 ms' │ '   88.00 x' │
+│ Composite_Intersect        │    1000    │ '    671 ms' │ '     17 ms' │ '   39.47 x' │
+│ Composite_Union            │    1000    │ '    537 ms' │ '     18 ms' │ '   29.83 x' │
+│ Math_Vector4               │    1000    │ '    816 ms' │ '     14 ms' │ '   58.29 x' │
+│ Math_Matrix4               │    1000    │ '    417 ms' │ '      6 ms' │ '   69.50 x' │
+│ Array_Primitive_Number     │    1000    │ '    378 ms' │ '      5 ms' │ '   75.60 x' │
+│ Array_Primitive_String     │    1000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    279 ms' │ '      5 ms' │ '   55.80 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1794 ms' │ '     20 ms' │ '   89.70 x' │
+│ Array_Object_Constrained   │    1000    │ '   1586 ms' │ '     19 ms' │ '   83.47 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    791 ms' │ '     13 ms' │ '   60.85 x' │
+│ Array_Tuple_Object         │    1000    │ '   1638 ms' │ '     17 ms' │ '   96.35 x' │
+│ Array_Composite_Intersect  │    1000    │ '    796 ms' │ '     17 ms' │ '   46.82 x' │
+│ Array_Composite_Union      │    1000    │ '    798 ms' │ '     15 ms' │ '   53.20 x' │
+│ Array_Math_Vector4         │    1000    │ '   1127 ms' │ '     14 ms' │ '   80.50 x' │
+│ Array_Math_Matrix4         │    1000    │ '    677 ms' │ '      9 ms' │ '   75.22 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1365,37 +1392,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     27 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│ Literal_Number             │  1000000   │ '     23 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│ Literal_Boolean            │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│ Primitive_Number           │  1000000   │ '     26 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
-│ Primitive_String           │  1000000   │ '     25 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    155 ms' │ '     49 ms' │ '     43 ms' │ '    1.14 x' │
-│ Primitive_Boolean          │  1000000   │ '     23 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Primitive_Null             │  1000000   │ '     24 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Object_Unconstrained       │  1000000   │ '    804 ms' │ '     35 ms' │ '     28 ms' │ '    1.25 x' │
-│ Object_Constrained         │  1000000   │ '   1041 ms' │ '     55 ms' │ '     41 ms' │ '    1.34 x' │
-│ Object_Vector3             │  1000000   │ '    380 ms' │ '     26 ms' │ '     20 ms' │ '    1.30 x' │
-│ Object_Box3D               │  1000000   │ '   1785 ms' │ '     65 ms' │ '     52 ms' │ '    1.25 x' │
-│ Object_Recursive           │  1000000   │ '   4984 ms' │ '    396 ms' │ '    114 ms' │ '    3.47 x' │
-│ Tuple_Primitive            │  1000000   │ '    168 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
-│ Tuple_Object               │  1000000   │ '    673 ms' │ '     30 ms' │ '     26 ms' │ '    1.15 x' │
-│ Composite_Intersect        │  1000000   │ '    751 ms' │ '     28 ms' │ '     20 ms' │ '    1.40 x' │
-│ Composite_Union            │  1000000   │ '    489 ms' │ '     24 ms' │ '     16 ms' │ '    1.50 x' │
-│ Math_Vector4               │  1000000   │ '    259 ms' │ '     23 ms' │ '     13 ms' │ '    1.77 x' │
-│ Math_Matrix4               │  1000000   │ '   1002 ms' │ '     40 ms' │ '     30 ms' │ '    1.33 x' │
-│ Array_Primitive_Number     │  1000000   │ '    252 ms' │ '     22 ms' │ '     15 ms' │ '    1.47 x' │
-│ Array_Primitive_String     │  1000000   │ '    227 ms' │ '     22 ms' │ '     18 ms' │ '    1.22 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    150 ms' │ '     23 ms' │ '     22 ms' │ '    1.05 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   4754 ms' │ '     71 ms' │ '     64 ms' │ '    1.11 x' │
-│ Array_Object_Constrained   │  1000000   │ '   4787 ms' │ '    142 ms' │ '    123 ms' │ '    1.15 x' │
-│ Array_Object_Recursive     │  1000000   │ '  19088 ms' │ '   1735 ms' │ '    314 ms' │ '    5.53 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    650 ms' │ '     41 ms' │ '     31 ms' │ '    1.32 x' │
-│ Array_Tuple_Object         │  1000000   │ '   2770 ms' │ '     67 ms' │ '     55 ms' │ '    1.22 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   2693 ms' │ '     50 ms' │ '     39 ms' │ '    1.28 x' │
-│ Array_Composite_Union      │  1000000   │ '   1982 ms' │ '     72 ms' │ '     33 ms' │ '    2.18 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1068 ms' │ '     40 ms' │ '     26 ms' │ '    1.54 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4609 ms' │ '    115 ms' │ '     88 ms' │ '    1.31 x' │
+│ Literal_String             │  1000000   │ '     24 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     21 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Literal_Boolean            │  1000000   │ '     19 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_Number           │  1000000   │ '     24 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Primitive_String           │  1000000   │ '     26 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    159 ms' │ '     45 ms' │ '     36 ms' │ '    1.25 x' │
+│ Primitive_Boolean          │  1000000   │ '     22 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Primitive_Null             │  1000000   │ '     23 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
+│ Object_Unconstrained       │  1000000   │ '    914 ms' │ '     34 ms' │ '     26 ms' │ '    1.31 x' │
+│ Object_Constrained         │  1000000   │ '   1095 ms' │ '     50 ms' │ '     38 ms' │ '    1.32 x' │
+│ Object_Vector3             │  1000000   │ '    414 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Object_Box3D               │  1000000   │ '   1933 ms' │ '     55 ms' │ '     53 ms' │ '    1.04 x' │
+│ Object_Recursive           │  1000000   │ '   4995 ms' │ '    378 ms' │ '    177 ms' │ '    2.14 x' │
+│ Tuple_Primitive            │  1000000   │ '    168 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│ Tuple_Object               │  1000000   │ '    681 ms' │ '     31 ms' │ '     19 ms' │ '    1.63 x' │
+│ Composite_Intersect        │  1000000   │ '    718 ms' │ '     25 ms' │ '     15 ms' │ '    1.67 x' │
+│ Composite_Union            │  1000000   │ '    511 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│ Math_Vector4               │  1000000   │ '    285 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│ Math_Matrix4               │  1000000   │ '   1197 ms' │ '     39 ms' │ '     28 ms' │ '    1.39 x' │
+│ Array_Primitive_Number     │  1000000   │ '    294 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Array_Primitive_String     │  1000000   │ '    251 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    131 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   5249 ms' │ '     69 ms' │ '     56 ms' │ '    1.23 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5299 ms' │ '    127 ms' │ '    123 ms' │ '    1.03 x' │
+│ Array_Object_Recursive     │  1000000   │ '  19609 ms' │ '   1711 ms' │ '    608 ms' │ '    2.81 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    734 ms' │ '     38 ms' │ '     30 ms' │ '    1.27 x' │
+│ Array_Tuple_Object         │  1000000   │ '   2843 ms' │ '     63 ms' │ '     51 ms' │ '    1.24 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   2794 ms' │ '     43 ms' │ '     36 ms' │ '    1.19 x' │
+│ Array_Composite_Union      │  1000000   │ '   1892 ms' │ '     66 ms' │ '     33 ms' │ '    2.00 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1177 ms' │ '     37 ms' │ '     23 ms' │ '    1.61 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   5115 ms' │ '    110 ms' │ '     85 ms' │ '    1.29 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1409,11 +1436,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '124.3 kb' │ ' 55.7 kb' │  '2.23 x'   │
-│ typebox/errors       │ '107.8 kb' │ ' 47.9 kb' │  '2.25 x'   │
-│ typebox/system       │ ' 73.3 kb' │ ' 30.2 kb' │  '2.43 x'   │
-│ typebox/value        │ '170.7 kb' │ ' 74.2 kb' │  '2.30 x'   │
-│ typebox              │ ' 72.0 kb' │ ' 29.7 kb' │  '2.43 x'   │
+│ typebox/compiler     │ '127.2 kb' │ ' 56.9 kb' │  '2.23 x'   │
+│ typebox/errors       │ '110.9 kb' │ ' 49.2 kb' │  '2.25 x'   │
+│ typebox/system       │ ' 76.4 kb' │ ' 31.5 kb' │  '2.42 x'   │
+│ typebox/value        │ '176.9 kb' │ ' 76.8 kb' │  '2.30 x'   │
+│ typebox              │ ' 75.3 kb' │ ' 31.1 kb' │  '2.42 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/system/system.d.ts

@@ -19,8 +19,4 @@ export declare namespace TypeSystem {
     function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => Types.TUnsafe<Type>;
     /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
-    /** @deprecated Use `TypeSystem.Type()` instead. */
-    function CreateType<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => Types.TUnsafe<Type>;
-    /** @deprecated Use `TypeSystem.Format()` instead.  */
-    function CreateFormat<F extends string>(format: F, check: (value: string) => boolean): F;
 }

package/system/system.js

@@ -74,17 +74,4 @@ var TypeSystem;
         return format;
     }
     TypeSystem.Format = Format;
-    // ------------------------------------------------------------------------
-    // Deprecated
-    // ------------------------------------------------------------------------
-    /** @deprecated Use `TypeSystem.Type()` instead. */
-    function CreateType(kind, check) {
-        return Type(kind, check);
-    }
-    TypeSystem.CreateType = CreateType;
-    /** @deprecated Use `TypeSystem.Format()` instead.  */
-    function CreateFormat(format, check) {
-        return Format(format, check);
-    }
-    TypeSystem.CreateFormat = CreateFormat;
 })(TypeSystem = exports.TypeSystem || (exports.TypeSystem = {}));