@sinclair/typebox 0.25.9 → 0.25.11

package/compiler/compiler.d.ts

@@ -1,6 +1,6 @@
 import { ValueError } from '../errors/index';
 import * as Types from '../typebox';
-export declare type CheckFunction = (value: unknown) => boolean;
+export type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
     private readonly references;

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')`;
@@ -237,11 +238,11 @@ var TypeCompiler;
         // Reference: If we have seen this reference before we can just yield and return
         // the function call. If this isn't the case we defer to visit to generate and
         // set the function for subsequent passes. Consider for refactor.
-        if (names.has(schema.$ref))
+        if (state_local_function_names.has(schema.$ref))
             return yield `(${CreateFunctionName(schema.$ref)}(${value}))`;
-        if (!referenceMap.has(schema.$ref))
+        if (!state_reference_map.has(schema.$ref))
             throw Error(`TypeCompiler.Ref: Cannot de-reference schema with $id '${schema.$ref}'`);
-        const reference = referenceMap.get(schema.$ref);
+        const reference = state_reference_map.get(schema.$ref);
         yield* Visit(reference, value);
     }
     function* Self(schema, value) {
@@ -292,15 +293,17 @@ var TypeCompiler;
     function* Void(schema, value) {
         yield `(${value} === null)`;
     }
-    function* Kind(schema, value) {
-        yield `(custom('${schema[Types.Kind]}', ${value}))`;
+    function* UserDefined(schema, value) {
+        const schema_key = `schema_key_${state_remote_custom_types.size}`;
+        state_remote_custom_types.set(schema_key, schema);
+        yield `(custom('${schema[Types.Kind]}', '${schema_key}', ${value}))`;
     }
     function* Visit(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 refactor.
-        if (schema.$id && !names.has(schema.$id)) {
-            names.add(schema.$id);
+        if (schema.$id && !state_local_function_names.has(schema.$id)) {
+            state_local_function_names.add(schema.$id);
             const name = CreateFunctionName(schema.$id);
             const body = CreateFunction(name, schema, 'value');
             PushFunction(body);
@@ -358,27 +361,29 @@ var TypeCompiler;
             default:
                 if (!index_4.Custom.Has(anySchema[Types.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
-                return yield* Kind(anySchema, value);
+                return yield* UserDefined(anySchema, value);
         }
     }
     // -------------------------------------------------------------------
-    // Compile State
+    // Compiler State
     // -------------------------------------------------------------------
-    const referenceMap = new Map();
-    const locals = new Set(); // local variables and functions
-    const names = new Set(); // cache of local functions
+    const state_reference_map = new Map(); // tracks schemas with identifiers
+    const state_local_variables = new Set(); // local variables and functions
+    const state_local_function_names = new Set(); // local function names used call ref validators
+    const state_remote_custom_types = new Map(); // remote custom types used during compilation
     function ResetCompiler() {
-        referenceMap.clear();
-        locals.clear();
-        names.clear();
+        state_reference_map.clear();
+        state_local_variables.clear();
+        state_local_function_names.clear();
+        state_remote_custom_types.clear();
     }
     function AddReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
                 throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
-            if (referenceMap.has(schema.$id))
+            if (state_reference_map.has(schema.$id))
                 throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`);
-            referenceMap.set(schema.$id, schema);
+            state_reference_map.set(schema.$id, schema);
         }
     }
     function CreateExpression(schema, value) {
@@ -392,15 +397,15 @@ var TypeCompiler;
         return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
     }
     function PushFunction(functionBody) {
-        locals.add(functionBody);
+        state_local_variables.add(functionBody);
     }
     function PushLocal(expression) {
-        const local = `local_${locals.size}`;
-        locals.add(`const ${local} = ${expression}`);
+        const local = `local_${state_local_variables.size}`;
+        state_local_variables.add(`const ${local} = ${expression}`);
         return local;
     }
     function GetLocals() {
-        return [...locals.values()];
+        return [...state_local_variables.values()];
     }
     // -------------------------------------------------------------------
     // Compile
@@ -416,17 +421,21 @@ var TypeCompiler;
     function Compile(schema, references = []) {
         index_2.TypeGuard.Assert(schema, references);
         const code = Build(schema, references);
-        const compiledFunction = globalThis.Function('custom', 'format', code);
-        const checkFunction = compiledFunction((kind, value) => {
-            if (!index_4.Custom.Has(kind))
+        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))
                 return false;
+            const schema = custom_schemas.get(schema_key);
             const func = index_4.Custom.Get(kind);
-            return func(value);
+            return func(schema, value);
         }, (format, value) => {
             if (!index_3.Format.Has(format))
                 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/conditional/conditional.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-export declare type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
+export type TExtends<L extends Types.TSchema, R extends Types.TSchema, T extends Types.TSchema, U extends Types.TSchema> = Types.Static<L> extends Types.Static<R> ? T : U;
 export interface TExclude<T extends Types.TUnion, U extends Types.TUnion> extends Types.TUnion<any[]> {
     static: Exclude<Types.Static<T, this['params']>, Types.Static<U, this['params']>>;
 }

package/conditional/structural.js

@@ -57,7 +57,7 @@ var Structural;
             return true;
         if (guard_1.TypeGuard.TAny(right))
             return true;
-        if (guard_1.TypeGuard.TCustom(right))
+        if (guard_1.TypeGuard.TUserDefined(right))
             throw Error(`Structural: Cannot structurally compare custom type '${right[Types.Kind]}'`);
         return false;
     }
@@ -668,7 +668,7 @@ var Structural;
         else if (guard_1.TypeGuard.TVoid(left)) {
             return Void(left, resolvedRight);
         }
-        else if (guard_1.TypeGuard.TCustom(left)) {
+        else if (guard_1.TypeGuard.TUserDefined(left)) {
             throw Error(`Structural: Cannot structurally compare custom type '${left[Types.Kind]}'`);
         }
         else {

package/custom/custom.d.ts

@@ -1,12 +1,12 @@
-export declare type CustomValidationFunction = (value: unknown) => boolean;
-/** Provides functions to create custom types */
+export type CustomValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** Provides functions to create user defined types */
 export declare namespace Custom {
-    /** Clears all custom types */
+    /** Clears all user defined types */
     function Clear(): void;
-    /** Returns true if this kind exists */
+    /** Returns true if this user defined type exists */
     function Has(kind: string): boolean;
-    /** Sets a validation function for a custom kind */
-    function Set(kind: string, func: CustomValidationFunction): void;
-    /** Gets a custom validation function */
-    function Get(kind: string): CustomValidationFunction | undefined;
+    /** Sets a validation function for a user defined type */
+    function Set<TSchema = unknown>(kind: string, func: CustomValidationFunction<TSchema>): void;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind: string): CustomValidationFunction<any> | undefined;
 }

package/custom/custom.js

@@ -28,26 +28,26 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Custom = void 0;
-/** Provides functions to create custom types */
+/** Provides functions to create user defined types */
 var Custom;
 (function (Custom) {
     const customs = new Map();
-    /** Clears all custom types */
+    /** Clears all user defined types */
     function Clear() {
         return customs.clear();
     }
     Custom.Clear = Clear;
-    /** Returns true if this kind exists */
+    /** Returns true if this user defined type exists */
     function Has(kind) {
         return customs.has(kind);
     }
     Custom.Has = Has;
-    /** Sets a validation function for a custom kind */
+    /** Sets a validation function for a user defined type */
     function Set(kind, func) {
         customs.set(kind, func);
     }
     Custom.Set = Set;
-    /** Gets a custom validation function */
+    /** Gets a custom validation function for a user defined type */
     function Get(kind) {
         return customs.get(kind);
     }

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++) {
@@ -367,9 +377,9 @@ var ValueErrors;
             return yield { type: ValueErrorType.Void, schema, path, value, message: `Expected null` };
         }
     }
-    function* CustomType(schema, references, path, value) {
+    function* UserDefined(schema, references, path, value) {
         const func = index_2.Custom.Get(schema[Types.Kind]);
-        if (!func(value)) {
+        if (!func(schema, value)) {
             return yield { type: ValueErrorType.Custom, schema, path, value, message: `Expected kind ${schema[Types.Kind]}` };
         }
     }
@@ -426,7 +436,7 @@ var ValueErrors;
             default:
                 if (!index_2.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueErrorsUnknownTypeError(schema);
-                return yield* CustomType(anySchema, anyReferences, path, value);
+                return yield* UserDefined(anySchema, anyReferences, path, value);
         }
     }
     function* Errors(schema, references, value) {

package/format/format.d.ts

@@ -1,12 +1,12 @@
-export declare type FormatValidationFunction = (value: string) => boolean;
-/** Provides functions to create custom string formats */
+export type FormatValidationFunction = (value: string) => boolean;
+/** Provides functions to create user defined string formats */
 export declare namespace Format {
-    /** Clears all formats */
+    /** Clears all user defined string formats */
     function Clear(): void;
-    /** Returns true if the string format exists */
+    /** Returns true if the user defined string format exists */
     function Has(format: string): boolean;
-    /** Sets a string format validation function */
+    /** Sets a validation function for a user defined string format */
     function Set(format: string, func: FormatValidationFunction): void;
-    /** Gets a string format validation function */
+    /** Gets a validation function for a user defined string format */
     function Get(format: string): FormatValidationFunction | undefined;
 }

package/format/format.js

@@ -28,26 +28,26 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Format = void 0;
-/** Provides functions to create custom string formats */
+/** Provides functions to create user defined string formats */
 var Format;
 (function (Format) {
     const formats = new Map();
-    /** Clears all formats */
+    /** Clears all user defined string formats */
     function Clear() {
         return formats.clear();
     }
     Format.Clear = Clear;
-    /** Returns true if the string format exists */
+    /** Returns true if the user defined string format exists */
     function Has(format) {
         return formats.has(format);
     }
     Format.Has = Has;
-    /** Sets a string format validation function */
+    /** Sets a validation function for a user defined string format */
     function Set(format, func) {
         formats.set(format, func);
     }
     Format.Set = Set;
-    /** Gets a string format validation function */
+    /** Gets a validation function for a user defined string format */
     function Get(format) {
         return formats.get(format);
     }

package/guard/guard.d.ts

@@ -51,8 +51,8 @@ export declare namespace TypeGuard {
     function TUnknown(schema: unknown): schema is Types.TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema: unknown): schema is Types.TVoid;
-    /** Returns true if the given schema is a registered custom type */
-    function TCustom(schema: unknown): schema is Types.TSchema;
+    /** Returns true if the given schema is a registered user defined type */
+    function TUserDefined(schema: unknown): schema is Types.TSchema;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema: unknown): schema is Types.TSchema;
     /** Asserts if this schema and associated references are valid. */

package/guard/guard.js

@@ -394,11 +394,11 @@ var TypeGuard;
             IsOptionalString(schema.$id));
     }
     TypeGuard.TVoid = TVoid;
-    /** Returns true if the given schema is a registered custom type */
-    function TCustom(schema) {
+    /** Returns true if the given schema is a registered user defined type */
+    function TUserDefined(schema) {
         return IsObject(schema) && IsString(schema[Types.Kind]) && index_1.Custom.Has(schema[Types.Kind]);
     }
-    TypeGuard.TCustom = TCustom;
+    TypeGuard.TUserDefined = TUserDefined;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema) {
         return (TAny(schema) ||
@@ -424,7 +424,7 @@ var TypeGuard;
             TUint8Array(schema) ||
             TUnknown(schema) ||
             TVoid(schema) ||
-            TCustom(schema));
+            TUserDefined(schema));
     }
     TypeGuard.TSchema = TSchema;
     /** Asserts if this schema and associated references are valid. */

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.9",
+  "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"
   },
@@ -39,12 +40,12 @@
     "@sinclair/hammer": "^0.17.1",
     "@types/chai": "^4.3.3",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^18.7.13",
-    "ajv": "^8.11.0",
+    "@types/node": "^18.11.9",
+    "ajv": "^8.11.2",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.8.2"
+    "typescript": "^4.9.3"
   }
 }