@rimbu/deep 2.0.1 → 2.0.2

package/README.md

@@ -8,44 +8,56 @@
 
 # @rimbu/deep
 
-Offers tools to use handle plain JS objects as immutable objects. The [`Patch` object](https://rimbu.org/docs/deep/patch) allows convenient immutable modification of simple objects. The [`Match` object](https://rimbu.org/docs/deep/match) allows easy matching on plain objects. The [`Path` object](https://rimbu.org/docs/deep/path) allows easy querying of nested values. The [`Immutable` type](https://rimbu.org/docs/deep/immutable) makes it easy to create plain objects that that have compile-time protection against mutation. The [`Tuple` type](https://rimbu.org/docs/deep/tuple) is a utility to have similar functionality as `as const` but less strict.
+Welcome to `@rimbu/deep`! This package offers powerful tools to handle plain JavaScript objects as immutable objects, making your code more robust and maintainable.
 
-For complete documentation please visit the [Immutable Objects overview](https://rimbu.org/docs/deep/overview) in the _[Rimbu Docs](https://rimbu.org)_, or directly see the _[Rimbu Deep API Docs](https://rimbu.org/api/rimbu/deep)_.
+### Key Features:
 
-Or [Try Out Rimbu](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/main?previewwindow=console&view=split&editorsize=65&moduleview=1&module=/src/index.ts) in CodeSandBox.
+- **Immutable Modification**: Use the [`Patch` object](https://rimbu.org/docs/deep/patch) for convenient and immutable modifications of simple objects.
+- **Pattern Matching**: The [`Match` object](https://rimbu.org/docs/deep/match) allows easy pattern matching on plain objects.
+- **Nested Value Querying**: Easily query nested values with the [`Path` object](https://rimbu.org/docs/deep/path).
+- **Compile-Time Protection**: The [`Immutable` type](https://rimbu.org/docs/deep/immutable) helps create plain objects with compile-time protection against mutation.
+- **Flexible Tuples**: The [`Tuple` type](https://rimbu.org/docs/deep/tuple) provides similar functionality to `as const` but with more flexibility.
+
+### Documentation
+
+For complete documentation, please visit the [Immutable Objects overview](https://rimbu.org/docs/deep/overview) in the [Rimbu Docs](https://rimbu.org), or directly explore the [Rimbu Deep API Docs](https://rimbu.org/api/rimbu/deep).
+
+### Try It Out
+
+Experience `@rimbu/deep` in action! [Try Out Rimbu](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/main?previewwindow=console&view=split&editorsize=65&moduleview=1&module=/src/index.ts) on CodeSandBox.
 
 ## Installation
 
 ### Compabitity
 
-- [`Node >= 16` ![NodeJS](https://img.shields.io/badge/node.js-6DA55F?logo=node.js&logoColor=white)](https://nodejs.org)
+- [`Node` ![NodeJS](https://img.shields.io/badge/node.js-6DA55F?logo=node.js&logoColor=white)](https://nodejs.org)
 - [`Deno` ![Deno JS](https://img.shields.io/badge/deno%20js-000000?logo=deno&logoColor=white)](https://deno.com/runtime)
-- [`Bun >= 0.6.0` ![Bun](https://img.shields.io/badge/Bun-%23000000.svg?logoColor=white)](https://bun.sh/)
+- [`Bun` ![Bun](https://img.shields.io/badge/Bun-%23000000.svg?logoColor=white)](https://bun.sh/)
 - `Web` ![HTML5](https://img.shields.io/badge/html5-%23E34F26.svg?logoColor=white)
 
-### Yarn / NPM / Bun
-
-For convenience, all main types are also exported through [`@rimbu/core`](../core).
-
-To install this package only:
+### Package Managers
 
-For `yarn`:
+**Yarn:**
 
-> `yarn add @rimbu/deep`
-
-For `npm`:
+```sh
+yarn add @rimbu/deep
+```
 
-> `npm i @rimbu/deep`
+**npm:**
 
-For `bun`:
+```sh
+npm install @rimbu/deep
+```
 
-> `bun add @rimbu/deep`
+**Bun:**
 
-### Deno
+```sh
+bun add @rimbu/deep
+```
 
-For Deno, the following approach is recommended:
+### Deno Setup
 
-In the root folder of your project, create or edit a file called `import_map.json` with the following contents (where you should replace `x.y.z` with the desired version of Rimbu):
+Create or edit `import_map.json` in your project root:
 
 ```json
 {
@@ -55,7 +67,7 @@ In the root folder of your project, create or edit a file called `import_map.jso
 }
 ```
 
-**Note: The trailing slashes are important!**
+_Replace `x.y.z` with the desired version._
 
 In this way you can use relative imports from Rimbu in your code, like so:
 
@@ -93,20 +105,18 @@ console.log(
 
 ## Author
 
-[Arvid Nicolaas](https://github.com/vitoke)
+Created and maintained by [Arvid Nicolaas](https://github.com/vitoke).
 
 ## Contributing
 
-Feel very welcome to contribute to further improve Rimbu. Please read our [Contributing guide](https://github.com/rimbu-org/rimbu/blob/main/CONTRIBUTING.md).
+We welcome contributions! Please read our [Contributing guide](https://github.com/rimbu-org/rimbu/blob/main/CONTRIBUTING.md).
 
 ## Contributors
 
 <img src = "https://contrib.rocks/image?repo=rimbu-org/rimbu"/>
 
-Made with [contributors-img](https://contrib.rocks).
+_Made with [contributors-img](https://contrib.rocks)._
 
 ## License
 
-Licensed under the MIT License, Copyright © 2020-present Arvid Nicolaas.
-
-See [LICENSE](./LICENSE) for more information.
+This project is licensed under the MIT License. See the [LICENSE](./LICENSE) for details.

package/dist/bun/deep.mts

@@ -185,7 +185,7 @@ export function selectWith<T, SL extends Selector<T>>(
 export function selectAt<
   T,
   P extends Path.Get<T>,
-  SL extends Selector<Path.Result<T, P>>
+  SL extends Selector<Path.Result<T, P>>,
 >(
   source: T,
   path: P,
@@ -211,7 +211,7 @@ export function selectAt<
 export function selectAtWith<
   T,
   P extends Path.Get<T>,
-  SL extends Selector<Path.Result<T, P>>
+  SL extends Selector<Path.Result<T, P>>,
 >(
   path: P,
   selector: Selector.Shape<SL>

package/dist/bun/match.mts

@@ -28,25 +28,31 @@ export namespace Match {
    * @typeparam P - the parent type
    * @typeparam R - the root object type
    */
-  export type Entry<T, C, P, R> = IsAnyFunc<T> extends true
-    ? // function can only be directly matched
-      T
-    : IsPlainObj<T> extends true
-    ? // determine allowed match values for object
-      Match.WithResult<T, P, R, Match.Obj<T, C, P, R>>
-    : IsArray<T> extends true
-    ? // determine allowed match values for array or tuple
-      | Match.Arr<T, C, P, R>
-        | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
-        | Match.Func<
-            T,
-            P,
-            R,
+  export type Entry<T, C, P, R> =
+    IsAnyFunc<T> extends true
+      ? // function can only be directly matched
+        T
+      : IsPlainObj<T> extends true
+        ? // determine allowed match values for object
+          Match.WithResult<T, P, R, Match.Obj<T, C, P, R>>
+        : IsArray<T> extends true
+          ? // determine allowed match values for array or tuple
             | Match.Arr<T, C, P, R>
-            | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
-          >
-    : // only accept values with same interface
-      Match.WithResult<T, P, R, { [K in keyof C]: C[K & keyof T] }>;
+              | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]
+              | Match.Func<
+                  T,
+                  P,
+                  R,
+                  | Match.Arr<T, C, P, R>
+                  | Match.Entry<
+                      T[number & keyof T],
+                      C[number & keyof C],
+                      P,
+                      R
+                    >[]
+                >
+          : // only accept values with same interface
+            Match.WithResult<T, P, R, { [K in keyof C]: C[K & keyof T] }>;
 
   /**
    * The type that determines allowed matchers for objects.
@@ -136,7 +142,7 @@ export namespace Match {
    */
   export type CompoundForObj<T, C, P, R> = [
     Match.CompoundType,
-    ...Match.Entry<T, C, P, R>[]
+    ...Match.Entry<T, C, P, R>[],
   ];
 
   /**
@@ -272,9 +278,7 @@ function matchEntry<T, C, P, R>(
   // already determined above that the source and matcher are not equal
 
   failureLog?.push(
-    `value ${JSON.stringify(
-      source
-    )} does not match given matcher ${JSON.stringify(matcher)}`
+    `value ${JSON.stringify(source)} does not match given matcher ${JSON.stringify(matcher)}`
   );
 
   return false;
@@ -469,9 +473,7 @@ function matchPlainObj<T extends object, C, P, R>(
       // the source does not have the given key
 
       failureLog?.push(
-        `key ${key} is specified in matcher but not present in value ${JSON.stringify(
-          source
-        )}`
+        `key ${key} is specified in matcher but not present in value ${JSON.stringify(source)}`
       );
 
       return false;

package/dist/bun/patch.mts

@@ -22,15 +22,16 @@ export namespace Patch {
    * @typeparam P - the parent type
    * @typeparam R - the root object type
    */
-  export type Entry<T, C, P, R> = IsAnyFunc<T> extends true
-    ? T
-    : IsPlainObj<T> extends true
-    ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>>
-    : Tuple.IsTuple<T> extends true
-    ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>>
-    : IsArray<T> extends true
-    ? Patch.WithResult<T, P, R, T>
-    : Patch.WithResult<T, P, R, T>;
+  export type Entry<T, C, P, R> =
+    IsAnyFunc<T> extends true
+      ? T
+      : IsPlainObj<T> extends true
+        ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>>
+        : Tuple.IsTuple<T> extends true
+          ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>>
+          : IsArray<T> extends true
+            ? Patch.WithResult<T, P, R, T>
+            : Patch.WithResult<T, P, R, T>;
 
   /**
    * Either result type S, or a patch function with the value type, the parent type, and the root type.

package/dist/bun/path.mts

@@ -36,7 +36,7 @@ export namespace Path {
       T,
       Write extends boolean,
       Maybe extends boolean,
-      First extends boolean = false
+      First extends boolean = false,
     > = `${IsAnyFunc<T> extends true
       ? // functions can not be further decomposed
         ''
@@ -54,20 +54,21 @@ export namespace Path {
       T,
       Write extends boolean,
       Maybe extends boolean,
-      First extends boolean
-    > = Path.Internal.IsOptional<T> extends true
-      ? // the value T may be null or undefined, check whether further chaining is allowed
-        Write extends false
-        ? // path is not used to write to, so optional chaining is allowed
-          Path.Internal.Generic<Exclude<T, undefined | null>, Write, true>
-        : // path can be written to, no optional chaining allowed
-          never
-      : // determine separator, and continue with non-optional value
-        `${Path.Internal.Separator<
-          First,
-          Maybe,
-          IsArray<T>
-        >}${Path.Internal.NonOptional<T, Write, Maybe>}`;
+      First extends boolean,
+    > =
+      Path.Internal.IsOptional<T> extends true
+        ? // the value T may be null or undefined, check whether further chaining is allowed
+          Write extends false
+          ? // path is not used to write to, so optional chaining is allowed
+            Path.Internal.Generic<Exclude<T, undefined | null>, Write, true>
+          : // path can be written to, no optional chaining allowed
+            never
+        : // determine separator, and continue with non-optional value
+          `${Path.Internal.Separator<
+            First,
+            Maybe,
+            IsArray<T>
+          >}${Path.Internal.NonOptional<T, Write, Maybe>}`;
 
     /**
      * Determines the allowed paths into a non-optional value of type `T`.
@@ -76,25 +77,22 @@ export namespace Path {
      * @typeparam Maybe - if true the value at the current path is optional
      * @typeparam First - if true this is the root call
      */
-    export type NonOptional<
-      T,
-      Write extends boolean,
-      Maybe extends boolean
-    > = Tuple.IsTuple<T> extends true
-      ? // determine allowed paths for tuple
-        Path.Internal.Tup<T, Write, Maybe>
-      : T extends readonly any[]
-      ? // determine allowed paths for array
-        Write extends false
-        ? // path is not writable so arrays are allowed
-          Path.Internal.Arr<T>
-        : // path is writable, no arrays allowed
-          never
-      : IsPlainObj<T> extends true
-      ? // determine allowed paths for object
-        Path.Internal.Obj<T, Write, Maybe>
-      : // no match
-        never;
+    export type NonOptional<T, Write extends boolean, Maybe extends boolean> =
+      Tuple.IsTuple<T> extends true
+        ? // determine allowed paths for tuple
+          Path.Internal.Tup<T, Write, Maybe>
+        : T extends readonly any[]
+          ? // determine allowed paths for array
+            Write extends false
+            ? // path is not writable so arrays are allowed
+              Path.Internal.Arr<T>
+            : // path is writable, no arrays allowed
+              never
+          : IsPlainObj<T> extends true
+            ? // determine allowed paths for object
+              Path.Internal.Obj<T, Write, Maybe>
+            : // no match
+              never;
 
     /**
      * Determines the allowed paths for a tuple. Since tuples have fixed types, they do not
@@ -104,11 +102,7 @@ export namespace Path {
      * @typeparam Maybe - if true the value at the current path is optional
      */
     export type Tup<T, Write extends boolean, Maybe extends boolean> = {
-      [K in Tuple.KeysOf<T>]: `[${K}]${Path.Internal.Generic<
-        T[K],
-        Write,
-        Maybe
-      >}`;
+      [K in Tuple.KeysOf<T>]: `[${K}]${Path.Internal.Generic<T[K], Write, Maybe>}`;
     }[Tuple.KeysOf<T>];
 
     /**
@@ -143,7 +137,7 @@ export namespace Path {
     export type Separator<
       First extends boolean,
       Maybe extends boolean,
-      IsArray extends boolean
+      IsArray extends boolean,
     > = Maybe extends true
       ? First extends true
         ? // first optional value cannot have separator
@@ -151,13 +145,13 @@ export namespace Path {
         : // non-first optional value must have separator
           '?.'
       : First extends true
-      ? // first non-optional value has empty separator
-        ''
-      : IsArray extends true
-      ? // array selectors do not have separator
-        ''
-      : // normal separator
-        '.';
+        ? // first non-optional value has empty separator
+          ''
+        : IsArray extends true
+          ? // array selectors do not have separator
+            ''
+          : // normal separator
+            '.';
 
     /**
      * Determines whether the given type `T` is optional, that is, whether it can be null or undefined.
@@ -169,10 +163,10 @@ export namespace Path {
       ? // is optional
         True
       : null extends T
-      ? // is optional
-        True
-      : // not optional
-        False;
+        ? // is optional
+          True
+        : // not optional
+          False;
 
     /**
      * Returns type `T` if `Maybe` is false, `T | undefined` otherwise.
@@ -190,7 +184,7 @@ export namespace Path {
      */
     export type AppendIfNotEmpty<
       A extends string[],
-      T extends string
+      T extends string,
     > = T extends ''
       ? // empty string, do not add
         A
@@ -224,23 +218,23 @@ export namespace Path {
     export type For<
       T,
       Tokens,
-      Maybe extends boolean = Path.Internal.IsOptional<T>
+      Maybe extends boolean = Path.Internal.IsOptional<T>,
     > = Tokens extends []
       ? // no more token
         Path.Internal.MaybeValue<T, Maybe>
       : Path.Internal.IsOptional<T> extends true
-      ? // T can be null or undefined, so continue with Maybe set to true
-        Path.Result.For<Exclude<T, undefined | null>, Tokens, Maybe>
-      : Tokens extends ['?.', infer Key, ...infer Rest]
-      ? // optional chaining, process first part and set Maybe to true
-        Path.Result.For<Path.Result.Part<T, Key, Maybe>, Rest, true>
-      : Tokens extends ['.', infer Key, ...infer Rest]
-      ? // normal chaining, process first part and continue
-        Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
-      : Tokens extends [infer Key, ...infer Rest]
-      ? // process first part, and continue
-        Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
-      : never;
+        ? // T can be null or undefined, so continue with Maybe set to true
+          Path.Result.For<Exclude<T, undefined | null>, Tokens, Maybe>
+        : Tokens extends ['?.', infer Key, ...infer Rest]
+          ? // optional chaining, process first part and set Maybe to true
+            Path.Result.For<Path.Result.Part<T, Key, Maybe>, Rest, true>
+          : Tokens extends ['.', infer Key, ...infer Rest]
+            ? // normal chaining, process first part and continue
+              Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
+            : Tokens extends [infer Key, ...infer Rest]
+              ? // process first part, and continue
+                Path.Result.For<Path.Result.Part<T, Key, false>, Rest, Maybe>
+              : never;
 
     /**
      * Determines the result of getting the property/index `K` from type `T`, taking into
@@ -249,15 +243,16 @@ export namespace Path {
      * @typeparam K - the key to get from the source type
      * @typeparam Maybe - if true indicates that the path may be undefined
      */
-    export type Part<T, K, Maybe extends boolean> = IsArray<T> extends true
-      ? // for arrays, Maybe needs to be set to true to force optional chaining
-        // for tuples, Maybe should be false
-        Path.Internal.MaybeValue<
-          T[K & keyof T],
-          Tuple.IsTuple<T> extends true ? Maybe : true
-        >
-      : // Return the type at the given key, and take `Maybe` into account
-        Path.Internal.MaybeValue<T[K & keyof T], Maybe>;
+    export type Part<T, K, Maybe extends boolean> =
+      IsArray<T> extends true
+        ? // for arrays, Maybe needs to be set to true to force optional chaining
+          // for tuples, Maybe should be false
+          Path.Internal.MaybeValue<
+            T[K & keyof T],
+            Tuple.IsTuple<T> extends true ? Maybe : true
+          >
+        : // Return the type at the given key, and take `Maybe` into account
+          Path.Internal.MaybeValue<T[K & keyof T], Maybe>;
 
     /**
      * Converts a path string into separate tokens in a string array.
@@ -268,31 +263,35 @@ export namespace Path {
     export type Tokenize<
       P extends string,
       Token extends string = '',
-      Res extends string[] = []
+      Res extends string[] = [],
     > = P extends ''
       ? // no more input to process, return result
         Path.Internal.AppendIfNotEmpty<Res, Token>
       : P extends `[${infer Index}]${infer Rest}`
-      ? // input is an array selector, append index to tokens. Continue with new token
-        Tokenize<
-          Rest,
-          '',
-          [...Path.Internal.AppendIfNotEmpty<Res, Token>, Index]
-        >
-      : P extends `?.${infer Rest}`
-      ? // optional chaining, append to tokens. Continue with new token
-        Tokenize<
-          Rest,
-          '',
-          [...Path.Internal.AppendIfNotEmpty<Res, Token>, '?.']
-        >
-      : P extends `.${infer Rest}`
-      ? // normal chaining, append to tokens. Continue with new token
-        Tokenize<Rest, '', [...Path.Internal.AppendIfNotEmpty<Res, Token>, '.']>
-      : P extends `${infer First}${infer Rest}`
-      ? // process next character
-        Tokenize<Rest, `${Token}${First}`, Res>
-      : never;
+        ? // input is an array selector, append index to tokens. Continue with new token
+          Tokenize<
+            Rest,
+            '',
+            [...Path.Internal.AppendIfNotEmpty<Res, Token>, Index]
+          >
+        : P extends `?.${infer Rest}`
+          ? // optional chaining, append to tokens. Continue with new token
+            Tokenize<
+              Rest,
+              '',
+              [...Path.Internal.AppendIfNotEmpty<Res, Token>, '?.']
+            >
+          : P extends `.${infer Rest}`
+            ? // normal chaining, append to tokens. Continue with new token
+              Tokenize<
+                Rest,
+                '',
+                [...Path.Internal.AppendIfNotEmpty<Res, Token>, '.']
+              >
+            : P extends `${infer First}${infer Rest}`
+              ? // process next character
+                Tokenize<Rest, `${Token}${First}`, Res>
+              : never;
   }
 
   /**

package/dist/bun/protected.mts

@@ -11,20 +11,21 @@ import type { IsAny, IsPlainObj } from '@rimbu/base';
  * - Any other type will not be mapped
  * @typeparam T - the input type
  */
-export type Protected<T> = IsAny<T> extends true
-  ? // to prevent infinite recursion, any will be any
-    T
-  : T extends readonly any[] & infer A
-  ? // convert all keys to readonly and all values to `Protected`
-    { readonly [K in keyof A]: Protected<A[K]> }
-  : T extends Map<infer K, infer V>
-  ? ReadonlyMap<Protected<K>, Protected<V>>
-  : T extends Set<infer E>
-  ? ReadonlySet<Protected<E>>
-  : T extends Promise<infer E>
-  ? Promise<Protected<E>>
-  : IsPlainObj<T> extends true
-  ? // convert all keys to readonly and all values to `Protected`
-    { readonly [K in keyof T]: Protected<T[K]> }
-  : // nothing to do, just return `T`
-    T;
+export type Protected<T> =
+  IsAny<T> extends true
+    ? // to prevent infinite recursion, any will be any
+      T
+    : T extends readonly any[] & infer A
+      ? // convert all keys to readonly and all values to `Protected`
+        { readonly [K in keyof A]: Protected<A[K]> }
+      : T extends Map<infer K, infer V>
+        ? ReadonlyMap<Protected<K>, Protected<V>>
+        : T extends Set<infer E>
+          ? ReadonlySet<Protected<E>>
+          : T extends Promise<infer E>
+            ? Promise<Protected<E>>
+            : IsPlainObj<T> extends true
+              ? // convert all keys to readonly and all values to `Protected`
+                { readonly [K in keyof T]: Protected<T[K]> }
+              : // nothing to do, just return `T`
+                T;

package/dist/bun/selector.mts

@@ -22,32 +22,34 @@ export namespace Selector {
    * Type defining the shape of allowed selectors, used to improve compiler checking.
    * @typeparam SL - the selector type
    */
-  export type Shape<SL> = IsAnyFunc<SL> extends true
-    ? // functions are allowed, type provided by `Selector`
-      SL
-    : IsArray<SL> extends true
-    ? // ensure tuple type is preserved
-      readonly [...(SL extends readonly unknown[] ? SL : never)]
-    : SL extends { readonly [key: string | number | symbol]: unknown }
-    ? // ensure all object properties satisfy `Shape`
-      { readonly [K in keyof SL]: Selector.Shape<SL[K]> }
-    : // nothing to check
-      SL;
+  export type Shape<SL> =
+    IsAnyFunc<SL> extends true
+      ? // functions are allowed, type provided by `Selector`
+        SL
+      : IsArray<SL> extends true
+        ? // ensure tuple type is preserved
+          readonly [...(SL extends readonly unknown[] ? SL : never)]
+        : SL extends { readonly [key: string | number | symbol]: unknown }
+          ? // ensure all object properties satisfy `Shape`
+            { readonly [K in keyof SL]: Selector.Shape<SL[K]> }
+          : // nothing to check
+            SL;
 
   /**
    * Type defining the result type of applying the SL selector type to the T value type.
    * @typeparam T - the source value type
    * @typeparam SL - the selector type
    */
-  export type Result<T, SL> = Selector<T> extends SL
-    ? never
-    : SL extends (...args: any[]) => infer R
-    ? R
-    : SL extends string
-    ? Path.Result<T, SL>
-    : {
-        readonly [K in keyof SL]: Selector.Result<T, SL[K]>;
-      };
+  export type Result<T, SL> =
+    Selector<T> extends SL
+      ? never
+      : SL extends (...args: any[]) => infer R
+        ? R
+        : SL extends string
+          ? Path.Result<T, SL>
+          : {
+              readonly [K in keyof SL]: Selector.Result<T, SL[K]>;
+            };
 }
 
 /**

package/dist/bun/tuple.mts

@@ -138,7 +138,7 @@ export namespace Tuple {
    */
   export function append<
     T extends Tuple.Source,
-    V extends readonly [unknown, ...unknown[]]
+    V extends readonly [unknown, ...unknown[]],
   >(tuple: T, ...values: V): readonly [...T, ...V] {
     return [...tuple, ...values];
   }