@sinclair/typebox 0.25.10 → 0.25.11

package/compiler/compiler.js

@@ -32,6 +32,7 @@ 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 Types = require("../typebox");
 // -------------------------------------------------------------------
 // TypeCheck
@@ -117,13 +118,13 @@ var TypeCompiler;
     }
     function* Array(schema, value) {
         const expression = CreateExpression(schema.items, 'value');
+        yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`;
         if (IsNumber(schema.minItems))
             yield `(${value}.length >= ${schema.minItems})`;
         if (IsNumber(schema.maxItems))
             yield `(${value}.length <= ${schema.maxItems})`;
         if (schema.uniqueItems === true)
-            yield `(new Set(${value}).size === ${value}.length)`;
-        yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`;
+            yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
     }
     function* Boolean(schema, value) {
         yield `(typeof ${value} === 'boolean')`;
@@ -421,7 +422,7 @@ var TypeCompiler;
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
         const custom_schemas = new Map(state_remote_custom_types);
-        const compiledFunction = globalThis.Function('custom', 'format', code);
+        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))
                 return false;
@@ -433,6 +434,8 @@ var TypeCompiler;
                 return false;
             const func = index_3.Format.Get(format);
             return func(value);
+        }, (value) => {
+            return index_5.ValueHash.Create(value);
         });
         return new TypeCheck(schema, references, checkFunction, code);
     }

package/errors/errors.js

@@ -31,6 +31,7 @@ exports.ValueErrors = exports.ValueErrorsUnknownTypeError = exports.ValueErrorTy
 const Types = require("../typebox");
 const index_1 = require("../format/index");
 const index_2 = require("../custom/index");
+const index_3 = require("../hash/index");
 // -------------------------------------------------------------------
 // ValueErrorType
 // -------------------------------------------------------------------
@@ -113,7 +114,16 @@ var ValueErrors;
         if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
             yield { type: ValueErrorType.ArrayMinItems, schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
         }
-        if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+        // prettier-ignore
+        if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
+            const hashed = index_3.ValueHash.Create(element);
+            if (set.has(hashed)) {
+                return false;
+            }
+            else {
+                set.add(hashed);
+            }
+        } return true; })())) {
             yield { type: ValueErrorType.ArrayUniqueItems, schema, path, value, message: `Expected array elements to be unique` };
         }
         for (let i = 0; i < value.length; i++) {

package/hash/hash.d.ts

@@ -0,0 +1,8 @@
+export declare class ValueHashError extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare namespace ValueHash {
+    /** Creates a FNV1A-64 non cryptographic hash of the given value */
+    function Create(value: unknown): bigint;
+}

package/hash/hash.js

@@ -0,0 +1,183 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/hash
+
+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.ValueHash = exports.ValueHashError = void 0;
+class ValueHashError extends Error {
+    constructor(value) {
+        super(`Hash: Unable to hash value`);
+        this.value = value;
+    }
+}
+exports.ValueHashError = ValueHashError;
+var ValueHash;
+(function (ValueHash) {
+    let ByteMarker;
+    (function (ByteMarker) {
+        ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
+        ByteMarker[ByteMarker["Null"] = 1] = "Null";
+        ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+        ByteMarker[ByteMarker["Number"] = 3] = "Number";
+        ByteMarker[ByteMarker["String"] = 4] = "String";
+        ByteMarker[ByteMarker["Object"] = 5] = "Object";
+        ByteMarker[ByteMarker["Array"] = 6] = "Array";
+        ByteMarker[ByteMarker["Date"] = 7] = "Date";
+        ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+    })(ByteMarker || (ByteMarker = {}));
+    // ----------------------------------------------------
+    // State
+    // ----------------------------------------------------
+    let Hash = 14695981039346656037n;
+    const [Prime, Size] = [1099511628211n, 2n ** 64n];
+    const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i));
+    const F64 = new globalThis.Float64Array(1);
+    const F64In = new globalThis.DataView(F64.buffer);
+    const F64Out = new globalThis.Uint8Array(F64.buffer);
+    // ----------------------------------------------------
+    // Guards
+    // ----------------------------------------------------
+    function IsDate(value) {
+        return value instanceof globalThis.Date;
+    }
+    function IsUint8Array(value) {
+        return value instanceof globalThis.Uint8Array;
+    }
+    function IsArray(value) {
+        return globalThis.Array.isArray(value);
+    }
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    function IsNull(value) {
+        return value === null;
+    }
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsUndefined(value) {
+        return value === undefined;
+    }
+    // ----------------------------------------------------
+    // Encoding
+    // ----------------------------------------------------
+    function Array(value) {
+        Fnv1A64(ByteMarker.Array);
+        for (const item of value) {
+            Visit(item);
+        }
+    }
+    function Boolean(value) {
+        Fnv1A64(ByteMarker.Boolean);
+        Fnv1A64(value ? 1 : 0);
+    }
+    function Date(value) {
+        Fnv1A64(ByteMarker.Date);
+        Visit(value.getTime());
+    }
+    function Null(value) {
+        Fnv1A64(ByteMarker.Null);
+    }
+    function Number(value) {
+        Fnv1A64(ByteMarker.Number);
+        F64In.setFloat64(0, value);
+        for (const byte of F64Out) {
+            Fnv1A64(byte);
+        }
+    }
+    function Object(value) {
+        Fnv1A64(ByteMarker.Object);
+        for (const key of globalThis.Object.keys(value).sort()) {
+            Visit(key);
+            Visit(value[key]);
+        }
+    }
+    function String(value) {
+        Fnv1A64(ByteMarker.String);
+        for (let i = 0; i < value.length; i++) {
+            Fnv1A64(value.charCodeAt(i));
+        }
+    }
+    function Uint8Array(value) {
+        Fnv1A64(ByteMarker.Uint8Array);
+        for (let i = 0; i < value.length; i++) {
+            Fnv1A64(value[i]);
+        }
+    }
+    function Undefined(value) {
+        return Fnv1A64(ByteMarker.Undefined);
+    }
+    function Visit(value) {
+        if (IsArray(value)) {
+            Array(value);
+        }
+        else if (IsBoolean(value)) {
+            Boolean(value);
+        }
+        else if (IsDate(value)) {
+            Date(value);
+        }
+        else if (IsNull(value)) {
+            Null(value);
+        }
+        else if (IsNumber(value)) {
+            Number(value);
+        }
+        else if (IsObject(value)) {
+            Object(value);
+        }
+        else if (IsString(value)) {
+            String(value);
+        }
+        else if (IsUint8Array(value)) {
+            Uint8Array(value);
+        }
+        else if (IsUndefined(value)) {
+            Undefined(value);
+        }
+        else {
+            throw new ValueHashError(value);
+        }
+    }
+    function Fnv1A64(byte) {
+        Hash = Hash ^ Bytes[byte];
+        Hash = (Hash * Prime) % Size;
+    }
+    /** Creates a FNV1A-64 non cryptographic hash of the given value */
+    function Create(value) {
+        Hash = 14695981039346656037n;
+        Visit(value);
+        return Hash;
+    }
+    ValueHash.Create = Create;
+})(ValueHash = exports.ValueHash || (exports.ValueHash = {}));

package/hash/index.d.ts

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

package/hash/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/hash
+
+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("./hash"), exports);

package/package.json

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

package/readme.md

@@ -90,6 +90,7 @@ License MIT
   - [Check](#values-check)
   - [Cast](#values-cast)
   - [Equal](#values-equal)
+  - [Hash](#values-hash)
   - [Diff](#values-diff)
   - [Patch](#values-patch)
   - [Errors](#values-errors)
@@ -843,6 +844,18 @@ const R = Value.Equal(                               // const R = true
 )
 ```
 
+<a name='values-hash'></a>
+
+### Hash
+
+Use the Hash function to create a [FNV1A-64](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) non cryptographic hash of a value.
+
+```typescript
+const A = Value.Hash({ x: 1, y: 2, z: 3 })          // const A = 2910466848807138541n
+
+const B = Value.Hash({ x: 1, y: 4, z: 3 })          // const B = 1418369778807423581n
+```
+
 <a name='values-diff'></a>
 
 ### Diff
@@ -1192,29 +1205,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    414 ms' │ '     14 ms' │ '   29.57 x' │
-│           String │    2000    │ '    326 ms' │ '     12 ms' │ '   27.17 x' │
-│          Boolean │    2000    │ '    301 ms' │ '     11 ms' │ '   27.36 x' │
-│             Null │    2000    │ '    253 ms' │ '      8 ms' │ '   31.63 x' │
-│            RegEx │    2000    │ '    480 ms' │ '     18 ms' │ '   26.67 x' │
-│          ObjectA │    2000    │ '   2704 ms' │ '     53 ms' │ '   51.02 x' │
-│          ObjectB │    2000    │ '   2846 ms' │ '     35 ms' │ '   81.31 x' │
-│            Tuple │    2000    │ '   1244 ms' │ '     23 ms' │ '   54.09 x' │
-│            Union │    2000    │ '   1222 ms' │ '     26 ms' │ '   47.00 x' │
-│          Vector4 │    2000    │ '   1522 ms' │ '     22 ms' │ '   69.18 x' │
-│          Matrix4 │    2000    │ '    830 ms' │ '     10 ms' │ '   83.00 x' │
-│   Literal_String │    2000    │ '    348 ms' │ '      9 ms' │ '   38.67 x' │
-│   Literal_Number │    2000    │ '    356 ms' │ '      9 ms' │ '   39.56 x' │
-│  Literal_Boolean │    2000    │ '    353 ms' │ '      6 ms' │ '   58.83 x' │
-│     Array_Number │    2000    │ '    686 ms' │ '     11 ms' │ '   62.36 x' │
-│     Array_String │    2000    │ '    722 ms' │ '     11 ms' │ '   65.64 x' │
-│    Array_Boolean │    2000    │ '    724 ms' │ '      9 ms' │ '   80.44 x' │
-│    Array_ObjectA │    2000    │ '   3706 ms' │ '     36 ms' │ '  102.94 x' │
-│    Array_ObjectB │    2000    │ '   3678 ms' │ '     38 ms' │ '   96.79 x' │
-│      Array_Tuple │    2000    │ '   2217 ms' │ '     23 ms' │ '   96.39 x' │
-│      Array_Union │    2000    │ '   1654 ms' │ '     24 ms' │ '   68.92 x' │
-│    Array_Vector4 │    2000    │ '   2283 ms' │ '     20 ms' │ '  114.15 x' │
-│    Array_Matrix4 │    2000    │ '   1567 ms' │ '     19 ms' │ '   82.47 x' │
+│           Number │    2000    │ '    415 ms' │ '     14 ms' │ '   29.64 x' │
+│           String │    2000    │ '    335 ms' │ '     12 ms' │ '   27.92 x' │
+│          Boolean │    2000    │ '    295 ms' │ '     13 ms' │ '   22.69 x' │
+│             Null │    2000    │ '    255 ms' │ '      8 ms' │ '   31.88 x' │
+│            RegEx │    2000    │ '    482 ms' │ '     17 ms' │ '   28.35 x' │
+│          ObjectA │    2000    │ '   2700 ms' │ '     55 ms' │ '   49.09 x' │
+│          ObjectB │    2000    │ '   2871 ms' │ '     36 ms' │ '   79.75 x' │
+│            Tuple │    2000    │ '   1229 ms' │ '     22 ms' │ '   55.86 x' │
+│            Union │    2000    │ '   1216 ms' │ '     26 ms' │ '   46.77 x' │
+│          Vector4 │    2000    │ '   1575 ms' │ '     25 ms' │ '   63.00 x' │
+│          Matrix4 │    2000    │ '    908 ms' │ '     13 ms' │ '   69.85 x' │
+│   Literal_String │    2000    │ '    353 ms' │ '      9 ms' │ '   39.22 x' │
+│   Literal_Number │    2000    │ '    371 ms' │ '      7 ms' │ '   53.00 x' │
+│  Literal_Boolean │    2000    │ '    361 ms' │ '      8 ms' │ '   45.13 x' │
+│     Array_Number │    2000    │ '    694 ms' │ '      7 ms' │ '   99.14 x' │
+│     Array_String │    2000    │ '    778 ms' │ '      8 ms' │ '   97.25 x' │
+│    Array_Boolean │    2000    │ '    735 ms' │ '      7 ms' │ '  105.00 x' │
+│    Array_ObjectA │    2000    │ '   3732 ms' │ '     44 ms' │ '   84.82 x' │
+│    Array_ObjectB │    2000    │ '   3624 ms' │ '     40 ms' │ '   90.60 x' │
+│      Array_Tuple │    2000    │ '   2101 ms' │ '     15 ms' │ '  140.07 x' │
+│      Array_Union │    2000    │ '   1480 ms' │ '     25 ms' │ '   59.20 x' │
+│    Array_Vector4 │    2000    │ '   2175 ms' │ '     18 ms' │ '  120.83 x' │
+│    Array_Matrix4 │    2000    │ '   1516 ms' │ '     13 ms' │ '  116.62 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1228,31 +1241,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     33 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     26 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
-│          Boolean │  1000000   │ '     24 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│             Null │  1000000   │ '     28 ms' │ '     24 ms' │ '     11 ms' │ '    2.18 x' │
-│            RegEx │  1000000   │ '    171 ms' │ '     56 ms' │ '     41 ms' │ '    1.37 x' │
-│          ObjectA │  1000000   │ '    614 ms' │ '     42 ms' │ '     24 ms' │ '    1.75 x' │
-│          ObjectB │  1000000   │ '   1109 ms' │ '     59 ms' │ '     45 ms' │ '    1.31 x' │
-│            Tuple │  1000000   │ '    122 ms' │ '     25 ms' │ '     13 ms' │ '    1.92 x' │
-│            Union │  1000000   │ '    316 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3219 ms' │ '    453 ms' │ '    128 ms' │ '    3.54 x' │
-│          Vector4 │  1000000   │ '    145 ms' │ '     26 ms' │ '     13 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    537 ms' │ '     42 ms' │ '     28 ms' │ '    1.50 x' │
-│   Literal_String │  1000000   │ '     51 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
-│   Literal_Number │  1000000   │ '     48 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│  Literal_Boolean │  1000000   │ '     49 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│     Array_Number │  1000000   │ '    438 ms' │ '     35 ms' │ '     19 ms' │ '    1.84 x' │
-│     Array_String │  1000000   │ '    468 ms' │ '     33 ms' │ '     23 ms' │ '    1.43 x' │
-│    Array_Boolean │  1000000   │ '    448 ms' │ '     36 ms' │ '     29 ms' │ '    1.24 x' │
-│    Array_ObjectA │  1000000   │ '  13904 ms' │ '   2536 ms' │ '   1530 ms' │ '    1.66 x' │
-│    Array_ObjectB │  1000000   │ '  16188 ms' │ '   2724 ms' │ '   1834 ms' │ '    1.49 x' │
-│      Array_Tuple │  1000000   │ '   1725 ms' │ '     98 ms' │ '     64 ms' │ '    1.53 x' │
-│      Array_Union │  1000000   │ '   4762 ms' │ '    237 ms' │ '     87 ms' │ '    2.72 x' │
-│  Array_Recursive │  1000000   │ '  54754 ms' │ '   7707 ms' │ '   1152 ms' │ '    6.69 x' │
-│    Array_Vector4 │  1000000   │ '   2485 ms' │ '    100 ms' │ '     48 ms' │ '    2.08 x' │
-│    Array_Matrix4 │  1000000   │ '  13116 ms' │ '    387 ms' │ '    232 ms' │ '    1.67 x' │
+│           Number │  1000000   │ '     28 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
+│           String │  1000000   │ '     22 ms' │ '     21 ms' │ '     13 ms' │ '    1.62 x' │
+│          Boolean │  1000000   │ '     22 ms' │ '     21 ms' │ '     11 ms' │ '    1.91 x' │
+│             Null │  1000000   │ '     25 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
+│            RegEx │  1000000   │ '    167 ms' │ '     48 ms' │ '     38 ms' │ '    1.26 x' │
+│          ObjectA │  1000000   │ '    591 ms' │ '     36 ms' │ '     22 ms' │ '    1.64 x' │
+│          ObjectB │  1000000   │ '   1168 ms' │ '     61 ms' │ '     37 ms' │ '    1.65 x' │
+│            Tuple │  1000000   │ '    127 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│            Union │  1000000   │ '    340 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
+│        Recursive │  1000000   │ '   3174 ms' │ '    432 ms' │ '    100 ms' │ '    4.32 x' │
+│          Vector4 │  1000000   │ '    142 ms' │ '     24 ms' │ '     12 ms' │ '    2.00 x' │
+│          Matrix4 │  1000000   │ '    577 ms' │ '     40 ms' │ '     28 ms' │ '    1.43 x' │
+│   Literal_String │  1000000   │ '     47 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│   Literal_Number │  1000000   │ '     47 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
+│  Literal_Boolean │  1000000   │ '     45 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│     Array_Number │  1000000   │ '    432 ms' │ '     33 ms' │ '     19 ms' │ '    1.74 x' │
+│     Array_String │  1000000   │ '    462 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
+│    Array_Boolean │  1000000   │ '    455 ms' │ '     32 ms' │ '     26 ms' │ '    1.23 x' │
+│    Array_ObjectA │  1000000   │ '  14595 ms' │ '   2306 ms' │ '   1496 ms' │ '    1.54 x' │
+│    Array_ObjectB │  1000000   │ '  17310 ms' │ '   2625 ms' │ '   2105 ms' │ '    1.25 x' │
+│      Array_Tuple │  1000000   │ '   1794 ms' │ '     97 ms' │ '     66 ms' │ '    1.47 x' │
+│      Array_Union │  1000000   │ '   5085 ms' │ '    246 ms' │ '     91 ms' │ '    2.70 x' │
+│  Array_Recursive │  1000000   │ '  59747 ms' │ '   7866 ms' │ '   1136 ms' │ '    6.92 x' │
+│    Array_Vector4 │  1000000   │ '   2375 ms' │ '     99 ms' │ '     48 ms' │ '    2.06 x' │
+│    Array_Matrix4 │  1000000   │ '  13115 ms' │ '    385 ms' │ '    246 ms' │ '    1.57 x' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1266,12 +1279,13 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   56 kb' │ '   28 kb' │  '2.01 x'   │
+│ typebox/compiler     │ '   61 kb' │ '   30 kb' │  '2.03 x'   │
 │ typebox/conditional  │ '   45 kb' │ '   18 kb' │  '2.44 x'   │
 │ typebox/custom       │ '    0 kb' │ '    0 kb' │  '2.61 x'   │
 │ typebox/format       │ '    0 kb' │ '    0 kb' │  '2.66 x'   │
 │ typebox/guard        │ '   23 kb' │ '   11 kb' │  '2.07 x'   │
-│ typebox/value        │ '   80 kb' │ '   37 kb' │  '2.16 x'   │
+│ typebox/hash         │ '    4 kb' │ '    1 kb' │  '2.27 x'   │
+│ typebox/value        │ '   85 kb' │ '   39 kb' │  '2.16 x'   │
 │ typebox              │ '   12 kb' │ '    6 kb' │  '1.89 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```

package/value/check.js

@@ -31,6 +31,7 @@ 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");
 class ValueCheckUnknownTypeError extends Error {
     constructor(schema) {
         super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
@@ -56,7 +57,16 @@ var ValueCheck;
         if (IsNumber(schema.maxItems) && !(value.length <= schema.maxItems)) {
             return false;
         }
-        if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+        // prettier-ignore
+        if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
+            const hashed = index_3.ValueHash.Create(element);
+            if (set.has(hashed)) {
+                return false;
+            }
+            else {
+                set.add(hashed);
+            }
+        } return true; })())) {
             return false;
         }
         return value.every((val) => Visit(schema.items, references, val));

package/value/index.d.ts

@@ -1,3 +1,4 @@
 export { ValueError, ValueErrorType } from '../errors/index';
+export { Edit, Insert, Update, Delete } from './delta';
 export * from './pointer';
 export * from './value';

package/value/index.js

@@ -41,8 +41,13 @@ 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 });
-exports.ValueErrorType = void 0;
+exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+var delta_1 = require("./delta");
+Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_1.Edit; } });
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_1.Insert; } });
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_1.Update; } });
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_1.Delete; } });
 __exportStar(require("./pointer"), exports);
 __exportStar(require("./value"), exports);

package/value/value.d.ts

@@ -1,7 +1,6 @@
 import * as Types from '../typebox';
 import { ValueError } from '../errors/index';
 import { Edit } from './delta';
-export { Edit, Insert, Update, Delete } from './delta';
 /** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
     /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
@@ -16,16 +15,18 @@ export declare namespace Value {
     function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
     /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
+    /** Returns a structural clone of the given value */
+    function Clone<T>(value: T): T;
     /** Returns an iterator for each error in this value. */
     function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>;
     /** Returns an iterator for each error in this value. */
     function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>;
     /** Returns true if left and right values are structurally equal */
     function Equal<T>(left: T, right: unknown): right is T;
-    /** Returns a structural clone of the given value */
-    function Clone<T>(value: T): T;
     /** Returns edits to transform the current value into the next value */
     function Diff(current: unknown, next: unknown): Edit[];
+    /** Returns a FNV1A-64 non cryptographic hash of the given value */
+    function Hash(value: unknown): bigint;
     /** Returns a new value with edits applied to the given value */
     function Patch<T = any>(current: unknown, edits: Edit[]): T;
 }

package/value/value.js

@@ -27,19 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = exports.Delete = exports.Update = exports.Insert = exports.Edit = void 0;
+exports.Value = void 0;
 const index_1 = require("../errors/index");
+const index_2 = require("../hash/index");
 const equal_1 = require("./equal");
 const cast_1 = require("./cast");
 const clone_1 = require("./clone");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const delta_1 = require("./delta");
-var delta_2 = require("./delta");
-Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_2.Edit; } });
-Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_2.Insert; } });
-Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_2.Update; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_2.Delete; } });
 /** Provides functions to perform structural updates to JavaScript values */
 var Value;
 (function (Value) {
@@ -58,6 +54,11 @@ var Value;
         return check_1.ValueCheck.Check(schema, references, value);
     }
     Value.Check = Check;
+    /** Returns a structural clone of the given value */
+    function Clone(value) {
+        return clone_1.ValueClone.Clone(value);
+    }
+    Value.Clone = Clone;
     function* Errors(...args) {
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
         yield* index_1.ValueErrors.Errors(schema, references, value);
@@ -68,16 +69,16 @@ var Value;
         return equal_1.ValueEqual.Equal(left, right);
     }
     Value.Equal = Equal;
-    /** Returns a structural clone of the given value */
-    function Clone(value) {
-        return clone_1.ValueClone.Clone(value);
-    }
-    Value.Clone = Clone;
     /** Returns edits to transform the current value into the next value */
     function Diff(current, next) {
         return delta_1.ValueDelta.Diff(current, next);
     }
     Value.Diff = Diff;
+    /** Returns a FNV1A-64 non cryptographic hash of the given value */
+    function Hash(value) {
+        return index_2.ValueHash.Create(value);
+    }
+    Value.Hash = Hash;
     /** Returns a new value with edits applied to the given value */
     function Patch(current, edits) {
         return delta_1.ValueDelta.Patch(current, edits);