@sinclair/typebox 0.28.13 → 0.28.15

package/compiler/compiler.js

@@ -166,6 +166,12 @@ var TypeCompiler;
     function IsString(value) {
         return typeof value === 'string';
     }
+    // ----------------------------------------------------------------------
+    // SchemaGuards
+    // ----------------------------------------------------------------------
+    function IsAnyOrUnknown(schema) {
+        return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown';
+    }
     // -------------------------------------------------------------------
     // Polices
     // -------------------------------------------------------------------
@@ -308,7 +314,7 @@ var TypeCompiler;
             const property = schema.properties[knownKey];
             if (schema.required && schema.required.includes(knownKey)) {
                 yield* Visit(property, references, memberExpression);
-                if (Types.ExtendsUndefined.Check(property))
+                if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property))
                     yield `('${knownKey}' in ${value})`;
             }
             else {
@@ -420,19 +426,22 @@ 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':
@@ -515,7 +524,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) {
@@ -534,9 +543,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 = []) {
@@ -570,4 +582,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.13",
+  "version": "0.28.15",
   "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

@@ -3,7 +3,7 @@
 <h1>TypeBox</h1>
 
 <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
-	
+
 <img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
 
 <br />
@@ -65,7 +65,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire. 
+This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -145,23 +145,23 @@ type T = {
 
 const T = Type.Object({                              // const T = {
   id: Type.String(),                                 //   type: 'object',
-  name: Type.String(),                               //   properties: { 
-  timestamp: Type.Integer()                          //     id: { 
-})                                                   //       type: 'string' 
+  name: Type.String(),                               //   properties: {
+  timestamp: Type.Integer()                          //     id: {
+})                                                   //       type: 'string'
                                                      //     },
-                                                     //     name: { 
-                                                     //       type: 'string' 
+                                                     //     name: {
+                                                     //       type: 'string'
                                                      //     },
-                                                     //     timestamp: { 
-                                                     //       type: 'integer' 
+                                                     //     timestamp: {
+                                                     //       type: 'integer'
                                                      //     }
-                                                     //   }, 
+                                                     //   },
                                                      //   required: [
                                                      //     'id',
                                                      //     'name',
                                                      //     'timestamp'
                                                      //   ]
-                                                     // } 
+                                                     // }
 
 //--------------------------------------------------------------------------------------------
 //
@@ -186,7 +186,7 @@ import { Value } from '@sinclair/typebox/value'
 function receive(value: T) {                         // ... as a Static Type
 
   if(Value.Check(T, value)) {                        // ... as a JSON Schema
-  
+
     // ok...
   }
 }
@@ -196,7 +196,7 @@ function receive(value: T) {                         // ... as a Static Type
 
 ## Types
 
-TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript. 
+TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript.
 
 <a name='types-standard'></a>
 
@@ -645,22 +645,22 @@ You can pass JSON Schema options on the last argument of any type. Option hints
 
 ```typescript
 // String must be an email
-const T = Type.String({                              // const T = { 
+const T = Type.String({                              // const T = {
   format: 'email'                                    //   type: 'string',
-})                                                   //   format: 'email' 
+})                                                   //   format: 'email'
                                                      // }
 
 // Mumber must be a multiple of 2
-const T = Type.Number({                              // const T = { 
-  multipleOf: 2                                      //  type: 'number', 
-})                                                   //  multipleOf: 2 
+const T = Type.Number({                              // const T = {
+  multipleOf: 2                                      //  type: 'number',
+})                                                   //  multipleOf: 2
                                                      // }
 
 // Array must have at least 5 integer values
-const T = Type.Array(Type.Integer(), {               // const T = { 
+const T = Type.Array(Type.Integer(), {               // const T = {
   minItems: 5                                        //   type: 'array',
-})                                                   //   minItems: 5,        
-                                                     //   items: { 
+})                                                   //   minItems: 5,
+                                                     //   items: {
                                                      //     type: 'integer'
                                                      //   }
                                                      // }
@@ -737,7 +737,7 @@ const T = Type.String({ $id: 'T' })                  // const T = {
                                                      //    $id: 'T',
                                                      //    type: 'string'
                                                      // }
-                                             
+
 const R = Type.Ref(T)                                // const R = {
                                                      //    $ref: 'T'
                                                      // }
@@ -808,7 +808,7 @@ type T0 = Static<typeof T0>                        // type T0 = false
 
 type T1 = Static<typeof T1>                        // type T1 = number
 
-type T2 = Static<typeof T2>                        // type T2 = string 
+type T2 = Static<typeof T2>                        // type T2 = string
 ```
 
 <a name='types-template-literal'></a>
@@ -876,16 +876,16 @@ const T = Type.Object({                              // const T = {
 
 const A = Type.Index(T, ['x'])                       // const A = { type: 'number' }
 
-const B = Type.Index(T, ['x', 'y'])                  // const B = { 
+const B = Type.Index(T, ['x', 'y'])                  // const B = {
                                                      //   anyOf: [
-                                                     //     { type: 'number' },  
+                                                     //     { type: 'number' },
                                                      //     { type: 'string' }
                                                      //   ]
                                                      // }
 
-const C = Type.Index(T, Type.KeyOf(T))               // const C = { 
+const C = Type.Index(T, Type.KeyOf(T))               // const C = {
                                                      //   anyOf: [
-                                                     //     { type: 'number' },  
+                                                     //     { type: 'number' },
                                                      //     { type: 'string' },
                                                      //     { type: 'boolean' }
                                                      //   ]
@@ -987,7 +987,7 @@ import { Type, TypeGuard } from '@sinclair/typebox'
 const T = Type.String()
 
 if(TypeGuard.TString(T)) {
-    
+
   // T is TString
 }
 ```
@@ -1012,12 +1012,12 @@ const T = Type.Object({                              // const T = {
                                                      // }
 
 const U = Type.Strict(T)                             // const U = {
-                                                     //   type: 'object', 
-                                                     //   properties: { 
-                                                     //     name: { 
-                                                     //       type: 'string' 
-                                                     //     } 
-                                                     //   } 
+                                                     //   type: 'object',
+                                                     //   properties: {
+                                                     //     name: {
+                                                     //       type: 'string'
+                                                     //     }
+                                                     //   }
                                                      // }
 ```
 
@@ -1183,21 +1183,21 @@ const R = [...Value.Errors(T, { x: '42' })]          // const R = [{
 Use the Mutate function to perform a deep mutable value assignment while retaining internal references.
 
 ```typescript
-const Y = { z: 1 }                                   // const Y = { z: 1 } 
+const Y = { z: 1 }                                   // const Y = { z: 1 }
 
 const X = { y: Y }                                   // const X = { y: { z: 1 } }
 
-const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }             
+const A = { x: X }                                   // const A = { x: { y: { z: 1 } } }
 
 
-Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }   
+Value.Mutate(A, { x: { y: { z: 2 } } })              // const A' = { x: { y: { z: 2 } } }
 
-const R0 = A.x.y.z === 2                             // const R0 = 2
+const R0 = A.x.y.z === 2                             // const R0 = true
 
 const R1 = A.x.y === Y                               // const R1 = true
 
 const R2 = A.x === X                                 // const R2 = true
-```     
+```
 
 <a name='values-pointer'></a>
 
@@ -1241,29 +1241,29 @@ import addFormats from 'ajv-formats'
 import Ajv        from 'ajv'
 
 const ajv = addFormats(new Ajv({}), [
-  'date-time', 
-  'time', 
-  'date', 
-  'email',  
-  'hostname', 
-  'ipv4', 
-  'ipv6', 
-  'uri', 
-  'uri-reference', 
+  'date-time',
+  'time',
+  'date',
+  'email',
+  'hostname',
+  'ipv4',
+  'ipv6',
+  'uri',
+  'uri-reference',
   'uuid',
-  'uri-template', 
-  'json-pointer', 
-  'relative-json-pointer', 
+  'uri-template',
+  'json-pointer',
+  'relative-json-pointer',
   'regex'
 ])
 
-const C = ajv.compile(Type.Object({                
+const C = ajv.compile(Type.Object({
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number()
 }))
 
-const R = C({ x: 1, y: 2, z: 3 })                    // const R = true 
+const R = C({ x: 1, y: 2, z: 3 })                    // const R = true
 ```
 
 <a name='typecheck-typecompiler'></a>
@@ -1350,15 +1350,15 @@ import { TypeSystem } from '@sinclair/typebox/system'
 Use the `Type(...)` function to create custom types. This function lets you specify custom value assertion logic and will return a type factory function which is used to instance the type. This function accepts two generic arguments, the first is the inference type, the second is options used to constrain the type. The following creates a Vector type.
 
 ```typescript
-type VectorOptions = { abs: boolean }       
+type VectorOptions = { abs: boolean }
 
 type Vector = { x: number, y: number }
 
 const Vector = TypeSystem.Type<Vector, VectorOptions>('Vector', (options, value) => {
   return (
     typeof value === 'object' && value !== null &&
-    'x' in value && typeof value.x === 'number' && 
-    'y' in value && typeof value.y === 'number' && 
+    'x' in value && typeof value.x === 'number' &&
+    'y' in value && typeof value.y === 'number' &&
     (options.abs ? (value.x === Math.abs(value.x) && value.y === Math.abs(value.y)) : true)
   )
 })
@@ -1383,7 +1383,7 @@ Use the `Format(...)` function to create a custom string format. The following c
 ```typescript
 TypeSystem.Format('lowercase', value => value === value.toLowerCase()) // format should be lowercase
 
-const T = Type.String({ format: 'lowercase' })       
+const T = Type.String({ format: 'lowercase' })
 
 const A = Value.Check(T, 'Hello')                    // const A = false
 
@@ -1407,13 +1407,13 @@ TypeSystem.ExactOptionalPropertyTypes = true
 //
 // const A: {} = [] - allowed in TS
 
-TypeSystem.AllowArrayObjects = true                  
+TypeSystem.AllowArrayObjects = true
 
 // Allow numeric values to be NaN or + or - Infinity (default is false)
 //
 // const A: number = NaN - allowed in TS
 
-TypeSystem.AllowNaN = true                      
+TypeSystem.AllowNaN = true
 ```
 
 <a name='workbench'></a>
@@ -1441,7 +1441,8 @@ The following is a list of community packages that provide general tooling and f
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
-| [ts2typebox](https://github.com/xddq/ts2typebox)  | Cli tool to generate TypeBox JSON schemas based on your Typescript types |
+| [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from JSON schemas |
+| [ts2typebox](https://github.com/xddq/ts2typebox)  | Creating TypeBox code from Typescript types |
 
 <a name='benchmark'></a>
 
@@ -1461,35 +1462,35 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    243 ms' │ '      8 ms' │ '   30.38 x' │
-│ Literal_Number             │    1000    │ '    195 ms' │ '      5 ms' │ '   39.00 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    │ '    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' │
+│ 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' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1503,37 +1504,37 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ 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' │
+│ 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' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1547,11 +1548,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '127.1 kb' │ ' 56.7 kb' │  '2.24 x'   │
-│ typebox/errors       │ '110.9 kb' │ ' 48.9 kb' │  '2.27 x'   │
-│ typebox/system       │ ' 76.3 kb' │ ' 31.2 kb' │  '2.44 x'   │
-│ typebox/value        │ '176.8 kb' │ ' 76.5 kb' │  '2.31 x'   │
-│ typebox              │ ' 75.2 kb' │ ' 30.8 kb' │  '2.44 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'   │
+│ typebox              │ ' 75.9 kb' │ ' 31.0 kb' │  '2.45 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

@@ -66,6 +66,12 @@ var ValueCheck;
         return value !== undefined;
     }
     // ----------------------------------------------------------------------
+    // SchemaGuards
+    // ----------------------------------------------------------------------
+    function IsAnyOrUnknown(schema) {
+        return schema[Types.Kind] === 'Any' || schema[Types.Kind] === 'Unknown';
+    }
+    // ----------------------------------------------------------------------
     // Policies
     // ----------------------------------------------------------------------
     function IsExactOptionalProperty(value, key) {
@@ -254,7 +260,7 @@ var ValueCheck;
                 if (!Visit(property, references, value[knownKey])) {
                     return false;
                 }
-                if (Types.ExtendsUndefined.Check(property) && !(knownKey in value)) {
+                if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
                     return false;
                 }
             }
@@ -483,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 = {}));