@sinclair/typebox 0.25.14 → 0.25.16

package/compiler/compiler.js

@@ -29,10 +29,11 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCompilerUnknownTypeError = exports.Property = exports.TypeCheck = void 0;
 const index_1 = require("../errors/index");
-const index_2 = require("../guard/index");
-const index_3 = require("../format/index");
-const index_4 = require("../custom/index");
-const index_5 = require("../hash/index");
+const index_2 = require("../system/index");
+const index_3 = require("../guard/index");
+const index_4 = require("../format/index");
+const index_5 = require("../custom/index");
+const index_6 = require("../hash/index");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -174,7 +175,12 @@ var TypeCompiler;
         yield `(${value} === null)`;
     }
     function* Number(schema, value) {
-        yield `(typeof ${value} === 'number' && !isNaN(${value}))`;
+        if (index_2.TypeSystem.AllowNaN) {
+            yield `(typeof ${value} === 'number')`;
+        }
+        else {
+            yield `(typeof ${value} === 'number' && !isNaN(${value}))`;
+        }
         if (IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf} === 0)`;
         if (IsNumber(schema.exclusiveMinimum))
@@ -187,29 +193,34 @@ var TypeCompiler;
             yield `(${value} <= ${schema.maximum})`;
     }
     function* Object(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
+        if (index_2.TypeSystem.AllowArrayObjects) {
+            yield `(typeof ${value} === 'object' && ${value} !== null)`;
+        }
+        else {
+            yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
+        }
         if (IsNumber(schema.minProperties))
-            yield `(Object.keys(${value}).length >= ${schema.minProperties})`;
+            yield `(Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties})`;
         if (IsNumber(schema.maxProperties))
-            yield `(Object.keys(${value}).length <= ${schema.maxProperties})`;
-        const propertyKeys = globalThis.Object.keys(schema.properties);
+            yield `(Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties})`;
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
         if (schema.additionalProperties === false) {
             // Optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
             if (schema.required && schema.required.length === propertyKeys.length) {
-                yield `(Object.keys(${value}).length === ${propertyKeys.length})`;
+                yield `(Object.getOwnPropertyNames(${value}).length === ${propertyKeys.length})`;
             }
             else {
                 const keys = `[${propertyKeys.map((key) => `'${key}'`).join(', ')}]`;
-                yield `(Object.keys(${value}).every(key => ${keys}.includes(key)))`;
+                yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key)))`;
             }
         }
-        if (index_2.TypeGuard.TSchema(schema.additionalProperties)) {
+        if (index_3.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}))`;
+            yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
         for (const propertyKey of propertyKeys) {
             const memberExpression = Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
@@ -227,10 +238,15 @@ var TypeCompiler;
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
     function* Record(schema, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date))`;
+        if (index_2.TypeSystem.AllowArrayObjects) {
+            yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date))`;
+        }
+        else {
+            yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !Array.isArray(${value}))`;
+        }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
-        yield `(Object.keys(${value}).every(key => ${local}.test(key)))`;
+        yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
         const expression = CreateExpression(valueSchema, 'value');
         yield `(Object.values(${value}).every(value => ${expression}))`;
     }
@@ -359,7 +375,7 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                if (!index_4.Custom.Has(anySchema[Types.Kind]))
+                if (!index_5.Custom.Has(anySchema[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
                 return yield* UserDefined(anySchema, value);
         }
@@ -419,23 +435,23 @@ var TypeCompiler;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {
-        index_2.TypeGuard.Assert(schema, references);
+        index_3.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
         const custom_schemas = new Map(state_remote_custom_types);
         const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
         const checkFunction = compiledFunction((kind, schema_key, value) => {
-            if (!index_4.Custom.Has(kind) || !custom_schemas.has(schema_key))
+            if (!index_5.Custom.Has(kind) || !custom_schemas.has(schema_key))
                 return false;
             const schema = custom_schemas.get(schema_key);
-            const func = index_4.Custom.Get(kind);
+            const func = index_5.Custom.Get(kind);
             return func(schema, value);
         }, (format, value) => {
-            if (!index_3.Format.Has(format))
+            if (!index_4.Format.Has(format))
                 return false;
-            const func = index_3.Format.Get(format);
+            const func = index_4.Format.Get(format);
             return func(value);
         }, (value) => {
-            return index_5.ValueHash.Create(value);
+            return index_6.ValueHash.Create(value);
         });
         return new TypeCheck(schema, references, checkFunction, code);
     }

package/errors/errors.js

@@ -29,9 +29,10 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
 const Types = require("../typebox");
-const index_1 = require("../format/index");
-const index_2 = require("../custom/index");
-const index_3 = require("../hash/index");
+const index_1 = require("../system/index");
+const index_2 = require("../format/index");
+const index_3 = require("../custom/index");
+const index_4 = require("../hash/index");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -116,7 +117,7 @@ var ValueErrors;
         }
         // prettier-ignore
         if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-            const hashed = index_3.ValueHash.Create(element);
+            const hashed = index_4.ValueHash.Create(element);
             if (set.has(hashed)) {
                 return false;
             }
@@ -162,10 +163,7 @@ var ValueErrors;
     }
     function* Integer(schema, references, path, value) {
         if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
-            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
-        }
-        if (!globalThis.Number.isInteger(value)) {
-            yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
+            return yield { type: ValueErrorType.Integer, schema, path, value, message: `Expected integer` };
         }
         if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             yield { type: ValueErrorType.IntegerMultipleOf, schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
@@ -198,8 +196,15 @@ var ValueErrors;
         }
     }
     function* Number(schema, references, path, value) {
-        if (!(typeof value === 'number' && !isNaN(value))) {
-            return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
+        if (index_1.TypeSystem.AllowNaN) {
+            if (!(typeof value === 'number')) {
+                return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
+            }
+        }
+        else {
+            if (!(typeof value === 'number' && !isNaN(value))) {
+                return yield { type: ValueErrorType.Number, schema, path, value, message: `Expected number` };
+            }
         }
         if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             yield { type: ValueErrorType.NumberMultipleOf, schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
@@ -218,39 +223,46 @@ var ValueErrors;
         }
     }
     function* Object(schema, references, path, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+        if (index_1.TypeSystem.AllowArrayObjects) {
+            if (!(typeof value === 'object' && value !== null)) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+        else {
+            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
+        }
+        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             yield { type: ValueErrorType.ObjectMinProperties, schema, path, value, message: `Expected object to have at least ${schema.minProperties} properties` };
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+        if (IsNumber(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 propertyKeys = globalThis.Object.keys(schema.properties);
+        const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties);
         if (schema.additionalProperties === false) {
-            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` };
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (!propertyNames.includes(propertyName)) {
+                    yield { type: ValueErrorType.ObjectAdditionalProperties, schema, path: `${path}/${propertyName}`, value: value[propertyName], message: `Unexpected property` };
                 }
             }
         }
         if (schema.required && schema.required.length > 0) {
-            const objectKeys = globalThis.Object.keys(value);
+            const propertyNames = globalThis.Object.getOwnPropertyNames(value);
             for (const requiredKey of schema.required) {
-                if (objectKeys.includes(requiredKey))
+                if (propertyNames.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))
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (propertyNames.includes(propertyName))
                     continue;
-                yield* Visit(schema.additionalProperties, references, `${path}/${objectKey}`, value[objectKey]);
+                yield* Visit(schema.additionalProperties, references, `${path}/${propertyName}`, value[propertyName]);
             }
         }
-        for (const propertyKey of propertyKeys) {
+        for (const propertyKey of propertyNames) {
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
                 yield* Visit(propertySchema, references, `${path}/${propertyKey}`, value[propertyKey]);
@@ -268,12 +280,19 @@ var ValueErrors;
         }
     }
     function* Record(schema, references, path, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+        if (index_1.TypeSystem.AllowArrayObjects) {
+            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
+        }
+        else {
+            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
+                return yield { type: ValueErrorType.Object, schema, path, value, message: `Expected object` };
+            }
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
             const numeric = keyPattern === '^(0|[1-9][0-9]*)$';
             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';
@@ -312,11 +331,11 @@ var ValueErrors;
             }
         }
         if (schema.format !== undefined) {
-            if (!index_1.Format.Has(schema.format)) {
+            if (!index_2.Format.Has(schema.format)) {
                 yield { type: ValueErrorType.StringFormatUnknown, schema, path, value, message: `Unknown string format '${schema.format}'` };
             }
             else {
-                const format = index_1.Format.Get(schema.format);
+                const format = index_2.Format.Get(schema.format);
                 if (!format(value)) {
                     yield { type: ValueErrorType.StringFormat, schema, path, value, message: `Expected string to match format '${schema.format}'` };
                 }
@@ -378,7 +397,7 @@ var ValueErrors;
         }
     }
     function* UserDefined(schema, references, path, value) {
-        const func = index_2.Custom.Get(schema[Types.Kind]);
+        const func = index_3.Custom.Get(schema[Types.Kind]);
         if (!func(schema, value)) {
             return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
         }
@@ -434,7 +453,7 @@ var ValueErrors;
             case 'Void':
                 return yield* Void(anySchema, anyReferences, path, value);
             default:
-                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                if (!index_3.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueErrorsUnknownTypeError(schema);
                 return yield* UserDefined(anySchema, anyReferences, path, value);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.25.14",
+  "version": "0.25.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -20,6 +20,7 @@
     "./format": "./format/index.js",
     "./guard": "./guard/index.js",
     "./hash": "./hash/index.js",
+    "./system": "./system/index.js",
     "./value": "./value/index.js",
     ".": "./typebox.js"
   },

package/system/index.d.ts

@@ -0,0 +1 @@
+export * from './system';

package/system/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./system"), exports);

package/system/system.d.ts

@@ -0,0 +1,10 @@
+export declare namespace TypeSystem {
+    /**
+     * Sets whether arrays should be treated as kinds of objects. The default is `false`
+     */
+    let AllowArrayObjects: boolean;
+    /**
+     * Sets whether numeric checks should consider NaN a valid number type. The default is `false`
+     */
+    let AllowNaN: boolean;
+}

package/system/system.js

@@ -0,0 +1,41 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/system
+
+The MIT License (MIT)
+
+Copyright (c) 2022 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystem = void 0;
+var TypeSystem;
+(function (TypeSystem) {
+    /**
+     * Sets whether arrays should be treated as kinds of objects. The default is `false`
+     */
+    TypeSystem.AllowArrayObjects = false;
+    /**
+     * Sets whether numeric checks should consider NaN a valid number type. The default is `false`
+     */
+    TypeSystem.AllowNaN = false;
+})(TypeSystem = exports.TypeSystem || (exports.TypeSystem = {}));

package/value/cast.js

@@ -239,11 +239,11 @@ var ValueCast;
         }
         // 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))
+            const propertyNames = globalThis.Object.getOwnPropertyNames(schema.properties);
+            for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
+                if (propertyNames.includes(propertyName))
                     continue;
-                result[objectKey] = Visit(schema.additionalProperties, references, value[objectKey]);
+                result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
             }
         }
         return result;
@@ -256,8 +256,8 @@ var ValueCast;
             return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
             return create_1.ValueCreate.Create(schema, references);
-        const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
-        const subschema = schema.patternProperties[subschemaKey];
+        const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const subschema = schema.patternProperties[subschemaPropertyName];
         const result = {};
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
             result[propKey] = Visit(subschema, references, propValue);

package/value/check.js

@@ -29,9 +29,10 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueCheck = exports.ValueCheckUnknownTypeError = void 0;
 const Types = require("../typebox");
-const index_1 = require("../format/index");
-const index_2 = require("../custom/index");
-const index_3 = require("../hash/index");
+const index_1 = require("../system/index");
+const index_2 = require("../format/index");
+const index_3 = require("../custom/index");
+const index_4 = require("../hash/index");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
@@ -59,7 +60,7 @@ var ValueCheck;
         }
         // prettier-ignore
         if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-            const hashed = index_3.ValueHash.Create(element);
+            const hashed = index_4.ValueHash.Create(element);
             if (set.has(hashed)) {
                 return false;
             }
@@ -102,9 +103,6 @@ var ValueCheck;
         if (!(typeof value === 'number' && globalThis.Number.isInteger(value))) {
             return false;
         }
-        if (!globalThis.Number.isInteger(value)) {
-            return false;
-        }
         if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             return false;
         }
@@ -132,8 +130,15 @@ var ValueCheck;
         return value === null;
     }
     function Number(schema, references, value) {
-        if (!(typeof value === 'number' && !isNaN(value))) {
-            return false;
+        if (index_1.TypeSystem.AllowNaN) {
+            if (!(typeof value === 'number')) {
+                return false;
+            }
+        }
+        else {
+            if (!(typeof value === 'number' && !isNaN(value))) {
+                return false;
+            }
         }
         if (IsNumber(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
             return false;
@@ -153,32 +158,39 @@ var ValueCheck;
         return true;
     }
     function Object(schema, references, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
-            return false;
+        if (index_1.TypeSystem.AllowArrayObjects) {
+            if (!(typeof value === 'object' && value !== null)) {
+                return false;
+            }
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.keys(value).length >= schema.minProperties)) {
+        else {
+            if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value))) {
+                return false;
+            }
+        }
+        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             return false;
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.keys(value).length <= schema.maxProperties)) {
+        if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             return false;
         }
-        const propertyKeys = globalThis.Object.keys(schema.properties);
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
         if (schema.additionalProperties === false) {
             // optimization: If the property key length matches the required keys length
             // then we only need check that the values property key length matches that
             // of the property key length. This is because exhaustive testing for values
             // will occur in subsequent property tests.
-            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.keys(value).length === propertyKeys.length)) {
+            if (schema.required && schema.required.length === propertyKeys.length && !(globalThis.Object.getOwnPropertyNames(value).length === propertyKeys.length)) {
                 return false;
             }
             else {
-                if (!globalThis.Object.keys(value).every((key) => propertyKeys.includes(key))) {
+                if (!globalThis.Object.getOwnPropertyNames(value).every((key) => propertyKeys.includes(key))) {
                     return false;
                 }
             }
         }
         if (typeof schema.additionalProperties === 'object') {
-            for (const objectKey of globalThis.Object.keys(value)) {
+            for (const objectKey of globalThis.Object.getOwnPropertyNames(value)) {
                 if (propertyKeys.includes(objectKey))
                     continue;
                 if (!Visit(schema.additionalProperties, references, value[objectKey])) {
@@ -207,12 +219,19 @@ var ValueCheck;
         return typeof value === 'object' && typeof value.then === 'function';
     }
     function Record(schema, references, value) {
-        if (!(typeof value === 'object' && value !== null && !globalThis.Array.isArray(value) && !(value instanceof globalThis.Date))) {
-            return false;
+        if (index_1.TypeSystem.AllowArrayObjects) {
+            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date))) {
+                return false;
+            }
+        }
+        else {
+            if (!(typeof value === 'object' && value !== null && !(value instanceof globalThis.Date) && !globalThis.Array.isArray(value))) {
+                return false;
+            }
         }
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const regex = new RegExp(keyPattern);
-        if (!globalThis.Object.keys(value).every((key) => regex.test(key))) {
+        if (!globalThis.Object.getOwnPropertyNames(value).every((key) => regex.test(key))) {
             return false;
         }
         for (const propValue of globalThis.Object.values(value)) {
@@ -251,9 +270,9 @@ var ValueCheck;
                 return false;
         }
         if (schema.format !== undefined) {
-            if (!index_1.Format.Has(schema.format))
+            if (!index_2.Format.Has(schema.format))
                 return false;
-            const func = index_1.Format.Get(schema.format);
+            const func = index_2.Format.Get(schema.format);
             return func(value);
         }
         return true;
@@ -302,9 +321,9 @@ var ValueCheck;
         return value === null;
     }
     function UserDefined(schema, references, value) {
-        if (!index_2.Custom.Has(schema[Types.Kind]))
+        if (!index_3.Custom.Has(schema[Types.Kind]))
             return false;
-        const func = index_2.Custom.Get(schema[Types.Kind]);
+        const func = index_3.Custom.Get(schema[Types.Kind]);
         return func(schema, value);
     }
     function Visit(schema, references, value) {
@@ -358,7 +377,7 @@ var ValueCheck;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                if (!index_2.Custom.Has(anySchema[Types.Kind]))
+                if (!index_3.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCheckUnknownTypeError(anySchema);
                 return UserDefined(anySchema, anyReferences, value);
         }