@sinclair/typebox 0.24.19 → 0.24.22

package/compiler/compiler.js

@@ -29,6 +29,7 @@ THE SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeCompiler = exports.TypeCheck = void 0;
 const errors_1 = require("../value/errors");
+const property_1 = require("./property");
 const Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -61,13 +62,13 @@ exports.TypeCheck = TypeCheck;
 var TypeCompiler;
 (function (TypeCompiler) {
     // -------------------------------------------------------------------
-    // Schemas
+    // Types
     // -------------------------------------------------------------------
     function* Any(schema, value) {
         yield '(true)';
     }
     function* Array(schema, value) {
-        const expression = [...Visit(schema.items, `value`)].map((condition) => condition).join(' && ');
+        const expression = CreateExpression(schema.items, 'value');
         if (schema.minItems !== undefined)
             yield `(${value}.length >= ${schema.minItems})`;
         if (schema.maxItems !== undefined)
@@ -143,13 +144,14 @@ var TypeCompiler;
             }
         }
         for (const propertyKey of propertyKeys) {
+            const memberExpression = property_1.Property.Check(propertyKey) ? `${value}.${propertyKey}` : `${value}['${propertyKey}']`;
             const propertySchema = schema.properties[propertyKey];
             if (schema.required && schema.required.includes(propertyKey)) {
-                yield* Visit(propertySchema, `${value}.${propertyKey}`);
+                yield* Visit(propertySchema, memberExpression);
             }
             else {
-                const expr = [...Visit(propertySchema, `${value}.${propertyKey}`)].map((condition) => condition).join(' && ');
-                yield `(${value}.${propertyKey} === undefined ? true : (${expr}))`;
+                const expression = CreateExpression(propertySchema, memberExpression);
+                yield `(${memberExpression} === undefined ? true : (${expression}))`;
             }
         }
     }
@@ -159,25 +161,16 @@ var TypeCompiler;
     function* Record(schema, value) {
         yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const local = PushLocal(`const local = new RegExp(/${keyPattern}/)`);
+        const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.keys(${value}).every(key => ${local}.test(key)))`;
-        const expr = [...Visit(valueSchema, 'value')].map((condition) => condition).join(' && ');
-        yield `(Object.values(${value}).every(value => ${expr}))`;
+        const expression = CreateExpression(valueSchema, 'value');
+        yield `(Object.values(${value}).every(value => ${expression}))`;
     }
     function* Ref(schema, value) {
-        // 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 review.
-        if (!functionNames.has(schema.$ref)) {
-            const reference = referenceMap.get(schema.$ref);
-            functionNames.add(schema.$ref);
-            const conditions = [...Visit(reference, 'value')];
-            const name = CreateFunctionName(schema.$ref);
-            const body = CreateFunction(name, conditions);
-            PushLocal(body);
-        }
-        const func = CreateFunctionName(schema.$ref);
-        yield `(${func}(${value}))`;
+        if (!referenceMap.has(schema.$ref))
+            throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
+        const reference = referenceMap.get(schema.$ref);
+        yield* Visit(reference, value);
     }
     function* Self(schema, value) {
         const func = CreateFunctionName(schema.$ref);
@@ -192,7 +185,7 @@ var TypeCompiler;
             yield `(${value}.length <= ${schema.maxLength})`;
         }
         if (schema.pattern !== undefined) {
-            const local = PushLocal(`const local = new RegExp(/${schema.pattern}/);`);
+            const local = PushLocal(`new RegExp(/${schema.pattern}/);`);
             yield `(${local}.test(${value}))`;
         }
     }
@@ -202,16 +195,16 @@ var TypeCompiler;
             return yield `(${value}.length === 0)`;
         yield `(${value}.length === ${schema.maxItems})`;
         for (let i = 0; i < schema.items.length; i++) {
-            const expr = [...Visit(schema.items[i], `${value}[${i}]`)].map((condition) => condition).join(' && ');
-            yield `(${expr})`;
+            const expression = CreateExpression(schema.items[i], `${value}[${i}]`);
+            yield `(${expression})`;
         }
     }
     function* Undefined(schema, value) {
         yield `(${value} === undefined)`;
     }
     function* Union(schema, value) {
-        const exprs = schema.anyOf.map((schema) => [...Visit(schema, value)].map((condition) => condition).join(' && '));
-        yield `(${exprs.join(' || ')})`;
+        const expressions = schema.anyOf.map((schema) => CreateExpression(schema, value));
+        yield `(${expressions.join(' || ')})`;
     }
     function* Uint8Array(schema, value) {
         yield `(${value} instanceof Uint8Array)`;
@@ -230,12 +223,11 @@ var TypeCompiler;
         // 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 review.
-        if (schema.$id && !functionNames.has(schema.$id)) {
-            functionNames.add(schema.$id);
-            const conditions = [...Visit(schema, 'value')];
+        if (schema.$id && !names.has(schema.$id)) {
+            names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
-            const body = CreateFunction(name, conditions);
-            PushLocal(body);
+            const body = CreateFunction(name, schema, 'value');
+            PushFunction(body);
             yield `(${name}(${value}))`;
             return;
         }
@@ -288,17 +280,17 @@ var TypeCompiler;
         }
     }
     // -------------------------------------------------------------------
-    // Locals
+    // Compile State
     // -------------------------------------------------------------------
     const referenceMap = new Map();
-    const functionLocals = new Set();
-    const functionNames = new Set();
-    function ClearLocals() {
-        functionLocals.clear();
-        functionNames.clear();
+    const locals = new Set(); // local variables and functions
+    const names = new Set(); // cache of local functions
+    function ResetCompiler() {
         referenceMap.clear();
+        locals.clear();
+        names.clear();
     }
-    function PushReferences(schemas = []) {
+    function AddReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
                 throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
@@ -307,33 +299,36 @@ var TypeCompiler;
             referenceMap.set(schema.$id, schema);
         }
     }
-    function PushLocal(code) {
-        const name = `local${functionLocals.size}`;
-        functionLocals.add(code.replace('local', name));
-        return name;
-    }
-    function GetLocals() {
-        return [...functionLocals.values()];
+    function CreateExpression(schema, value) {
+        return [...Visit(schema, value)].join(' && ');
     }
-    // -------------------------------------------------------------------
-    // Functions
-    // -------------------------------------------------------------------
     function CreateFunctionName($id) {
         return `check_${$id.replace(/-/g, '_')}`;
     }
-    function CreateFunction(name, conditions) {
-        const expression = conditions.map((condition) => `    ${condition}`).join(' &&\n');
+    function CreateFunction(name, schema, value) {
+        const expression = [...Visit(schema, value)].map((condition) => `    ${condition}`).join(' &&\n');
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
+    function PushFunction(functionBody) {
+        locals.add(functionBody);
+    }
+    function PushLocal(expression) {
+        const local = `local_${locals.size}`;
+        locals.add(`const ${local} = ${expression}`);
+        return local;
+    }
+    function GetLocals() {
+        return [...locals.values()];
+    }
     // -------------------------------------------------------------------
     // Compile
     // -------------------------------------------------------------------
     function Build(schema, references = []) {
-        ClearLocals();
-        PushReferences(references);
-        const conditions = [...Visit(schema, 'value')]; // locals populated during yield
+        ResetCompiler();
+        AddReferences(references);
+        const check = CreateFunction('check', schema, 'value');
         const locals = GetLocals();
-        return `${locals.join('\n')}\nreturn ${CreateFunction('check', conditions)}`;
+        return `${locals.join('\n')}\nreturn ${check}`;
     }
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile(schema, references = []) {

package/compiler/property.d.ts

@@ -0,0 +1,4 @@
+export declare namespace Property {
+    /** Tests if this property name can be used in a member expression */
+    function Check(propertyName: string): boolean;
+}

package/compiler/property.js

@@ -0,0 +1,64 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/compiler
+
+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.Property = void 0;
+var Property;
+(function (Property) {
+    function DollarSign(char) {
+        return char === 36;
+    }
+    function Underscore(char) {
+        return char === 95;
+    }
+    function Numeric(char) {
+        return char >= 48 && char <= 57;
+    }
+    function Alpha(char) {
+        return (char >= 65 && char <= 90) || (char >= 97 && char <= 122);
+    }
+    /** Tests if this property name can be used in a member expression */
+    function Check(propertyName) {
+        if (propertyName.length === 0)
+            return false;
+        {
+            const code = propertyName.charCodeAt(0);
+            if (!(DollarSign(code) || Underscore(code) || Alpha(code))) {
+                return false;
+            }
+        }
+        for (let i = 1; i < propertyName.length; i++) {
+            const code = propertyName.charCodeAt(i);
+            if (!(DollarSign(code) || Underscore(code) || Alpha(code) || Numeric(code))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Property.Check = Check;
+})(Property = exports.Property || (exports.Property = {}));

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.19",
+  "version": "0.24.22",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
-    "json-schema",
     "typescript",
-    "static-types",
-    "runtime-typechecking"
+    "json-schema",
+    "validate",
+    "typecheck"
   ],
   "author": "sinclairzx81",
   "license": "MIT",

package/readme.md

@@ -114,9 +114,9 @@ const T = Type.Object({                              // const T = {
                                                      //     }
                                                      //   }, 
                                                      //   required: [
-                                                     //     "id",
-                                                     //     "name",
-                                                     //     "timestamp"
+                                                     //     'id',
+                                                     //     'name',
+                                                     //     'timestamp'
                                                      //   ]
                                                      // } 
 
@@ -528,7 +528,7 @@ function test(node: Node) {
 
 ## Generic Types
 
-Generic types can be created using functions. The following creates a generic `Nullable<T>` type. 
+Use functions to create generic types. The following creates a generic `Nullable<T>` type. 
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -594,12 +594,12 @@ type T = Static<typeof T>                            // type T = string | null
 
 //--------------------------------------------------------------------------------------------
 //
-// StringUnion<[...]>
+// StringEnum<string[]>
 //
 //--------------------------------------------------------------------------------------------
 
 function StringEnum<T extends string[]>(values: [...T]) {
-  return Type.Unsafe<T[number]>({ enum: values })
+  return Type.Unsafe<T[number]>({ type: 'string', enum: values })
 }
 
 const T = StringEnum(['A', 'B', 'C'])                // const T = {
@@ -876,7 +876,7 @@ console.log(C.Code())                                // return function check(va
 
 ## Benchmark
 
-This project maintains benchmarks that measure Ajv and TypeCompiler validation and compilation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. Results show against Ajv version 8.11.0.
+This project maintains benchmarks that measure Ajv and TypeCompiler validate and compile performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. Results show against Ajv version 8.11.0.
 
 ### Validate
 
@@ -886,31 +886,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  16000000  │ '     73 ms' │ '     65 ms' │ '    1.12 x' │
-│           String │  16000000  │ '    281 ms' │ '    161 ms' │ '    1.75 x' │
-│          Boolean │  16000000  │ '    302 ms' │ '    151 ms' │ '    2.00 x' │
-│             Null │  16000000  │ '    281 ms' │ '    149 ms' │ '    1.89 x' │
-│            RegEx │  16000000  │ '    689 ms' │ '    550 ms' │ '    1.25 x' │
-│          ObjectA │  16000000  │ '    470 ms' │ '    311 ms' │ '    1.51 x' │
-│          ObjectB │  16000000  │ '    667 ms' │ '    556 ms' │ '    1.20 x' │
-│            Tuple │  16000000  │ '    362 ms' │ '    190 ms' │ '    1.91 x' │
-│            Union │  16000000  │ '    387 ms' │ '    209 ms' │ '    1.85 x' │
-│        Recursive │  16000000  │ '   6327 ms' │ '   2773 ms' │ '    2.28 x' │
-│          Vector4 │  16000000  │ '    362 ms' │ '    172 ms' │ '    2.10 x' │
-│          Matrix4 │  16000000  │ '    607 ms' │ '    418 ms' │ '    1.45 x' │
-│   Literal_String │  16000000  │ '    314 ms' │ '    151 ms' │ '    2.08 x' │
-│   Literal_Number │  16000000  │ '    281 ms' │ '    147 ms' │ '    1.91 x' │
-│  Literal_Boolean │  16000000  │ '    289 ms' │ '    148 ms' │ '    1.95 x' │
-│     Array_Number │  16000000  │ '    475 ms' │ '    230 ms' │ '    2.07 x' │
-│     Array_String │  16000000  │ '    463 ms' │ '    297 ms' │ '    1.56 x' │
-│    Array_Boolean │  16000000  │ '    521 ms' │ '    348 ms' │ '    1.50 x' │
-│    Array_ObjectA │  16000000  │ '  43842 ms' │ '  28375 ms' │ '    1.55 x' │
-│    Array_ObjectB │  16000000  │ '  45055 ms' │ '  32882 ms' │ '    1.37 x' │
-│      Array_Tuple │  16000000  │ '   1424 ms' │ '   1105 ms' │ '    1.29 x' │
-│      Array_Union │  16000000  │ '   3505 ms' │ '   1350 ms' │ '    2.60 x' │
-│  Array_Recursive │  16000000  │ ' 117087 ms' │ '  42982 ms' │ '    2.72 x' │
-│    Array_Vector4 │  16000000  │ '   1500 ms' │ '    817 ms' │ '    1.84 x' │
-│    Array_Matrix4 │  16000000  │ '   6126 ms' │ '   4965 ms' │ '    1.23 x' │
+│           Number │  4000000   │ '     17 ms' │ '     16 ms' │ '    1.06 x' │
+│           String │  4000000   │ '     74 ms' │ '     37 ms' │ '    2.00 x' │
+│          Boolean │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
+│             Null │  4000000   │ '     68 ms' │ '     36 ms' │ '    1.89 x' │
+│            RegEx │  4000000   │ '    170 ms' │ '    143 ms' │ '    1.19 x' │
+│          ObjectA │  4000000   │ '    122 ms' │ '     84 ms' │ '    1.45 x' │
+│          ObjectB │  4000000   │ '    182 ms' │ '    137 ms' │ '    1.33 x' │
+│            Tuple │  4000000   │ '     82 ms' │ '     48 ms' │ '    1.71 x' │
+│            Union │  4000000   │ '     84 ms' │ '     52 ms' │ '    1.62 x' │
+│        Recursive │  4000000   │ '   1526 ms' │ '    631 ms' │ '    2.42 x' │
+│          Vector4 │  4000000   │ '     80 ms' │ '     42 ms' │ '    1.90 x' │
+│          Matrix4 │  4000000   │ '    157 ms' │ '    113 ms' │ '    1.39 x' │
+│   Literal_String │  4000000   │ '     69 ms' │ '     36 ms' │ '    1.92 x' │
+│   Literal_Number │  4000000   │ '     69 ms' │ '     35 ms' │ '    1.97 x' │
+│  Literal_Boolean │  4000000   │ '     68 ms' │ '     35 ms' │ '    1.94 x' │
+│     Array_Number │  4000000   │ '    119 ms' │ '     60 ms' │ '    1.98 x' │
+│     Array_String │  4000000   │ '    119 ms' │ '     76 ms' │ '    1.57 x' │
+│    Array_Boolean │  4000000   │ '    131 ms' │ '     88 ms' │ '    1.49 x' │
+│    Array_ObjectA │  4000000   │ '  10615 ms' │ '   7053 ms' │ '    1.51 x' │
+│    Array_ObjectB │  4000000   │ '  11305 ms' │ '   8128 ms' │ '    1.39 x' │
+│      Array_Tuple │  4000000   │ '    355 ms' │ '    271 ms' │ '    1.31 x' │
+│      Array_Union │  4000000   │ '    910 ms' │ '    340 ms' │ '    2.68 x' │
+│  Array_Recursive │  4000000   │ '  29101 ms' │ '  10837 ms' │ '    2.69 x' │
+│    Array_Vector4 │  4000000   │ '    381 ms' │ '    212 ms' │ '    1.80 x' │
+│    Array_Matrix4 │  4000000   │ '   1534 ms' │ '   1344 ms' │ '    1.14 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -922,29 +922,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    387 ms' │ '      7 ms' │ '   55.29 x' │
-│           String │    2000    │ '    340 ms' │ '      6 ms' │ '   56.67 x' │
-│          Boolean │    2000    │ '    314 ms' │ '      5 ms' │ '   62.80 x' │
-│             Null │    2000    │ '    259 ms' │ '      5 ms' │ '   51.80 x' │
-│            RegEx │    2000    │ '    491 ms' │ '      7 ms' │ '   70.14 x' │
-│          ObjectA │    2000    │ '   2850 ms' │ '     26 ms' │ '  109.62 x' │
-│          ObjectB │    2000    │ '   2989 ms' │ '     22 ms' │ '  135.86 x' │
-│            Tuple │    2000    │ '   1283 ms' │ '     17 ms' │ '   75.47 x' │
-│            Union │    2000    │ '   1292 ms' │ '     16 ms' │ '   80.75 x' │
-│          Vector4 │    2000    │ '   1588 ms' │ '     12 ms' │ '  132.33 x' │
-│          Matrix4 │    2000    │ '    934 ms' │ '      7 ms' │ '  133.43 x' │
-│   Literal_String │    2000    │ '    340 ms' │ '      5 ms' │ '   68.00 x' │
-│   Literal_Number │    2000    │ '    402 ms' │ '      4 ms' │ '  100.50 x' │
-│  Literal_Boolean │    2000    │ '    381 ms' │ '      6 ms' │ '   63.50 x' │
-│     Array_Number │    2000    │ '    750 ms' │ '      8 ms' │ '   93.75 x' │
-│     Array_String │    2000    │ '    760 ms' │ '      6 ms' │ '  126.67 x' │
-│    Array_Boolean │    2000    │ '    796 ms' │ '      7 ms' │ '  113.71 x' │
-│    Array_ObjectA │    2000    │ '   3617 ms' │ '     26 ms' │ '  139.12 x' │
-│    Array_ObjectB │    2000    │ '   3823 ms' │ '     26 ms' │ '  147.04 x' │
-│      Array_Tuple │    2000    │ '   2263 ms' │ '     13 ms' │ '  174.08 x' │
-│      Array_Union │    2000    │ '   1725 ms' │ '     16 ms' │ '  107.81 x' │
-│    Array_Vector4 │    2000    │ '   2445 ms' │ '     14 ms' │ '  174.64 x' │
-│    Array_Matrix4 │    2000    │ '   1638 ms' │ '     11 ms' │ '  148.91 x' │
+│           Number │    2000    │ '    384 ms' │ '      7 ms' │ '   54.86 x' │
+│           String │    2000    │ '    311 ms' │ '      6 ms' │ '   51.83 x' │
+│          Boolean │    2000    │ '    304 ms' │ '      5 ms' │ '   60.80 x' │
+│             Null │    2000    │ '    252 ms' │ '      5 ms' │ '   50.40 x' │
+│            RegEx │    2000    │ '    480 ms' │ '      7 ms' │ '   68.57 x' │
+│          ObjectA │    2000    │ '   2786 ms' │ '     27 ms' │ '  103.19 x' │
+│          ObjectB │    2000    │ '   2946 ms' │ '     22 ms' │ '  133.91 x' │
+│            Tuple │    2000    │ '   1277 ms' │ '     16 ms' │ '   79.81 x' │
+│            Union │    2000    │ '   1288 ms' │ '     16 ms' │ '   80.50 x' │
+│          Vector4 │    2000    │ '   1628 ms' │ '     12 ms' │ '  135.67 x' │
+│          Matrix4 │    2000    │ '    912 ms' │ '      7 ms' │ '  130.29 x' │
+│   Literal_String │    2000    │ '    344 ms' │ '      5 ms' │ '   68.80 x' │
+│   Literal_Number │    2000    │ '    432 ms' │ '      5 ms' │ '   86.40 x' │
+│  Literal_Boolean │    2000    │ '    407 ms' │ '      4 ms' │ '  101.75 x' │
+│     Array_Number │    2000    │ '    788 ms' │ '      9 ms' │ '   87.56 x' │
+│     Array_String │    2000    │ '    823 ms' │ '      7 ms' │ '  117.57 x' │
+│    Array_Boolean │    2000    │ '    816 ms' │ '      5 ms' │ '  163.20 x' │
+│    Array_ObjectA │    2000    │ '   4270 ms' │ '     24 ms' │ '  177.92 x' │
+│    Array_ObjectB │    2000    │ '   4008 ms' │ '     28 ms' │ '  143.14 x' │
+│      Array_Tuple │    2000    │ '   2243 ms' │ '     13 ms' │ '  172.54 x' │
+│      Array_Union │    2000    │ '   1734 ms' │ '     16 ms' │ '  108.38 x' │
+│    Array_Vector4 │    2000    │ '   2348 ms' │ '     14 ms' │ '  167.71 x' │
+│    Array_Matrix4 │    2000    │ '   1608 ms' │ '     11 ms' │ '  146.18 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 

package/value/check.js

@@ -201,7 +201,7 @@ var ValueCheck;
         return true;
     }
     function Tuple(schema, references, value) {
-        if (!global.Array.isArray(value)) {
+        if (!globalThis.Array.isArray(value)) {
             return false;
         }
         if (schema.items === undefined && !(value.length === 0)) {

package/value/errors.js

@@ -195,7 +195,7 @@ var ValueErrors;
         }
     }
     function* Tuple(schema, references, path, value) {
-        if (!global.Array.isArray(value)) {
+        if (!globalThis.Array.isArray(value)) {
             return yield { schema, path, value, message: 'Expected Array' };
         }
         if (schema.items === undefined && !(value.length === 0)) {