@sinclair/typebox 0.24.47 → 0.24.49

package/compiler/compiler.js

@@ -190,6 +190,11 @@ var TypeCompiler;
                 yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`;
             }
         }
+        if (index_2.TypeGuard.TSchema(schema.additionalProperties)) {
+            const expression = CreateExpression(schema.additionalProperties, 'value[key]');
+            const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
+            yield `(Object.keys(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
+        }
         for (const propertyKey of propertyKeys) {
             const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
             const propertySchema = schema.properties[propertyKey];

package/errors/errors.d.ts

@@ -25,23 +25,24 @@ export declare enum ValueErrorType {
     ObjectMinProperties = 22,
     ObjectMaxProperties = 23,
     ObjectAdditionalProperties = 24,
-    Promise = 25,
-    RecordKeyNumeric = 26,
-    RecordKeyString = 27,
-    String = 28,
-    StringMinLength = 29,
-    StringMaxLength = 30,
-    StringPattern = 31,
-    StringFormatUnknown = 32,
-    StringFormat = 33,
-    TupleZeroLength = 34,
-    TupleLength = 35,
-    Undefined = 36,
-    Union = 37,
-    Uint8Array = 38,
-    Uint8ArrayMinByteLength = 39,
-    Uint8ArrayMaxByteLength = 40,
-    Void = 41
+    ObjectRequiredProperties = 25,
+    Promise = 26,
+    RecordKeyNumeric = 27,
+    RecordKeyString = 28,
+    String = 29,
+    StringMinLength = 30,
+    StringMaxLength = 31,
+    StringPattern = 32,
+    StringFormatUnknown = 33,
+    StringFormat = 34,
+    TupleZeroLength = 35,
+    TupleLength = 36,
+    Undefined = 37,
+    Union = 38,
+    Uint8Array = 39,
+    Uint8ArrayMinByteLength = 40,
+    Uint8ArrayMaxByteLength = 41,
+    Void = 42
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -60,23 +60,24 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["ObjectMinProperties"] = 22] = "ObjectMinProperties";
     ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 23] = "ObjectMaxProperties";
     ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 24] = "ObjectAdditionalProperties";
-    ValueErrorType[ValueErrorType["Promise"] = 25] = "Promise";
-    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 26] = "RecordKeyNumeric";
-    ValueErrorType[ValueErrorType["RecordKeyString"] = 27] = "RecordKeyString";
-    ValueErrorType[ValueErrorType["String"] = 28] = "String";
-    ValueErrorType[ValueErrorType["StringMinLength"] = 29] = "StringMinLength";
-    ValueErrorType[ValueErrorType["StringMaxLength"] = 30] = "StringMaxLength";
-    ValueErrorType[ValueErrorType["StringPattern"] = 31] = "StringPattern";
-    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 32] = "StringFormatUnknown";
-    ValueErrorType[ValueErrorType["StringFormat"] = 33] = "StringFormat";
-    ValueErrorType[ValueErrorType["TupleZeroLength"] = 34] = "TupleZeroLength";
-    ValueErrorType[ValueErrorType["TupleLength"] = 35] = "TupleLength";
-    ValueErrorType[ValueErrorType["Undefined"] = 36] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 37] = "Union";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 38] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 39] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 40] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Void"] = 41] = "Void";
+    ValueErrorType[ValueErrorType["ObjectRequiredProperties"] = 25] = "ObjectRequiredProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 26] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 27] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 28] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 29] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 30] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 31] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 32] = "StringPattern";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 33] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 34] = "StringFormat";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 35] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 36] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 37] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 38] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 39] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 40] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 41] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 42] = "Void";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -190,12 +191,27 @@ var ValueErrors;
         }
         const propertyKeys = globalThis.Object.keys(schema.properties);
         if (schema.additionalProperties === false) {
-            for (const propKey of globalThis.Object.keys(value)) {
-                if (!propertyKeys.includes(propKey)) {
-                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propKey}`, value: value[propKey], message: 'Unexpected property' };
+            for (const objectKey of globalThis.Object.keys(value)) {
+                if (!propertyKeys.includes(objectKey)) {
+                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${objectKey}`, value: value[objectKey], message: `Unexpected property` };
                 }
             }
         }
+        if (schema.required && schema.required.length > 0) {
+            const objectKeys = globalThis.Object.keys(value);
+            for (const requiredKey of schema.required) {
+                if (objectKeys.includes(requiredKey))
+                    continue;
+                yield { type: ValueErrorType.ObjectRequiredProperties, schema: schema.properties[requiredKey], path: `${path}/${requiredKey}`, value: undefined, message: `Expected required property` };
+            }
+        }
+        if (typeof schema.additionalProperties === 'object') {
+            for (const objectKey of globalThis.Object.keys(value)) {
+                if (propertyKeys.includes(objectKey))
+                    continue;
+                yield* Visit(schema.additionalProperties, references, `${path}/${objectKey}`, value[objectKey]);
+            }
+        }
         for (const propertyKey of propertyKeys) {
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {

package/guard/guard.js

@@ -89,6 +89,9 @@ var TypeGuard;
     function IsOptionalFormat(value) {
         return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
     }
+    function IsOptionalSchema(value) {
+        return value === undefined || TSchema(value);
+    }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
         return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id);
@@ -194,7 +197,7 @@ var TypeGuard;
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
             IsObject(schema.properties) &&
-            IsOptionalBoolean(schema.additionalProperties) &&
+            (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
             IsOptionalNumber(schema.minProperties) &&
             IsOptionalNumber(schema.maxProperties))) {
             return false;

package/package.json

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

package/readme.md

@@ -1062,29 +1062,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    384 ms' │ '      9 ms' │ '   42.67 x' │
-│           String │    2000    │ '    322 ms' │ '      8 ms' │ '   40.25 x' │
-│          Boolean │    2000    │ '    310 ms' │ '      6 ms' │ '   51.67 x' │
-│             Null │    2000    │ '    271 ms' │ '      6 ms' │ '   45.17 x' │
-│            RegEx │    2000    │ '    491 ms' │ '     12 ms' │ '   40.92 x' │
-│          ObjectA │    2000    │ '   2935 ms' │ '     44 ms' │ '   66.70 x' │
-│          ObjectB │    2000    │ '   3076 ms' │ '     30 ms' │ '  102.53 x' │
-│            Tuple │    2000    │ '   1274 ms' │ '     22 ms' │ '   57.91 x' │
-│            Union │    2000    │ '   1281 ms' │ '     22 ms' │ '   58.23 x' │
-│          Vector4 │    2000    │ '   1602 ms' │ '     17 ms' │ '   94.24 x' │
-│          Matrix4 │    2000    │ '    959 ms' │ '     10 ms' │ '   95.90 x' │
-│   Literal_String │    2000    │ '    337 ms' │ '      6 ms' │ '   56.17 x' │
-│   Literal_Number │    2000    │ '    376 ms' │ '      5 ms' │ '   75.20 x' │
-│  Literal_Boolean │    2000    │ '    370 ms' │ '      5 ms' │ '   74.00 x' │
-│     Array_Number │    2000    │ '    733 ms' │ '      9 ms' │ '   81.44 x' │
-│     Array_String │    2000    │ '    764 ms' │ '     10 ms' │ '   76.40 x' │
-│    Array_Boolean │    2000    │ '    818 ms' │ '      6 ms' │ '  136.33 x' │
-│    Array_ObjectA │    2000    │ '   3744 ms' │ '     35 ms' │ '  106.97 x' │
-│    Array_ObjectB │    2000    │ '   3893 ms' │ '     34 ms' │ '  114.50 x' │
-│      Array_Tuple │    2000    │ '   2229 ms' │ '     16 ms' │ '  139.31 x' │
-│      Array_Union │    2000    │ '   1705 ms' │ '     18 ms' │ '   94.72 x' │
-│    Array_Vector4 │    2000    │ '   2261 ms' │ '     17 ms' │ '  133.00 x' │
-│    Array_Matrix4 │    2000    │ '   1574 ms' │ '     14 ms' │ '  112.43 x' │
+│           Number │    2000    │ '    428 ms' │ '     12 ms' │ '   35.67 x' │
+│           String │    2000    │ '    337 ms' │ '     12 ms' │ '   28.08 x' │
+│          Boolean │    2000    │ '    317 ms' │ '     11 ms' │ '   28.82 x' │
+│             Null │    2000    │ '    274 ms' │ '     10 ms' │ '   27.40 x' │
+│            RegEx │    2000    │ '    500 ms' │ '     18 ms' │ '   27.78 x' │
+│          ObjectA │    2000    │ '   2717 ms' │ '     49 ms' │ '   55.45 x' │
+│          ObjectB │    2000    │ '   2854 ms' │ '     37 ms' │ '   77.14 x' │
+│            Tuple │    2000    │ '   1224 ms' │ '     21 ms' │ '   58.29 x' │
+│            Union │    2000    │ '   1266 ms' │ '     23 ms' │ '   55.04 x' │
+│          Vector4 │    2000    │ '   1513 ms' │ '     19 ms' │ '   79.63 x' │
+│          Matrix4 │    2000    │ '    841 ms' │ '     12 ms' │ '   70.08 x' │
+│   Literal_String │    2000    │ '    327 ms' │ '      8 ms' │ '   40.88 x' │
+│   Literal_Number │    2000    │ '    358 ms' │ '      6 ms' │ '   59.67 x' │
+│  Literal_Boolean │    2000    │ '    355 ms' │ '      5 ms' │ '   71.00 x' │
+│     Array_Number │    2000    │ '    685 ms' │ '      7 ms' │ '   97.86 x' │
+│     Array_String │    2000    │ '    716 ms' │ '     11 ms' │ '   65.09 x' │
+│    Array_Boolean │    2000    │ '    732 ms' │ '      6 ms' │ '  122.00 x' │
+│    Array_ObjectA │    2000    │ '   3503 ms' │ '     34 ms' │ '  103.03 x' │
+│    Array_ObjectB │    2000    │ '   3626 ms' │ '     38 ms' │ '   95.42 x' │
+│      Array_Tuple │    2000    │ '   2095 ms' │ '     21 ms' │ '   99.76 x' │
+│      Array_Union │    2000    │ '   1577 ms' │ '     22 ms' │ '   71.68 x' │
+│    Array_Vector4 │    2000    │ '   2172 ms' │ '     17 ms' │ '  127.76 x' │
+│    Array_Matrix4 │    2000    │ '   1468 ms' │ '     19 ms' │ '   77.26 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1098,31 +1098,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     37 ms' │ '      5 ms' │ '      5 ms' │ '    1.00 x' │
-│           String │  1000000   │ '     31 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
-│          Boolean │  1000000   │ '     25 ms' │ '     25 ms' │ '     11 ms' │ '    2.27 x' │
-│             Null │  1000000   │ '     32 ms' │ '     26 ms' │ '     10 ms' │ '    2.60 x' │
-│            RegEx │  1000000   │ '    170 ms' │ '     48 ms' │ '     35 ms' │ '    1.37 x' │
-│          ObjectA │  1000000   │ '    564 ms' │ '     36 ms' │ '     23 ms' │ '    1.57 x' │
-│          ObjectB │  1000000   │ '   1000 ms' │ '     56 ms' │ '     40 ms' │ '    1.40 x' │
-│            Tuple │  1000000   │ '    125 ms' │ '     27 ms' │ '     13 ms' │ '    2.08 x' │
-│            Union │  1000000   │ '    316 ms' │ '     27 ms' │ '     14 ms' │ '    1.93 x' │
-│        Recursive │  1000000   │ '   3308 ms' │ '    415 ms' │ '    183 ms' │ '    2.27 x' │
-│          Vector4 │  1000000   │ '    135 ms' │ '     27 ms' │ '     12 ms' │ '    2.25 x' │
-│          Matrix4 │  1000000   │ '    658 ms' │ '     44 ms' │ '     30 ms' │ '    1.47 x' │
-│   Literal_String │  1000000   │ '     48 ms' │ '     26 ms' │ '     10 ms' │ '    2.60 x' │
-│   Literal_Number │  1000000   │ '     49 ms' │ '     31 ms' │ '      9 ms' │ '    3.44 x' │
-│  Literal_Boolean │  1000000   │ '     47 ms' │ '     28 ms' │ '     10 ms' │ '    2.80 x' │
-│     Array_Number │  1000000   │ '    418 ms' │ '     38 ms' │ '     17 ms' │ '    2.24 x' │
-│     Array_String │  1000000   │ '    466 ms' │ '     35 ms' │ '     22 ms' │ '    1.59 x' │
-│    Array_Boolean │  1000000   │ '    403 ms' │ '     41 ms' │ '     24 ms' │ '    1.71 x' │
-│    Array_ObjectA │  1000000   │ '  13596 ms' │ '   2861 ms' │ '   1759 ms' │ '    1.63 x' │
-│    Array_ObjectB │  1000000   │ '  15767 ms' │ '   2798 ms' │ '   1991 ms' │ '    1.41 x' │
-│      Array_Tuple │  1000000   │ '   1666 ms' │ '    103 ms' │ '     73 ms' │ '    1.41 x' │
-│      Array_Union │  1000000   │ '   4738 ms' │ '    229 ms' │ '     87 ms' │ '    2.63 x' │
-│  Array_Recursive │  1000000   │ '  56371 ms' │ '   7315 ms' │ '   2813 ms' │ '    2.60 x' │
-│    Array_Vector4 │  1000000   │ '   2180 ms' │ '    106 ms' │ '     53 ms' │ '    2.00 x' │
-│    Array_Matrix4 │  1000000   │ '  11795 ms' │ '    384 ms' │ '    313 ms' │ '    1.23 x' │
+│           Number │  1000000   │ '     24 ms' │ '      9 ms' │ '      6 ms' │ '    1.50 x' │
+│           String │  1000000   │ '     23 ms' │ '     19 ms' │ '     12 ms' │ '    1.58 x' │
+│          Boolean │  1000000   │ '     24 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│             Null │  1000000   │ '     23 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│            RegEx │  1000000   │ '    164 ms' │ '     46 ms' │ '     38 ms' │ '    1.21 x' │
+│          ObjectA │  1000000   │ '    548 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
+│          ObjectB │  1000000   │ '   1118 ms' │ '     51 ms' │ '     38 ms' │ '    1.34 x' │
+│            Tuple │  1000000   │ '    136 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
+│            Union │  1000000   │ '    338 ms' │ '     27 ms' │ '     16 ms' │ '    1.69 x' │
+│        Recursive │  1000000   │ '   3251 ms' │ '    416 ms' │ '     98 ms' │ '    4.24 x' │
+│          Vector4 │  1000000   │ '    146 ms' │ '     23 ms' │ '     12 ms' │ '    1.92 x' │
+│          Matrix4 │  1000000   │ '    584 ms' │ '     40 ms' │ '     25 ms' │ '    1.60 x' │
+│   Literal_String │  1000000   │ '     46 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
+│  Literal_Boolean │  1000000   │ '     47 ms' │ '     21 ms' │ '     10 ms' │ '    2.10 x' │
+│     Array_Number │  1000000   │ '    456 ms' │ '     31 ms' │ '     19 ms' │ '    1.63 x' │
+│     Array_String │  1000000   │ '    489 ms' │ '     40 ms' │ '     25 ms' │ '    1.60 x' │
+│    Array_Boolean │  1000000   │ '    458 ms' │ '     35 ms' │ '     27 ms' │ '    1.30 x' │
+│    Array_ObjectA │  1000000   │ '  13559 ms' │ '   2568 ms' │ '   1564 ms' │ '    1.64 x' │
+│    Array_ObjectB │  1000000   │ '  15863 ms' │ '   2744 ms' │ '   2060 ms' │ '    1.33 x' │
+│      Array_Tuple │  1000000   │ '   1694 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
+│      Array_Union │  1000000   │ '   4736 ms' │ '    229 ms' │ '     86 ms' │ '    2.66 x' │
+│  Array_Recursive │  1000000   │ '  53804 ms' │ '   6744 ms' │ '   1167 ms' │ '    5.78 x' │
+│    Array_Vector4 │  1000000   │ '   2244 ms' │ '     99 ms' │ '     46 ms' │ '    2.15 x' │
+│    Array_Matrix4 │  1000000   │ '  11966 ms' │ '    378 ms' │ '    229 ms' │ '    1.65 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1136,11 +1136,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   49 kb' │ '   24 kb' │  '2.00 x'   │
+│ typebox/compiler     │ '   51 kb' │ '   25 kb' │  '2.00 x'   │
 │ typebox/conditional  │ '   42 kb' │ '   17 kb' │  '2.46 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
-│ typebox/guard        │ '   21 kb' │ '   10 kb' │  '2.07 x'   │
-│ typebox/value        │ '   72 kb' │ '   33 kb' │  '2.16 x'   │
+│ typebox/guard        │ '   21 kb' │ '   10 kb' │  '2.08 x'   │
+│ typebox/value        │ '   74 kb' │ '   34 kb' │  '2.16 x'   │
 │ typebox              │ '   11 kb' │ '    6 kb' │  '1.91 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```

package/typebox.d.ts

@@ -177,14 +177,16 @@ export interface TProperties {
 }
 export declare type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
 export declare type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
-export interface ObjectOptions extends SchemaOptions {
-    additionalProperties?: boolean;
+export declare type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions<A extends TAdditionalProperties = undefined> extends SchemaOptions {
+    additionalProperties?: A;
     minProperties?: number;
     maxProperties?: number;
 }
-export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+export interface TObject<T extends TProperties = TProperties, A extends TAdditionalProperties = undefined> extends TSchema, ObjectOptions<A> {
     [Kind]: 'Object';
-    static: PropertiesReduce<T, this['params']>;
+    static: A extends TSchema ? PropertiesReduce<T, this['params']> & Record<string, Static<A, ['params']>> : PropertiesReduce<T, this['params']>;
+    additionalProperties?: A;
     type: 'object';
     properties: T;
     required?: string[];
@@ -349,7 +351,7 @@ export declare class TypeBuilder {
     /** Creates a number type */
     Number(options?: NumericOptions): TNumber;
     /** Creates an object type with the given properties */
-    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+    Object<T extends TProperties, A extends TAdditionalProperties = undefined>(properties: T, options?: ObjectOptions<A>): TObject<T, A>;
     /** Creates a new object whose properties are omitted from the given object */
     Omit<T extends TObject, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: ObjectOptions): TOmit<T, UnionStringLiteralToTuple<K>>;
     /** Creates a new object whose properties are omitted from the given object */

package/value/cast.js

@@ -230,6 +230,15 @@ var ValueCast;
                 continue;
             result[key] = Visit(property, references, value[key]);
         }
+        // additional schema properties
+        if (typeof schema.additionalProperties === 'object') {
+            const propertyKeys = globalThis.Object.keys(schema.properties);
+            for (const objectKey of globalThis.Object.keys(value)) {
+                if (propertyKeys.includes(objectKey))
+                    continue;
+                result[objectKey] = Visit(schema.additionalProperties, references, value[objectKey]);
+            }
+        }
         return result;
     }
     function Promise(schema, references, value) {

package/value/check.js

@@ -145,6 +145,15 @@ var ValueCheck;
                 }
             }
         }
+        if (typeof schema.additionalProperties === 'object') {
+            for (const objectKey of globalThis.Object.keys(value)) {
+                if (propertyKeys.includes(objectKey))
+                    continue;
+                if (!Visit(schema.additionalProperties, references, value[objectKey])) {
+                    return false;
+                }
+            }
+        }
         for (const propertyKey of propertyKeys) {
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {