@sinclair/typebox 0.32.0-dev-25 → 0.32.0-dev-27

package/build/require/type/rest/rest.js

@@ -1,12 +1,11 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rest = exports.RestResolve = void 0;
+exports.Rest = void 0;
 const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function RestResolve(T) {
@@ -15,7 +14,6 @@ function RestResolve(T) {
             (0, type_2.IsTuple)(T) ? [...(T.items ?? [])] :
                 []);
 }
-exports.RestResolve = RestResolve;
 /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
 function Rest(T) {
     return (0, type_1.CloneRest)(RestResolve(T));

package/build/require/type/sets/index.d.ts

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

package/build/require/type/{operators → sets}/index.js

@@ -15,4 +15,4 @@ 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("./operators"), exports);
+__exportStar(require("./set"), exports);

package/build/require/type/sets/set.d.ts

@@ -0,0 +1,24 @@
+export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TSetIncludes<R, S> : false);
+/** Returns true if element S is in the set of T */
+export declare function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S>;
+export type SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? SetIsSubset<R, S> : false : true);
+/** Returns true if T is a subset of S */
+export declare function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): SetIsSubset<T, S>;
+export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<Acc, L> extends false ? TSetDistinct<R, [...Acc, L]> : TSetDistinct<R, [...Acc]> : Acc;
+/** Returns a distinct set of elements */
+export declare function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T>;
+export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIntersect<R, S, [L, ...Acc]> : TSetIntersect<R, S, [...Acc]> : Acc);
+/** Returns the Intersect of the given sets */
+export declare function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIntersect<T, S>;
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetUnion<R, S, [...Acc, L]> : Acc);
+/** Returns the Union of the given sets */
+export declare function SetUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetUnion<T, S>;
+export type TSetComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetComplement<R, S, [...Acc]> : TSetComplement<R, S, [...Acc, L]> : Acc);
+/** Returns the Complement by omitting elements in T that are in S */
+export declare function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetComplement<T, S>;
+export type TSetIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectMany<R, TSetIntersect<Acc, L>> : Acc);
+/** Returns the Intersect of multiple sets */
+export declare function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetIntersectMany<T>;
+export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetUnionMany<R, TSetUnion<Acc, L>> : Acc);
+/** Returns the Union of multiple sets */
+export declare function SetUnionMany<T extends PropertyKey[][]>(T: [...T]): TSetUnionMany<T>;

package/build/require/type/sets/set.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUnionMany = exports.SetIntersectMany = exports.SetComplement = exports.SetUnion = exports.SetIntersect = exports.SetDistinct = exports.SetIsSubset = exports.SetIncludes = void 0;
+/** Returns true if element S is in the set of T */
+// prettier-ignore
+function SetIncludes(T, S) {
+    return T.includes(S);
+}
+exports.SetIncludes = SetIncludes;
+/** Returns true if T is a subset of S */
+function SetIsSubset(T, S) {
+    return T.every((L) => SetIncludes(S, L));
+}
+exports.SetIsSubset = SetIsSubset;
+/** Returns a distinct set of elements */
+function SetDistinct(T) {
+    return [...new Set(T)];
+}
+exports.SetDistinct = SetDistinct;
+/** Returns the Intersect of the given sets */
+function SetIntersect(T, S) {
+    return T.filter((L) => S.includes(L));
+}
+exports.SetIntersect = SetIntersect;
+/** Returns the Union of the given sets */
+function SetUnion(T, S) {
+    return [...T, ...S];
+}
+exports.SetUnion = SetUnion;
+/** Returns the Complement by omitting elements in T that are in S */
+// prettier-ignore
+function SetComplement(T, S) {
+    return T.filter(L => !S.includes(L));
+}
+exports.SetComplement = SetComplement;
+/** Returns the Intersect of multiple sets */
+// prettier-ignore
+function SetIntersectMany(T) {
+    return (T.length === 1 ? T[0] : T.reduce((Acc, L) => [...SetIntersect(Acc, L)], []));
+}
+exports.SetIntersectMany = SetIntersectMany;
+/** Returns the Union of multiple sets */
+function SetUnionMany(T) {
+    return T.reduce((Acc, L) => [...Acc, ...L], []);
+}
+exports.SetUnionMany = SetUnionMany;

package/build/require/type/strict/strict.d.ts

@@ -1,3 +1,3 @@
 import type { TSchema } from '../schema/index';
-/** `[Json]` Omits compositing symbols from this schema */
+/** `[Json]` Omits compositing symbols from this schema. */
 export declare function Strict<T extends TSchema>(schema: T): T;

package/build/require/type/strict/strict.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strict = void 0;
-/** `[Json]` Omits compositing symbols from this schema */
+/** `[Json]` Omits compositing symbols from this schema. */
 function Strict(schema) {
     return JSON.parse(JSON.stringify(schema));
 }

package/build/require/type/template-literal/parse.js

@@ -1,7 +1,7 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.TemplateLiteralParserError = void 0;
-
 const index_1 = require("../error/index");
 // ------------------------------------------------------------------
 // TemplateLiteralParserError

package/build/require/type/template-literal/syntax.d.ts

@@ -1,5 +1,5 @@
 import type { Assert, Trim } from '../helpers/index';
-import type { TTemplateLiteralKind, TTemplateLiteral } from './index';
+import type { TTemplateLiteral, TTemplateLiteralKind } from './index';
 import { type TLiteral } from '../literal/index';
 import { type TBoolean } from '../boolean/index';
 import { type TBigInt } from '../bigint/index';

package/build/require/type/template-literal/template-literal.d.ts

@@ -9,7 +9,7 @@ import type { TString } from '../string/index';
 import type { TBoolean } from '../boolean/index';
 import type { TNever } from '../never/index';
 import type { Static } from '../static/index';
-import { TTemplateLiteralSyntax } from './syntax';
+import { type TTemplateLiteralSyntax } from './syntax';
 import { EmptyString } from '../helpers/index';
 import { Kind } from '../symbols/index';
 type TemplateLiteralStaticKind<T, Acc extends string> = T extends TUnion<infer U> ? {

package/build/require/type/transform/transform.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transform = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = void 0;
-const type_1 = require("../clone/type");
 const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------

package/build/require/type/type/json.d.ts

@@ -21,10 +21,10 @@ import { type TNull } from '../null/index';
 import { type TMappedKey } from '../mapped/index';
 import { type TNumber, type NumberOptions } from '../number/index';
 import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
-import { type TOmit, type TOmitFromMappedKey } from '../omit/index';
+import { type TOmit, type TOmitFromMappedKey, type TOmitFromMappedResult } from '../omit/index';
 import { type TOptionalWithFlag, type TOptionalFromMappedResult } from '../optional/index';
 import { type TPartial, type TPartialFromMappedResult } from '../partial/index';
-import { type TPick, type TPickFromMappedKey } from '../pick/index';
+import { type TPick, type TPickFromMappedKey, type TPickFromMappedResult } from '../pick/index';
 import { type TReadonlyWithFlag, type TReadonlyFromMappedResult } from '../readonly/index';
 import { type TReadonlyOptional } from '../readonly-optional/index';
 import { type TRecordOrObject } from '../record/index';
@@ -127,6 +127,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Creates an Object type */
     Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
+    Omit<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K], options?: SchemaOptions): TOmitFromMappedResult<T, K>;
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
     /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
@@ -137,6 +139,8 @@ export declare class JsonTypeBuilder {
     /** `[Json]` Constructs a type where all properties are optional */
     Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
+    Pick<T extends TMappedResult, K extends PropertyKey[]>(T: T, K: [...K]): TPickFromMappedResult<T, K>;
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TMappedKey>(T: T, K: K): TPickFromMappedKey<T, K>;
     /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;

package/build/require/type/union/union-evaluated.js

@@ -11,25 +11,14 @@ const union_create_1 = require("./union-create");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function IsUnionOptional(T) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsOptional)(L)
-            ? true
-            : IsUnionOptional(R)
-        : false);
+    return T.some(L => (0, type_2.IsOptional)(L));
 }
 // prettier-ignore
-function RemoveOptionalFromRest(T, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? (0, type_2.IsOptional)(L)
-            ? RemoveOptionalFromRest(R, [...Acc, RemoveOptionalFromType(L)])
-            : RemoveOptionalFromRest(R, [...Acc, L])
-        : Acc);
+function RemoveOptionalFromRest(T) {
+    return T.map(L => (0, type_2.IsOptional)(L) ? RemoveOptionalFromType(L) : L);
 }
 // prettier-ignore
 function RemoveOptionalFromType(T) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-25",
+  "version": "0.32.0-dev-27",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -53,7 +53,7 @@ type T = Static<typeof T>                            // type T = {
 
 TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
-This library is designed to be a runtime type system with capabilities similar to TypeScript's static type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
+This library is built to be a runtime type system offering similar capabilities to TypeScript's static type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -1619,12 +1619,12 @@ The following example shows an inline error function that intercepts errors for
 ```typescript
 import { SetErrorFunction, DefaultErrorFunction, ValueErrorType } from '@sinclair/typebox/errors'
 
-SetErrorFunction((schema, errorType) => { // i18n override
-  switch(errorType) {
+SetErrorFunction((error) => { // i18n override
+  switch(error.errorType) {
     /* en-US */ case ValueErrorType.String: return 'Expected string'
     /* fr-FR */ case ValueErrorType.Number: return 'Nombre attendu'  
     /* ko-KR */ case ValueErrorType.Boolean: return '예상 부울'      
-    /* en-US */ default: return DefaultErrorFunction(schema, errorType)          
+    /* en-US */ default: return DefaultErrorFunction(error)          
   }
 })
 const T = Type.Object({                              // const T: TObject<{
@@ -1709,35 +1709,35 @@ This benchmark measures compilation performance for varying types.
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    236 ms' │ '      9 ms' │ '   26.22 x' │
-│ Literal_Number             │    1000    │ '    205 ms' │ '     13 ms' │ '   15.77 x' │
-│ Literal_Boolean            │    1000    │ '    168 ms' │ '      4 ms' │ '   42.00 x' │
-│ Primitive_Number           │    1000    │ '    170 ms' │ '      8 ms' │ '   21.25 x' │
-│ Primitive_String           │    1000    │ '    162 ms' │ '      7 ms' │ '   23.14 x' │
-│ Primitive_String_Pattern   │    1000    │ '    211 ms' │ '     10 ms' │ '   21.10 x' │
-│ Primitive_Boolean          │    1000    │ '    139 ms' │ '      4 ms' │ '   34.75 x' │
-│ Primitive_Null             │    1000    │ '    146 ms' │ '      5 ms' │ '   29.20 x' │
-│ Object_Unconstrained       │    1000    │ '   1160 ms' │ '     33 ms' │ '   35.15 x' │
-│ Object_Constrained         │    1000    │ '   1257 ms' │ '     26 ms' │ '   48.35 x' │
-│ Object_Vector3             │    1000    │ '    393 ms' │ '      8 ms' │ '   49.13 x' │
-│ Object_Box3D               │    1000    │ '   1795 ms' │ '     30 ms' │ '   59.83 x' │
-│ Tuple_Primitive            │    1000    │ '    542 ms' │ '     16 ms' │ '   33.88 x' │
-│ Tuple_Object               │    1000    │ '   1330 ms' │ '     17 ms' │ '   78.24 x' │
-│ Composite_Intersect        │    1000    │ '    624 ms' │ '     17 ms' │ '   36.71 x' │
-│ Composite_Union            │    1000    │ '    565 ms' │ '     19 ms' │ '   29.74 x' │
-│ Math_Vector4               │    1000    │ '    853 ms' │ '     10 ms' │ '   85.30 x' │
-│ Math_Matrix4               │    1000    │ '    406 ms' │ '     12 ms' │ '   33.83 x' │
-│ Array_Primitive_Number     │    1000    │ '    401 ms' │ '     11 ms' │ '   36.45 x' │
-│ Array_Primitive_String     │    1000    │ '    385 ms' │ '      6 ms' │ '   64.17 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    347 ms' │ '      8 ms' │ '   43.38 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1904 ms' │ '     25 ms' │ '   76.16 x' │
-│ Array_Object_Constrained   │    1000    │ '   1582 ms' │ '     20 ms' │ '   79.10 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    864 ms' │ '     11 ms' │ '   78.55 x' │
-│ Array_Tuple_Object         │    1000    │ '   1658 ms' │ '     16 ms' │ '  103.63 x' │
-│ Array_Composite_Intersect  │    1000    │ '    786 ms' │ '     17 ms' │ '   46.24 x' │
-│ Array_Composite_Union      │    1000    │ '    844 ms' │ '     16 ms' │ '   52.75 x' │
-│ Array_Math_Vector4         │    1000    │ '   1192 ms' │ '     10 ms' │ '  119.20 x' │
-│ Array_Math_Matrix4         │    1000    │ '    688 ms' │ '     10 ms' │ '   68.80 x' │
+│ Literal_String             │    1000    │ '    242 ms' │ '     10 ms' │ '   24.20 x' │
+│ Literal_Number             │    1000    │ '    200 ms' │ '      8 ms' │ '   25.00 x' │
+│ Literal_Boolean            │    1000    │ '    168 ms' │ '      6 ms' │ '   28.00 x' │
+│ Primitive_Number           │    1000    │ '    165 ms' │ '      8 ms' │ '   20.63 x' │
+│ Primitive_String           │    1000    │ '    154 ms' │ '      6 ms' │ '   25.67 x' │
+│ Primitive_String_Pattern   │    1000    │ '    208 ms' │ '     14 ms' │ '   14.86 x' │
+│ Primitive_Boolean          │    1000    │ '    142 ms' │ '      6 ms' │ '   23.67 x' │
+│ Primitive_Null             │    1000    │ '    143 ms' │ '      6 ms' │ '   23.83 x' │
+│ Object_Unconstrained       │    1000    │ '   1217 ms' │ '     31 ms' │ '   39.26 x' │
+│ Object_Constrained         │    1000    │ '   1275 ms' │ '     26 ms' │ '   49.04 x' │
+│ Object_Vector3             │    1000    │ '    405 ms' │ '     12 ms' │ '   33.75 x' │
+│ Object_Box3D               │    1000    │ '   1833 ms' │ '     27 ms' │ '   67.89 x' │
+│ Tuple_Primitive            │    1000    │ '    475 ms' │ '     13 ms' │ '   36.54 x' │
+│ Tuple_Object               │    1000    │ '   1267 ms' │ '     30 ms' │ '   42.23 x' │
+│ Composite_Intersect        │    1000    │ '    604 ms' │ '     18 ms' │ '   33.56 x' │
+│ Composite_Union            │    1000    │ '    545 ms' │ '     20 ms' │ '   27.25 x' │
+│ Math_Vector4               │    1000    │ '    829 ms' │ '     12 ms' │ '   69.08 x' │
+│ Math_Matrix4               │    1000    │ '    405 ms' │ '     10 ms' │ '   40.50 x' │
+│ Array_Primitive_Number     │    1000    │ '    372 ms' │ '     12 ms' │ '   31.00 x' │
+│ Array_Primitive_String     │    1000    │ '    327 ms' │ '      5 ms' │ '   65.40 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    300 ms' │ '      4 ms' │ '   75.00 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1755 ms' │ '     21 ms' │ '   83.57 x' │
+│ Array_Object_Constrained   │    1000    │ '   1516 ms' │ '     20 ms' │ '   75.80 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    825 ms' │ '     14 ms' │ '   58.93 x' │
+│ Array_Tuple_Object         │    1000    │ '   1616 ms' │ '     16 ms' │ '  101.00 x' │
+│ Array_Composite_Intersect  │    1000    │ '    776 ms' │ '     16 ms' │ '   48.50 x' │
+│ Array_Composite_Union      │    1000    │ '    820 ms' │ '     14 ms' │ '   58.57 x' │
+│ Array_Math_Vector4         │    1000    │ '   1166 ms' │ '     15 ms' │ '   77.73 x' │
+│ Array_Math_Matrix4         │    1000    │ '    695 ms' │ '      8 ms' │ '   86.88 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1751,37 +1751,37 @@ This benchmark measures validation performance for varying types.
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     19 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
-│ Literal_Number             │  1000000   │ '     14 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
-│ Literal_Boolean            │  1000000   │ '     14 ms' │ '     19 ms' │ '      9 ms' │ '    2.11 x' │
-│ Primitive_Number           │  1000000   │ '     21 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Primitive_String           │  1000000   │ '     22 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Primitive_String_Pattern   │  1000000   │ '    164 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
-│ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Literal_String             │  1000000   │ '     18 ms' │ '      5 ms' │ '      4 ms' │ '    1.25 x' │
+│ Literal_Number             │  1000000   │ '     16 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Literal_Boolean            │  1000000   │ '     15 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_Number           │  1000000   │ '     21 ms' │ '     19 ms' │ '     10 ms' │ '    1.90 x' │
+│ Primitive_String           │  1000000   │ '     22 ms' │ '     18 ms' │ '      9 ms' │ '    2.00 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    155 ms' │ '     41 ms' │ '     34 ms' │ '    1.21 x' │
+│ Primitive_Boolean          │  1000000   │ '     18 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
 │ Primitive_Null             │  1000000   │ '     19 ms' │ '     17 ms' │ '      9 ms' │ '    1.89 x' │
-│ Object_Unconstrained       │  1000000   │ '    966 ms' │ '     33 ms' │ '     24 ms' │ '    1.38 x' │
-│ Object_Constrained         │  1000000   │ '   1275 ms' │ '     52 ms' │ '     42 ms' │ '    1.24 x' │
-│ Object_Vector3             │  1000000   │ '    427 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Object_Box3D               │  1000000   │ '   2024 ms' │ '     56 ms' │ '     50 ms' │ '    1.12 x' │
-│ Object_Recursive           │  1000000   │ '   5263 ms' │ '    358 ms' │ '    164 ms' │ '    2.18 x' │
-│ Tuple_Primitive            │  1000000   │ '    157 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
-│ Tuple_Object               │  1000000   │ '    767 ms' │ '     29 ms' │ '     18 ms' │ '    1.61 x' │
-│ Composite_Intersect        │  1000000   │ '    769 ms' │ '     26 ms' │ '     15 ms' │ '    1.73 x' │
-│ Composite_Union            │  1000000   │ '    501 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
-│ Math_Vector4               │  1000000   │ '    250 ms' │ '     23 ms' │ '     11 ms' │ '    2.09 x' │
-│ Math_Matrix4               │  1000000   │ '   1073 ms' │ '     43 ms' │ '     28 ms' │ '    1.54 x' │
-│ Array_Primitive_Number     │  1000000   │ '    264 ms' │ '     21 ms' │ '     12 ms' │ '    1.75 x' │
-│ Array_Primitive_String     │  1000000   │ '    242 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    151 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   5864 ms' │ '     66 ms' │ '     58 ms' │ '    1.14 x' │
-│ Array_Object_Constrained   │  1000000   │ '   5996 ms' │ '    138 ms' │ '    116 ms' │ '    1.19 x' │
-│ Array_Object_Recursive     │  1000000   │ '  22515 ms' │ '   1625 ms' │ '    585 ms' │ '    2.78 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    737 ms' │ '     38 ms' │ '     31 ms' │ '    1.23 x' │
-│ Array_Tuple_Object         │  1000000   │ '   3257 ms' │ '     77 ms' │ '     56 ms' │ '    1.38 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   3119 ms' │ '     49 ms' │ '     38 ms' │ '    1.29 x' │
-│ Array_Composite_Union      │  1000000   │ '   2108 ms' │ '     72 ms' │ '     33 ms' │ '    2.18 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1078 ms' │ '     38 ms' │ '     26 ms' │ '    1.46 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4967 ms' │ '    126 ms' │ '     88 ms' │ '    1.43 x' │
+│ Object_Unconstrained       │  1000000   │ '   1003 ms' │ '     32 ms' │ '     24 ms' │ '    1.33 x' │
+│ Object_Constrained         │  1000000   │ '   1265 ms' │ '     49 ms' │ '     38 ms' │ '    1.29 x' │
+│ Object_Vector3             │  1000000   │ '    418 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
+│ Object_Box3D               │  1000000   │ '   2035 ms' │ '     56 ms' │ '     49 ms' │ '    1.14 x' │
+│ Object_Recursive           │  1000000   │ '   5243 ms' │ '    326 ms' │ '    157 ms' │ '    2.08 x' │
+│ Tuple_Primitive            │  1000000   │ '    153 ms' │ '     20 ms' │ '     12 ms' │ '    1.67 x' │
+│ Tuple_Object               │  1000000   │ '    781 ms' │ '     28 ms' │ '     18 ms' │ '    1.56 x' │
+│ Composite_Intersect        │  1000000   │ '    742 ms' │ '     25 ms' │ '     14 ms' │ '    1.79 x' │
+│ Composite_Union            │  1000000   │ '    558 ms' │ '     24 ms' │ '     13 ms' │ '    1.85 x' │
+│ Math_Vector4               │  1000000   │ '    246 ms' │ '     22 ms' │ '     11 ms' │ '    2.00 x' │
+│ Math_Matrix4               │  1000000   │ '   1052 ms' │ '     43 ms' │ '     28 ms' │ '    1.54 x' │
+│ Array_Primitive_Number     │  1000000   │ '    272 ms' │ '     22 ms' │ '     12 ms' │ '    1.83 x' │
+│ Array_Primitive_String     │  1000000   │ '    235 ms' │ '     24 ms' │ '     14 ms' │ '    1.71 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    134 ms' │ '     23 ms' │ '     14 ms' │ '    1.64 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   6280 ms' │ '     65 ms' │ '     59 ms' │ '    1.10 x' │
+│ Array_Object_Constrained   │  1000000   │ '   6076 ms' │ '    130 ms' │ '    119 ms' │ '    1.09 x' │
+│ Array_Object_Recursive     │  1000000   │ '  22738 ms' │ '   1730 ms' │ '    635 ms' │ '    2.72 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    689 ms' │ '     35 ms' │ '     30 ms' │ '    1.17 x' │
+│ Array_Tuple_Object         │  1000000   │ '   3266 ms' │ '     63 ms' │ '     52 ms' │ '    1.21 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   3310 ms' │ '     44 ms' │ '     36 ms' │ '    1.22 x' │
+│ Array_Composite_Union      │  1000000   │ '   2432 ms' │ '     69 ms' │ '     33 ms' │ '    2.09 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1158 ms' │ '     37 ms' │ '     24 ms' │ '    1.54 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   5435 ms' │ '    132 ms' │ '     92 ms' │ '    1.43 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1795,11 +1795,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '120.5 kb' │ ' 52.7 kb' │  '2.29 x'   │
-│ typebox/errors       │ ' 55.5 kb' │ ' 25.2 kb' │  '2.20 x'   │
+│ typebox/compiler     │ '119.2 kb' │ ' 52.3 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 55.0 kb' │ ' 25.2 kb' │  '2.19 x'   │
 │ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '147.4 kb' │ ' 62.2 kb' │  '2.37 x'   │
-│ typebox              │ ' 91.3 kb' │ ' 38.0 kb' │  '2.40 x'   │
+│ typebox/value        │ '146.1 kb' │ ' 61.8 kb' │  '2.37 x'   │
+│ typebox              │ ' 90.1 kb' │ ' 37.3 kb' │  '2.41 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/build/import/type/operators/index.d.mts

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

package/build/import/type/operators/index.mjs

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

package/build/import/type/operators/operators.d.mts

@@ -1,24 +0,0 @@
-export type TOperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TOperatorIncludes<R, S> : false);
-/** Returns true if element S is in the set of T */
-export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TOperatorIncludes<T, S>;
-export type TOperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? TOperatorSubset<R, S> : false : true);
-/** Returns true if T is a subset of S */
-export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TOperatorSubset<T, S>;
-export type TOperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<Acc, L> extends false ? TOperatorDistinct<R, [...Acc, L]> : TOperatorDistinct<R, [...Acc]> : Acc;
-/** Returns a distinct set of elements */
-export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): TOperatorDistinct<T>;
-export type TOperatorIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? TOperatorIntersect<R, S, [L, ...Acc]> : TOperatorIntersect<R, S, [...Acc]> : Acc);
-/** Returns the Intersect of the given sets */
-export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TOperatorIntersect<T, S>;
-export type TOperatorUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorUnion<R, S, [...Acc, L]> : Acc);
-/** Returns the Union of the given sets */
-export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S], Acc?: PropertyKey[]): TOperatorUnion<T, S>;
-export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? OperatorComplement<R, S, [...Acc]> : OperatorComplement<R, S, [L, ...Acc]> : Acc);
-/** Returns the Complement by omitting elements in T that are in S */
-export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S], Acc?: PropertyKey[]): OperatorComplement<T, S>;
-export type OperatorIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersectMany<R, TOperatorIntersect<Acc, L>> : Acc);
-/** Returns the Intersect of multiple sets */
-export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T], Acc?: PropertyKey[]): OperatorIntersectMany<T>;
-export type OperatorUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnionMany<R, TOperatorUnion<Acc, L>> : Acc);
-/** Returns the Union of multiple sets */
-export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T], Acc?: PropertyKey[]): OperatorUnionMany<T>;

package/build/import/type/operators/operators.mjs

@@ -1,77 +0,0 @@
-/** Returns true if element S is in the set of T */
-// prettier-ignore
-export function OperatorIncludes(T, S) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? S === L
-            ? true
-            : OperatorIncludes(R, S)
-        : false);
-}
-/** Returns true if T is a subset of S */
-export function OperatorSubset(T, S) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorIncludes(S, L) === true
-            ? OperatorSubset(R, S)
-            : false
-        : true);
-}
-/** Returns a distinct set of elements */
-export function OperatorDistinct(T, Acc = []) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0 ?
-        (OperatorIncludes(Acc, L) === false
-            ? OperatorDistinct(R, [...Acc, L])
-            : OperatorDistinct(R, [...Acc])) : Acc);
-}
-/** Returns the Intersect of the given sets */
-export function OperatorIntersect(T, S) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorIncludes(S, L) === true
-            ? [L, ...OperatorIntersect(R, S)]
-            : [...OperatorIntersect(R, S)]
-        : []);
-}
-/** Returns the Union of the given sets */
-export function OperatorUnion(T, S, Acc = S) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorUnion(R, S, [...Acc, L])
-        : Acc);
-}
-/** Returns the Complement by omitting elements in T that are in S */
-// prettier-ignore
-export function OperatorComplement(T, S, Acc = []) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? OperatorIncludes(S, L) === true
-            ? OperatorComplement(R, S, [...Acc])
-            : OperatorComplement(R, S, [L, ...Acc])
-        : Acc);
-}
-/** Returns the Intersect of multiple sets */
-// prettier-ignore
-export function OperatorIntersectMany(T, Acc = []) {
-    return (T.length === 1
-        ? T[0]
-        : (() => {
-            const [L, ...R] = T;
-            return (L.length > 0
-                ? OperatorIntersect(L, OperatorIntersectMany(R))
-                : []);
-        })());
-}
-/** Returns the Union of multiple sets */
-export function OperatorUnionMany(T, Acc = []) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorUnionMany(R, OperatorUnion(Acc, L))
-        : Acc);
-}

package/build/require/type/operators/index.d.ts

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

package/build/require/type/operators/operators.d.ts

@@ -1,24 +0,0 @@
-export type TOperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TOperatorIncludes<R, S> : false);
-/** Returns true if element S is in the set of T */
-export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TOperatorIncludes<T, S>;
-export type TOperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? TOperatorSubset<R, S> : false : true);
-/** Returns true if T is a subset of S */
-export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TOperatorSubset<T, S>;
-export type TOperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<Acc, L> extends false ? TOperatorDistinct<R, [...Acc, L]> : TOperatorDistinct<R, [...Acc]> : Acc;
-/** Returns a distinct set of elements */
-export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): TOperatorDistinct<T>;
-export type TOperatorIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? TOperatorIntersect<R, S, [L, ...Acc]> : TOperatorIntersect<R, S, [...Acc]> : Acc);
-/** Returns the Intersect of the given sets */
-export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TOperatorIntersect<T, S>;
-export type TOperatorUnion<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = S> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorUnion<R, S, [...Acc, L]> : Acc);
-/** Returns the Union of the given sets */
-export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S], Acc?: PropertyKey[]): TOperatorUnion<T, S>;
-export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TOperatorIncludes<S, L> extends true ? OperatorComplement<R, S, [...Acc]> : OperatorComplement<R, S, [L, ...Acc]> : Acc);
-/** Returns the Complement by omitting elements in T that are in S */
-export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S], Acc?: PropertyKey[]): OperatorComplement<T, S>;
-export type OperatorIntersectMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersectMany<R, TOperatorIntersect<Acc, L>> : Acc);
-/** Returns the Intersect of multiple sets */
-export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T], Acc?: PropertyKey[]): OperatorIntersectMany<T>;
-export type OperatorUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnionMany<R, TOperatorUnion<Acc, L>> : Acc);
-/** Returns the Union of multiple sets */
-export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T], Acc?: PropertyKey[]): OperatorUnionMany<T>;