@sinclair/typebox 0.25.9 → 0.25.11

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)
@@ -97,8 +98,8 @@ License MIT
 - [TypeCheck](#typecheck)
   - [Ajv](#typecheck-ajv)
   - [TypeCompiler](#typecheck-typecompiler)
-  - [Custom](#typecheck-custom)
-  - [Formats](#typecheck-formats)
+  - [Custom Types](#typecheck-custom-types)
+  - [Custom Formats](#typecheck-custom-formats)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -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
@@ -1118,11 +1131,11 @@ console.log(C.Code())                                // return function check(va
                                                      // }
 ```
 
-<a name='typecheck-custom'></a>
+<a name='typecheck-custom-types'></a>
 
-### Custom
+### Custom Types
 
-Use custom module to create a custom types. When creating a custom type you must specify a `Kind` symbol property on the types schema. The `Kind` symbol property should match the name used to register the type. Custom types are used by the Value and TypeCompiler modules only.
+Use the custom module to create user defined types. User defined types require a `[Kind]` symbol property which is used to match the schema against a registered type. Custom types are specific to TypeBox and can only be used with the TypeCompiler and Value modules.
 
 The custom module is an optional import.
 
@@ -1130,23 +1143,27 @@ The custom module is an optional import.
 import { Custom } from '@sinclair/typebox/custom'
 ```
 
-The following registers a BigInt custom type.
+The following creates a `BigInt` type.
 
 ```typescript
 import { Type, Kind } from '@sinclair/typebox'
 
-Custom.Set('BigInt', value => typeof value === 'bigint')
-
+Custom.Set('BigInt', (schema, value) => typeof value === 'bigint')
+//            │
+//            └────────────────────────────┐         The [Kind] is used to match registered type
+//                                         │
 const T = Type.Unsafe<bigint>({ [Kind]: 'BigInt' })  // const T = { [Kind]: 'BigInt' }
 
-const R = Value.Check(T, 65536n)                     // const R = true
+const A = TypeCompiler.Compile(T).Check(65536)       // const A = false
+
+const B = Value.Check(T, 65536n)                     // const B = true
 ```
 
-<a name='typecheck-formats'></a>
+<a name='typecheck-custom-formats'></a>
 
-### Formats
+### Custom Formats
 
-Use the format module to create user defined string formats. The format module is used by the Value and TypeCompiler modules only. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html).
+Use the format module to create user defined string formats. If using Ajv, please refer to the official Ajv format documentation located [here](https://ajv.js.org/guide/formats.html). The format module is specific to TypeBox can only be used with the TypeCompiler and Value modules.
 
 The format module is an optional import.
 
@@ -1154,7 +1171,7 @@ The format module is an optional import.
 import { Format } from '@sinclair/typebox/format'
 ```
 
-The following creates a `palindrome` string format.
+The following creates a palindrome string format.
 
 ```typescript
 Format.Set('palindrome', value => value === value.split('').reverse().join(''))
@@ -1174,7 +1191,7 @@ const B = Value.Check(T, 'kayak')                    // const B = true
 
 ## Benchmark
 
-This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.0. 
+This project maintains a set of benchmarks that measure Ajv, Value and TypeCompiler compilation and validation performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. The results below show for Ajv version 8.11.2. 
 
 For additional comparative benchmarks, please refer to [typescript-runtime-type-benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/).
 
@@ -1188,29 +1205,29 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │    2000    │ '    427 ms' │ '     13 ms' │ '   32.85 x' │
-│           String │    2000    │ '    367 ms' │ '     12 ms' │ '   30.58 x' │
-│          Boolean │    2000    │ '    297 ms' │ '     13 ms' │ '   22.85 x' │
-│             Null │    2000    │ '    255 ms' │ '      9 ms' │ '   28.33 x' │
-│            RegEx │    2000    │ '    487 ms' │ '     17 ms' │ '   28.65 x' │
-│          ObjectA │    2000    │ '   2718 ms' │ '     53 ms' │ '   51.28 x' │
-│          ObjectB │    2000    │ '   2874 ms' │ '     36 ms' │ '   79.83 x' │
-│            Tuple │    2000    │ '   1221 ms' │ '     22 ms' │ '   55.50 x' │
-│            Union │    2000    │ '   1223 ms' │ '     24 ms' │ '   50.96 x' │
-│          Vector4 │    2000    │ '   1517 ms' │ '     21 ms' │ '   72.24 x' │
-│          Matrix4 │    2000    │ '    830 ms' │ '     10 ms' │ '   83.00 x' │
-│   Literal_String │    2000    │ '    334 ms' │ '      8 ms' │ '   41.75 x' │
-│   Literal_Number │    2000    │ '    357 ms' │ '      6 ms' │ '   59.50 x' │
-│  Literal_Boolean │    2000    │ '    353 ms' │ '      7 ms' │ '   50.43 x' │
-│     Array_Number │    2000    │ '    679 ms' │ '     11 ms' │ '   61.73 x' │
-│     Array_String │    2000    │ '    713 ms' │ '     10 ms' │ '   71.30 x' │
-│    Array_Boolean │    2000    │ '    710 ms' │ '      7 ms' │ '  101.43 x' │
-│    Array_ObjectA │    2000    │ '   3571 ms' │ '     35 ms' │ '  102.03 x' │
-│    Array_ObjectB │    2000    │ '   3567 ms' │ '     41 ms' │ '   87.00 x' │
-│      Array_Tuple │    2000    │ '   2083 ms' │ '     19 ms' │ '  109.63 x' │
-│      Array_Union │    2000    │ '   1559 ms' │ '     23 ms' │ '   67.78 x' │
-│    Array_Vector4 │    2000    │ '   2156 ms' │ '     19 ms' │ '  113.47 x' │
-│    Array_Matrix4 │    2000    │ '   1483 ms' │ '     13 ms' │ '  114.08 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' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1224,31 +1241,31 @@ This benchmark measures validation performance for varying types. You can review
 ┌──────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │     (index)      │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├──────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│           Number │  1000000   │ '     25 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│           String │  1000000   │ '     22 ms' │ '     20 ms' │ '     11 ms' │ '    1.82 x' │
-│          Boolean │  1000000   │ '     21 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│             Null │  1000000   │ '     24 ms' │ '     21 ms' │ '      9 ms' │ '    2.33 x' │
-│            RegEx │  1000000   │ '    158 ms' │ '     46 ms' │ '     37 ms' │ '    1.24 x' │
-│          ObjectA │  1000000   │ '    566 ms' │ '     36 ms' │ '     24 ms' │ '    1.50 x' │
-│          ObjectB │  1000000   │ '   1026 ms' │ '     52 ms' │ '     40 ms' │ '    1.30 x' │
-│            Tuple │  1000000   │ '    121 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│            Union │  1000000   │ '    299 ms' │ '     26 ms' │ '     16 ms' │ '    1.63 x' │
-│        Recursive │  1000000   │ '   3168 ms' │ '    414 ms' │ '     97 ms' │ '    4.27 x' │
-│          Vector4 │  1000000   │ '    147 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
-│          Matrix4 │  1000000   │ '    573 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
-│   Literal_String │  1000000   │ '     48 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│   Literal_Number │  1000000   │ '     46 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│  Literal_Boolean │  1000000   │ '     48 ms' │ '     20 ms' │ '     10 ms' │ '    2.00 x' │
-│     Array_Number │  1000000   │ '    454 ms' │ '     32 ms' │ '     18 ms' │ '    1.78 x' │
-│     Array_String │  1000000   │ '    481 ms' │ '     32 ms' │ '     22 ms' │ '    1.45 x' │
-│    Array_Boolean │  1000000   │ '    448 ms' │ '     34 ms' │ '     27 ms' │ '    1.26 x' │
-│    Array_ObjectA │  1000000   │ '  13709 ms' │ '   2360 ms' │ '   1548 ms' │ '    1.52 x' │
-│    Array_ObjectB │  1000000   │ '  16602 ms' │ '   2585 ms' │ '   1904 ms' │ '    1.36 x' │
-│      Array_Tuple │  1000000   │ '   1831 ms' │ '     96 ms' │ '     63 ms' │ '    1.52 x' │
-│      Array_Union │  1000000   │ '   4958 ms' │ '    234 ms' │ '     86 ms' │ '    2.72 x' │
-│  Array_Recursive │  1000000   │ '  55876 ms' │ '   7160 ms' │ '   1138 ms' │ '    6.29 x' │
-│    Array_Vector4 │  1000000   │ '   2381 ms' │ '     99 ms' │ '     47 ms' │ '    2.11 x' │
-│    Array_Matrix4 │  1000000   │ '  11670 ms' │ '    383 ms' │ '    228 ms' │ '    1.68 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' │
 └──────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1262,12 +1279,13 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '   55 kb' │ '   27 kb' │  '2.00 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.15 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/typebox.d.ts

@@ -1,14 +1,14 @@
 export declare const Kind: unique symbol;
 export declare const Hint: unique symbol;
 export declare const Modifier: unique symbol;
-export declare type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
-export declare type TReadonly<T extends TSchema> = T & {
+export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
+export type TReadonly<T extends TSchema> = T & {
     [Modifier]: 'Readonly';
 };
-export declare type TOptional<T extends TSchema> = T & {
+export type TOptional<T extends TSchema> = T & {
     [Modifier]: 'Optional';
 };
-export declare type TReadonlyOptional<T extends TSchema> = T & {
+export type TReadonlyOptional<T extends TSchema> = T & {
     [Modifier]: 'ReadonlyOptional';
 };
 export interface SchemaOptions {
@@ -32,7 +32,7 @@ export interface TSchema extends SchemaOptions {
     params: unknown[];
     static: unknown;
 }
-export declare type TAnySchema = TSchema | TAny | TArray | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TLiteral | TNull | TNumber | TObject | TPromise | TRecord | TSelf | TRef | TString | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TLiteral | TNull | TNumber | TObject | TPromise | TRecord | TSelf | TRef | TString | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
 export interface NumericOptions extends SchemaOptions {
     exclusiveMaximum?: number;
     exclusiveMinimum?: number;
@@ -40,7 +40,7 @@ export interface NumericOptions extends SchemaOptions {
     minimum?: number;
     multipleOf?: number;
 }
-export declare type TNumeric = TInteger | TNumber;
+export type TNumeric = TInteger | TNumber;
 export interface TAny extends TSchema {
     [Kind]: 'Any';
     static: any;
@@ -61,9 +61,9 @@ export interface TBoolean extends TSchema {
     static: boolean;
     type: 'boolean';
 }
-export declare type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
-export declare type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
-export declare type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
+export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
+export type StaticContructorParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
@@ -95,9 +95,9 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
-export declare type TParameters<T extends TFunction> = TTuple<T['parameters']>;
-export declare type TReturnType<T extends TFunction> = T['returns'];
-export declare type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
+export type TParameters<T extends TFunction> = TTuple<T['parameters']>;
+export type TReturnType<T extends TFunction> = T['returns'];
+export type StaticFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 }];
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
@@ -113,29 +113,29 @@ export interface TInteger extends TSchema, NumericOptions {
     static: number;
     type: 'integer';
 }
-export declare type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {};
-export declare type IntersectEvaluate<T extends readonly TSchema[], P extends unknown[]> = {
+export type IntersectReduce<I extends unknown, T extends readonly any[]> = T extends [infer A, ...infer B] ? IntersectReduce<I & A, B> : I extends object ? I : {};
+export type IntersectEvaluate<T extends readonly TSchema[], P extends unknown[]> = {
     [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
 };
-export declare type IntersectProperties<T extends readonly TObject[]> = {
+export type IntersectProperties<T extends readonly TObject[]> = {
     [K in keyof T]: T[K] extends TObject<infer P> ? P : {};
 };
 export interface TIntersect<T extends TObject[] = TObject[]> extends TObject {
     static: IntersectReduce<unknown, IntersectEvaluate<T, this['params']>>;
     properties: IntersectReduce<unknown, IntersectProperties<T>>;
 }
-export declare type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
-export declare type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
-export declare type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
-export declare type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
     [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never;
 } : never;
-export declare type UnionLiteralsFromObject<T extends TObject> = {
+export type UnionLiteralsFromObject<T extends TObject> = {
     [K in ObjectPropertyKeys<T>]: TLiteral<K>;
 } extends infer R ? UnionToTuple<R[keyof R]> : never;
 export interface TKeyOf<T extends TObject> extends TUnion<UnionLiteralsFromObject<T>> {
 }
-export declare type TLiteralValue = string | number | boolean;
+export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
     [Kind]: 'Literal';
     static: T;
@@ -162,17 +162,17 @@ export interface TNumber extends TSchema, NumericOptions {
     static: number;
     type: 'number';
 }
-export declare type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+export type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonlyOptional<TSchema> ? K : never;
 }[keyof T];
-export declare type ReadonlyPropertyKeys<T extends TProperties> = {
+export type ReadonlyPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TReadonly<TSchema> ? K : never;
 }[keyof T];
-export declare type OptionalPropertyKeys<T extends TProperties> = {
+export type OptionalPropertyKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends TOptional<TSchema> ? K : never;
 }[keyof T];
-export declare type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-export declare type PropertiesReduce<T extends TProperties, P extends unknown[]> = {
+export type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+export type PropertiesReduce<T extends TProperties, P extends unknown[]> = {
     readonly [K in ReadonlyOptionalPropertyKeys<T>]?: Static<T[K], P>;
 } & {
     readonly [K in ReadonlyPropertyKeys<T>]: Static<T[K], P>;
@@ -183,15 +183,15 @@ export declare type PropertiesReduce<T extends TProperties, P extends unknown[]>
 } extends infer R ? {
     [K in keyof R]: R[K];
 } : never;
-export declare type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? {
+export type TRecordProperties<K extends TUnion<TLiteral[]>, T extends TSchema> = Static<K> extends string ? {
     [X in Static<K>]: T;
 } : never;
 export interface TProperties {
     [key: string]: TSchema;
 }
-export declare type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
-export declare type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
-export declare type TAdditionalProperties = undefined | TSchema | boolean;
+export type ObjectProperties<T> = T extends TObject<infer U> ? U : never;
+export type ObjectPropertyKeys<T> = T extends TObject<infer U> ? keyof U : never;
+export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
     additionalProperties?: TAdditionalProperties;
     minProperties?: number;
@@ -215,7 +215,7 @@ export interface TPartial<T extends TObject> extends TObject {
         [K in keyof T['properties']]: T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T['properties'][K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T['properties'][K] extends TOptional<infer U> ? TOptional<U> : TOptional<T['properties'][K]>;
     };
 }
-export declare type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> = TObject<{
+export type TPick<T extends TObject, Properties extends ObjectPropertyKeys<T>[]> = TObject<{
     [K in Properties[number]]: T['properties'][K];
 }>;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
@@ -225,7 +225,7 @@ export interface TPromise<T extends TSchema = TSchema> extends TSchema {
     instanceOf: 'Promise';
     item: TSchema;
 }
-export declare type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
+export type TRecordKey = TString | TNumeric | TUnion<TLiteral<any>[]>;
 export interface TRecord<K extends TRecordKey = TRecordKey, T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Record';
     static: Record<Static<K>, Static<T, this['params']>>;
@@ -240,7 +240,7 @@ export interface TSelf extends TSchema {
     static: this['params'][0];
     $ref: string;
 }
-export declare type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
+export type TRecursiveReduce<T extends TSchema> = Static<T, [TRecursiveReduce<T>]>;
 export interface TRecursive<T extends TSchema> extends TSchema {
     static: TRecursiveReduce<T>;
 }
@@ -255,7 +255,7 @@ export interface TRequired<T extends TObject | TRef<TObject>> extends TObject {
         [K in keyof T['properties']]: T['properties'][K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T['properties'][K] extends TReadonly<infer U> ? TReadonly<U> : T['properties'][K] extends TOptional<infer U> ? U : T['properties'][K];
     };
 }
-export declare type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
 export interface StringOptions<Format extends string> extends SchemaOptions {
     minLength?: number;
     maxLength?: number;
@@ -269,7 +269,7 @@ export interface TString<Format extends string = string> extends TSchema, String
     static: string;
     type: 'string';
 }
-export declare type TupleToArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? R : never;
+export type TupleToArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? R : never;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: {
@@ -322,7 +322,7 @@ export interface TVoid extends TSchema {
     typeOf: 'Void';
 }
 /** Creates a static type from a TypeBox type */
-export declare type Static<T extends TSchema, P extends unknown[] = []> = (T & {
+export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];
 export declare class TypeBuilder {

package/value/cast.js

@@ -307,7 +307,7 @@ var ValueCast;
     function Void(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Kind(schema, references, value) {
+    function UserDefined(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
     function Visit(schema, references, value) {
@@ -365,7 +365,7 @@ var ValueCast;
             default:
                 if (!index_1.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCastUnknownTypeError(anySchema);
-                return Kind(anySchema, anyReferences, value);
+                return UserDefined(anySchema, anyReferences, value);
         }
     }
     ValueCast.Visit = Visit;

package/value/check.js

@@ -31,9 +31,10 @@ 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: Unknown type');
+        super(`ValueCheck: ${schema[Types.Kind] ? `Unknown type '${schema[Types.Kind]}'` : 'Unknown type'}`);
         this.schema = schema;
     }
 }
@@ -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));
@@ -291,11 +301,11 @@ var ValueCheck;
     function Void(schema, references, value) {
         return value === null;
     }
-    function Kind(schema, references, value) {
+    function UserDefined(schema, references, value) {
         if (!index_2.Custom.Has(schema[Types.Kind]))
             return false;
         const func = index_2.Custom.Get(schema[Types.Kind]);
-        return func(value);
+        return func(schema, value);
     }
     function Visit(schema, references, value) {
         const anyReferences = schema.$id === undefined ? references : [schema, ...references];
@@ -350,7 +360,7 @@ var ValueCheck;
             default:
                 if (!index_2.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCheckUnknownTypeError(anySchema);
-                return Kind(anySchema, anyReferences, value);
+                return UserDefined(anySchema, anyReferences, value);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.js

@@ -293,12 +293,12 @@ var ValueCreate;
     function Void(schema, references) {
         return null;
     }
-    function Kind(schema, references) {
+    function UserDefined(schema, references) {
         if (schema.default !== undefined) {
             return schema.default;
         }
         else {
-            throw new Error('ValueCreate.Kind: Custom types must specify a default value');
+            throw new Error('ValueCreate.UserDefined: User defined types must specify a default value');
         }
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
@@ -357,7 +357,7 @@ var ValueCreate;
             default:
                 if (!index_1.Custom.Has(anySchema[Types.Kind]))
                     throw new ValueCreateUnknownTypeError(anySchema);
-                return Kind(anySchema, anyReferences);
+                return UserDefined(anySchema, anyReferences);
         }
     }
     ValueCreate.Visit = Visit;

package/value/delta.d.ts

@@ -1,22 +1,22 @@
 import { Static } from '../typebox';
-export declare type Insert = Static<typeof Insert>;
+export type Insert = Static<typeof Insert>;
 export declare const Insert: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"insert">;
     path: import("../typebox").TString<string>;
     value: import("../typebox").TUnknown;
 }>;
-export declare type Update = Static<typeof Update>;
+export type Update = Static<typeof Update>;
 export declare const Update: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"update">;
     path: import("../typebox").TString<string>;
     value: import("../typebox").TUnknown;
 }>;
-export declare type Delete = Static<typeof Delete>;
+export type Delete = Static<typeof Delete>;
 export declare const Delete: import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"delete">;
     path: import("../typebox").TString<string>;
 }>;
-export declare type Edit = Static<typeof Edit>;
+export type Edit = Static<typeof Edit>;
 export declare const Edit: import("../typebox").TUnion<[import("../typebox").TObject<{
     type: import("../typebox").TLiteral<"insert">;
     path: import("../typebox").TString<string>;

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/is.d.ts

@@ -1,7 +1,7 @@
-export declare type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
-export declare type ObjectType = Record<string | number | symbol, unknown>;
-export declare type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export declare type ArrayType = unknown[];
+export type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
+export type ObjectType = Record<string | number | symbol, unknown>;
+export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+export type ArrayType = unknown[];
 export declare namespace Is {
     function Object(value: unknown): value is ObjectType;
     function Date(value: unknown): value is Date;