@sinclair/typebox 0.32.0-dev-26 → 0.32.0-dev-28

package/build/require/value/mutate/mutate.js

@@ -1,7 +1,7 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
+exports.Mutate = exports.ValueMutateError = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
@@ -9,18 +9,12 @@ const index_4 = require("../../type/error/index");
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-class ValueMutateTypeMismatchError extends index_4.TypeBoxError {
-    constructor() {
-        super('Cannot assign due type mismatch of assignable values');
+class ValueMutateError extends index_4.TypeBoxError {
+    constructor(message) {
+        super(message);
     }
 }
-exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
-class ValueMutateInvalidRootMutationError extends index_4.TypeBoxError {
-    constructor() {
-        super('Only object and array types can be mutated at the root level');
-    }
-}
-exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
+exports.ValueMutateError = ValueMutateError;
 function ObjectType(root, path, current, next) {
     if (!(0, index_1.IsPlainObject)(current)) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
@@ -96,9 +90,9 @@ function IsMismatchedValue(current, next) {
 /** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 function Mutate(current, next) {
     if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new ValueMutateInvalidRootMutationError();
+        throw new ValueMutateError('Only object and array types can be mutated at the root level');
     if (IsMismatchedValue(current, next))
-        throw new ValueMutateTypeMismatchError();
+        throw new ValueMutateError('Cannot assign due type mismatch of assignable values');
     Visit(current, '', current, next);
 }
 exports.Mutate = Mutate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-26",
+  "version": "0.32.0-dev-28",
   "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
 
@@ -605,9 +605,10 @@ TypeBox provides an extended type set that can be used to create schematics for
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.RegExp(/abc/)   │ type T = string             │ const T = {                    │
-│                                │                             │   type: 'string'               │
-│                                │                             │   pattern: 'abc'               │
+│ const T = Type.RegExp(/abc/i)  │ type T = string             │ const T = {                    │
+│                                │                             │   type: 'RegExp'               │
+│                                │                             │   source: 'abc'                │
+│                                │                             │   flags: 'i'                   │
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -1709,35 +1710,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 +1752,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 +1796,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '120.7 kb' │ ' 53.0 kb' │  '2.28 x'   │
-│ typebox/errors       │ ' 55.8 kb' │ ' 25.5 kb' │  '2.19 x'   │
+│ typebox/compiler     │ '120.6 kb' │ ' 52.9 kb' │  '2.28 x'   │
+│ typebox/errors       │ ' 55.7 kb' │ ' 25.5 kb' │  '2.19 x'   │
 │ typebox/system       │ '  4.7 kb' │ '  2.0 kb' │  '2.33 x'   │
-│ typebox/value        │ '147.6 kb' │ ' 62.5 kb' │  '2.36 x'   │
-│ typebox              │ ' 91.3 kb' │ ' 38.0 kb' │  '2.40 x'   │
+│ typebox/value        │ '146.2 kb' │ ' 62.0 kb' │  '2.36 x'   │
+│ typebox              │ ' 91.4 kb' │ ' 37.8 kb' │  '2.42 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>;

package/build/require/type/operators/operators.js

@@ -1,89 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorUnionMany = exports.OperatorIntersectMany = exports.OperatorComplement = exports.OperatorUnion = exports.OperatorIntersect = exports.OperatorDistinct = exports.OperatorSubset = exports.OperatorIncludes = void 0;
-/** Returns true if element S is in the set of T */
-// prettier-ignore
-function OperatorIncludes(T, S) {
-    const [L, ...R] = T;
-    return (T.length > 0
-        ? S === L
-            ? true
-            : OperatorIncludes(R, S)
-        : false);
-}
-exports.OperatorIncludes = OperatorIncludes;
-/** Returns true if T is a subset of S */
-function OperatorSubset(T, S) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorIncludes(S, L) === true
-            ? OperatorSubset(R, S)
-            : false
-        : true);
-}
-exports.OperatorSubset = OperatorSubset;
-/** Returns a distinct set of elements */
-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);
-}
-exports.OperatorDistinct = OperatorDistinct;
-/** Returns the Intersect of the given sets */
-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)]
-        : []);
-}
-exports.OperatorIntersect = OperatorIntersect;
-/** Returns the Union of the given sets */
-function OperatorUnion(T, S, Acc = S) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorUnion(R, S, [...Acc, L])
-        : Acc);
-}
-exports.OperatorUnion = OperatorUnion;
-/** Returns the Complement by omitting elements in T that are in S */
-// prettier-ignore
-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);
-}
-exports.OperatorComplement = OperatorComplement;
-/** Returns the Intersect of multiple sets */
-// prettier-ignore
-function OperatorIntersectMany(T, Acc = []) {
-    return (T.length === 1
-        ? T[0]
-        : (() => {
-            const [L, ...R] = T;
-            return (L.length > 0
-                ? OperatorIntersect(L, OperatorIntersectMany(R))
-                : []);
-        })());
-}
-exports.OperatorIntersectMany = OperatorIntersectMany;
-/** Returns the Union of multiple sets */
-function OperatorUnionMany(T, Acc = []) {
-    const [L, ...R] = T;
-    // prettier-ignore
-    return (T.length > 0
-        ? OperatorUnionMany(R, OperatorUnion(Acc, L))
-        : Acc);
-}
-exports.OperatorUnionMany = OperatorUnionMany;