@develia/commons 0.4.14 → 0.4.16

package/dist/cjs/collections/default-weak-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"default-weak-map.js","sourceRoot":"","sources":["../../../src/collections/default-weak-map.ts"],"names":[],"mappings":";;AAWA,MAAqB,UAAgC,SAAQ,OAAa;IAOtE,YAAY,aAAkC,EAAE,UAAsC,SAAS;QAC3F,KAAK,EAAE,CAAC;QAER,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YAClB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO,IAAI,EAAE,EAAE,CAAC;gBACvC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACzB,CAAC;QACL,CAAC;QAED,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,SAAS,CAAC,wDAAwD,CAAC,CAAC;QAClF,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;IACxC,CAAC;IAMQ,GAAG,CAAC,GAAM;QACf,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACvC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACtB,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;IAC3B,CAAC;CAGJ;AArCD,6BAqCC"}
+{"version":3,"file":"default-weak-map.js","sourceRoot":"","sources":["../../../src/collections/default-weak-map.ts"],"names":[],"mappings":";;AAEA;;;;;;;GAOG;AACH,MAAqB,cAAoC,SAAQ,OAAa;IAG1E;;;OAGG;IACH,YAAY,aAAkC,EAAE,UAAsC,SAAS;QAC3F,KAAK,EAAE,CAAC;QAER,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YAClB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,OAAO,IAAI,EAAE,EAAE,CAAC;gBACvC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACzB,CAAC;QACL,CAAC;QAED,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,SAAS,CAAC,uDAAuD,CAAC,CAAC;QACjF,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;IACxC,CAAC;IAED;;;;;;OAMG;IACM,GAAG,CAAC,GAAM;QACf,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACvC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACtB,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,iFAAiF;QACjF,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;IAC3B,CAAC;CAGJ;AAxCD,iCAwCC","sourcesContent":["import type {Optional, UnaryFunction} from \"../types.js\";\r\n\r\n/**\r\n * DefaultWeakMap<K, V>\r\n * A WeakMap that automatically creates and saves a default value\r\n * when accessing a non-existent key with get(key).\r\n *\r\n * @template K - The type of the keys. Must be an object.\r\n * @template V - The type of the values.\r\n */\r\nexport default class DefaultWeakMap<K extends object, V> extends WeakMap<K, V> {\r\n    private readonly _factoryMethod: (key: K) => V;\r\n\r\n    /**\r\n     * @param {UnaryFunction<K, V>} factoryMethod - Function that produces the default value for a key.\r\n     * @param {Optional<Iterable<[K, V]>>} entries - Initial entries.\r\n     */\r\n    constructor(factoryMethod: UnaryFunction<K, V>, entries: Optional<Iterable<[K, V]>> = undefined) {\r\n        super();\r\n\r\n        if (entries != null) {\r\n            for (const [key, value] of entries ?? []) {\r\n                this.set(key, value);\r\n            }\r\n        }\r\n\r\n        if (typeof factoryMethod !== \"function\") {\r\n            throw new TypeError(\"DefaultWeakMap needs a factory (key => defaultValue).\");\r\n        }\r\n        this._factoryMethod = factoryMethod;\r\n    }\r\n\r\n    /**\r\n     * Gets the value for the key. If it does not exist, it creates it using the factory,\r\n     * saves it, and returns it.\r\n     *\r\n     * @param {K} key - The key to get.\r\n     * @returns {V} The value associated with the key.\r\n     */\r\n    override get(key: K): V {\r\n        if (!super.has(key)) {\r\n            const value = this._factoryMethod(key);\r\n            super.set(key, value);\r\n            return value;\r\n        }\r\n        // ¡super.get puede devolver undefined si no existe! Pero ya comprobamos has(key)\r\n        return super.get(key)!;\r\n    }\r\n\r\n\r\n}\r\n"]}

package/dist/cjs/{from.js → collections/from.js}

@@ -5,8 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Grouping = exports.From = void 0;
 exports.default = from;
-const utilities_js_1 = require("./utilities.js");
-const order_js_1 = __importDefault(require("./order.js"));
+const utilities_js_1 = require("../utilities.js");
+const order_js_1 = __importDefault(require("../order.js"));
+/**
+ * Creates a new From instance from an Iterable or a Supplier of an Iterable.
+ * @template T - The type of elements in the source.
+ * @param {Iterable<T> | Supplier<Iterable<T>>} source - The source data.
+ * @returns {From<T> | From<KeyValuePair<any, any>>} A new From instance.
+ * @throws {string} If source is null or invalid.
+ */
 function from(source) {
     if (source == null)
         throw "Source is null.";
@@ -20,7 +27,16 @@ function from(source) {
     }
     throw "Invalid source.";
 }
+/**
+ * A LINQ-like wrapper for iterables that provides various transformation and query methods.
+ * @template T - The type of elements in the sequence.
+ */
 class From {
+    /**
+     * Creates a From instance from an object's entries.
+     * @param {any} obj - The object to convert to pairs.
+     * @returns {From<KeyValuePair<any, any>>} A From instance of key-value pairs.
+     */
     static object(obj) {
         return new From(function () {
             return (0, utilities_js_1.toPairs)(obj);
@@ -29,14 +45,30 @@ class From {
     constructor(fn) {
         this._fn = fn;
     }
+    /**
+     * Creates a From instance from a supplier function.
+     * @template T
+     * @param {Supplier<Iterable<T>>} callable - A function that returns an Iterable.
+     * @returns {From<T>} A new From instance.
+     */
     static fn(callable) {
         return new From(callable);
     }
-    ;
+    /**
+     * Collects all elements into an array and returns a new From instance from it.
+     * Useful for freezing the sequence and preventing multiple iterations over a generator.
+     * @returns {From<T>} A new From instance with cached data.
+     */
     collect() {
         const cache = Array.from(this);
         return From.iterable(cache);
     }
+    /**
+     * Creates a From instance from an Iterable.
+     * @template T
+     * @param {Iterable<T>} iterable - The source iterable.
+     * @returns {From<T>} A new From instance.
+     */
     static iterable(iterable) {
         return From.fn(function* () {
             for (const item of iterable) {
@@ -44,7 +76,12 @@ class From {
             }
         });
     }
-    ;
+    /**
+     * Maps each element of the sequence into a new form.
+     * @template R
+     * @param {UnaryFunction<T, R>} mapper - A transformation function.
+     * @returns {From<R>} A new From instance with the mapped elements.
+     */
     map(mapper) {
         const self = this;
         return From.fn(function* () {
@@ -56,6 +93,11 @@ class From {
     *[Symbol.iterator]() {
         yield* this._fn();
     }
+    /**
+     * Checks if all elements in the sequence satisfy the given predicate.
+     * @param {Predicate<T>} predicate - A function to test each element.
+     * @returns {boolean} True if all elements satisfy the predicate.
+     */
     all(predicate) {
         for (let item of this._fn()) {
             if (!predicate(item)) {
@@ -64,6 +106,12 @@ class From {
         }
         return true;
     }
+    /**
+     * Checks if any element in the sequence satisfies the given predicate.
+     * If no predicate is provided, checks if the sequence is not empty.
+     * @param {Optional<Predicate<T>>} predicate - A function to test each element.
+     * @returns {boolean} True if any element satisfies the predicate.
+     */
     any(predicate = undefined) {
         for (let item of this) {
             if (predicate == null || predicate(item)) {
@@ -72,9 +120,19 @@ class From {
         }
         return false;
     }
+    /**
+     * Gets the number of elements in the sequence.
+     * @returns {number} The count of elements.
+     */
     get length() {
         return this.count();
     }
+    /**
+     * Counts the number of elements that satisfy the given predicate.
+     * If no predicate is provided, counts all elements.
+     * @param {Optional<Predicate<T>>} predicate - A function to test each element.
+     * @returns {number} The count of elements.
+     */
     count(predicate = undefined) {
         let output = 0;
         for (let item of this) {
@@ -84,6 +142,11 @@ class From {
         }
         return output;
     }
+    /**
+     * Filters the sequence based on a predicate.
+     * @param {Predicate<T>} predicate - A function to test each element.
+     * @returns {From<T>} A new From instance with the filtered elements.
+     */
     filter(predicate) {
         const self = this;
         return From.fn(function* () {
@@ -94,6 +157,11 @@ class From {
             }
         });
     }
+    /**
+     * Checks if the sequence contains a specific value.
+     * @param {T} value - The value to search for.
+     * @returns {boolean} True if the value is found.
+     */
     contains(value) {
         for (let item of this) {
             if (item === value) {
@@ -102,6 +170,11 @@ class From {
         }
         return false;
     }
+    /**
+     * Returns the first element of the sequence that satisfies a condition.
+     * @param {Predicate<T>} [predicate] - Optional condition.
+     * @returns {T | undefined} The first element or undefined.
+     */
     first(predicate) {
         if (predicate) {
             for (let item of this) {
@@ -111,12 +184,19 @@ class From {
             }
         }
         else {
+            // noinspection LoopStatementThatDoesntLoopJS
             for (let item of this) {
                 return item;
             }
         }
         return undefined;
     }
+    /**
+     * Returns the only element of the sequence that satisfies a condition, or throws if more than one exists.
+     * @param {Predicate<T>} [predicate] - Optional condition.
+     * @returns {T | null} The single element or null if not found.
+     * @throws {Error} If more than one element is found.
+     */
     single(predicate) {
         let found = false;
         let output = null;
@@ -132,6 +212,7 @@ class From {
             }
         }
         else {
+            // noinspection LoopStatementThatDoesntLoopJS
             for (let item of this) {
                 if (found) {
                     throw new Error("Sequence contains more than one element.");
@@ -142,6 +223,11 @@ class From {
         }
         return output;
     }
+    /**
+     * Appends an item to the end of the sequence.
+     * @param {T} item - The item to append.
+     * @returns {From<T>} A new From instance.
+     */
     append(item) {
         const self = this;
         return From.fn(function* () {
@@ -151,6 +237,11 @@ class From {
             yield item;
         });
     }
+    /**
+     * Prepends an item to the beginning of the sequence.
+     * @param {T} item - The item to prepend.
+     * @returns {From<T>} A new From instance.
+     */
     prepend(item) {
         const self = this;
         return From.fn(function* () {
@@ -160,6 +251,11 @@ class From {
             }
         });
     }
+    /**
+     * Gets the element at a specific index.
+     * @param {number} index - The zero-based index.
+     * @returns {T | undefined} The element at the index or undefined.
+     */
     at(index) {
         let idx = 0;
         for (let item of this) {
@@ -169,6 +265,11 @@ class From {
         }
         return undefined;
     }
+    /**
+     * Returns the last element of the sequence that satisfies a condition.
+     * @param {Predicate<T>} [predicate] - Optional condition.
+     * @returns {T | undefined} The last element or undefined.
+     */
     last(predicate) {
         let last = undefined;
         if (predicate)
@@ -184,6 +285,12 @@ class From {
         }
         return last;
     }
+    /**
+     * Projects each element of a sequence to an Iterable and flattens the resulting sequences into one sequence.
+     * @template R
+     * @param {UnaryFunction<T, Iterable<R>>} mapper - A transformation function.
+     * @returns {From<R>} A new From instance.
+     */
     mapMany(mapper) {
         const self = this;
         return From.fn(function* () {
@@ -195,6 +302,10 @@ class From {
             }
         });
     }
+    /**
+     * Flattens a sequence of iterables.
+     * @returns {From<any>} A new From instance.
+     */
     flatten() {
         const self = this;
         return From.fn(function* () {
@@ -206,6 +317,11 @@ class From {
             }
         });
     }
+    /**
+     * Calculates the sum of the elements in the sequence.
+     * @param {UnaryFunction<T, number>} [mapper] - Optional projection function.
+     * @returns {number} The sum.
+     */
     sum(mapper) {
         let total = 0;
         if (mapper)
@@ -218,6 +334,11 @@ class From {
             }
         return total;
     }
+    /**
+     * Calculates the average of the elements in the sequence.
+     * @param {UnaryFunction<T, number>} [mapper] - Optional projection function.
+     * @returns {number} The average.
+     */
     avg(mapper) {
         let total = 0;
         let count = 0;
@@ -233,6 +354,11 @@ class From {
             }
         return count > 0 ? total / count : 0;
     }
+    /**
+     * Returns the maximum value in the sequence.
+     * @param {UnaryFunction<T, number>} mapper - Projection function.
+     * @returns {number} The maximum value.
+     */
     max(mapper) {
         let max = -Infinity;
         for (let item of this) {
@@ -241,6 +367,11 @@ class From {
         }
         return max;
     }
+    /**
+     * Returns the minimum value in the sequence.
+     * @param {UnaryFunction<T, number>} mapper - Projection function.
+     * @returns {number} The minimum value.
+     */
     min(mapper) {
         let min = Infinity;
         for (let item of this) {
@@ -249,6 +380,11 @@ class From {
         }
         return min;
     }
+    /**
+     * Returns the element with the maximum value.
+     * @param {UnaryFunction<T, number>} mapper - Projection function.
+     * @returns {T | undefined} The element with the maximum value.
+     */
     maxBy(mapper) {
         let max = -Infinity;
         let maxItem;
@@ -261,6 +397,11 @@ class From {
         }
         return maxItem;
     }
+    /**
+     * Returns the element with the minimum value.
+     * @param {UnaryFunction<T, number>} mapper - Projection function.
+     * @returns {T | undefined} The element with the minimum value.
+     */
     minBy(mapper) {
         let min = Infinity;
         let minItem;
@@ -273,6 +414,13 @@ class From {
         }
         return minItem;
     }
+    /**
+     * Sorts the elements of the sequence.
+     * @template R
+     * @param {UnaryFunction<T, R>} mapper - Projection function for the key to sort by.
+     * @param {Order} [order] - Ascending or Descending.
+     * @returns {From<T>} A new From instance.
+     */
     orderBy(mapper, order = order_js_1.default.Ascending) {
         const array = Array.from(this._fn());
         if (order == order_js_1.default.Ascending) {
@@ -294,6 +442,13 @@ class From {
         }
         return From.iterable(array);
     }
+    /**
+     * Groups the elements of the sequence.
+     * @template TKey
+     * @param {UnaryFunction<T, TKey>} keySelector - Function to extract the key for each element.
+     * @param {EqualityComparer<TKey>} [equalityComparer] - Optional comparer for keys.
+     * @returns {From<Grouping<TKey, T>>} A new From instance.
+     */
     groupBy(keySelector, equalityComparer) {
         equalityComparer = (equalityComparer == null ? utilities_js_1.shallowEqual : equalityComparer);
         const self = this;
@@ -316,6 +471,11 @@ class From {
             yield* groups.map(([key, values]) => new Grouping(key, values));
         });
     }
+    /**
+     * Returns a specified number of contiguous elements from the start of the sequence.
+     * @param {number} n - The number of elements to return.
+     * @returns {From<T>} A new From instance.
+     */
     head(n) {
         const self = this;
         return From.fn(function* () {
@@ -330,6 +490,11 @@ class From {
             }
         });
     }
+    /**
+     * Returns a specified number of contiguous elements from the end of the sequence.
+     * @param {number} n - The number of elements to return.
+     * @returns {From<T>} A new From instance.
+     */
     tail(n) {
         const self = this;
         return From.fn(function* () {
@@ -343,14 +508,29 @@ class From {
             yield* buffer;
         });
     }
+    /**
+     * Performs the specified action on each element of the sequence.
+     * @param {Consumer<T>} action - The action to perform.
+     */
     forEach(action) {
         for (let item of this) {
             action(item);
         }
     }
+    /**
+     * Converts the sequence to an array.
+     * @returns {T[]} The array.
+     */
     toArray() {
         return Array.from(this);
     }
+    /**
+     * Converts the sequence to a record.
+     * @template R
+     * @param {UnaryFunction<T, string | symbol | number>} keySelector - Key selector.
+     * @param {UnaryFunction<T, R>} valueSelector - Value selector.
+     * @returns {Record<string | symbol | number, R>} The record.
+     */
     toRecord(keySelector, valueSelector) {
         const output = {};
         for (let item of this) {
@@ -358,6 +538,13 @@ class From {
         }
         return output;
     }
+    /**
+     * Converts the sequence to a Map.
+     * @template RKey, RValue
+     * @param {UnaryFunction<T, RKey>} keySelector - Key selector.
+     * @param {UnaryFunction<T, RValue>} valueSelector - Value selector.
+     * @returns {Map<RKey, RValue>} The map.
+     */
     toMap(keySelector, valueSelector) {
         const map = new Map();
         for (let item of this) {
@@ -367,9 +554,19 @@ class From {
         }
         return map;
     }
+    /**
+     * Returns elements that are instances of a specific primitive type.
+     * @param {string} type - The type string (e.g., 'string', 'number').
+     * @returns {From<T>} A new From instance.
+     */
     instancesOf(type) {
         return this.filter(item => typeof item === type);
     }
+    /**
+     * Checks if all elements are instances of a specific class.
+     * @param {new (...args: any[]) => any} type - The class constructor.
+     * @returns {boolean} True if all elements are instances of the type.
+     */
     allInstanceOf(type) {
         for (let item of this) {
             if (!(item instanceof type)) {
@@ -378,6 +575,11 @@ class From {
         }
         return true;
     }
+    /**
+     * Returns distinct elements from the sequence.
+     * @param {EqualityComparer<T>} [eq_comparer] - Optional equality comparer.
+     * @returns {From<T>} A new From instance.
+     */
     distinct(eq_comparer) {
         if (eq_comparer == null)
             eq_comparer = utilities_js_1.shallowEqual;
@@ -392,6 +594,12 @@ class From {
             }
         });
     }
+    /**
+     * Inserts an item at a specific index.
+     * @param {T} item - The item to insert.
+     * @param {number} index - The zero-based index.
+     * @returns {From<T>} A new From instance.
+     */
     insert(item, index) {
         const self = this;
         return From.fn(function* () {
@@ -410,6 +618,11 @@ class From {
             }
         });
     }
+    /**
+     * Bypasses a specified number of elements in a sequence and then returns the remaining elements.
+     * @param {number} n - The number of elements to skip.
+     * @returns {From<T>} A new From instance.
+     */
     skip(n) {
         const self = this;
         return From.fn(function* () {
@@ -422,6 +635,11 @@ class From {
             }
         });
     }
+    /**
+     * Concatenates two sequences.
+     * @param {Iterable<T>} other - The other sequence.
+     * @returns {From<T>} A new From instance.
+     */
     union(other) {
         const self = this;
         return From.fn(function* () {
@@ -429,6 +647,15 @@ class From {
             yield* other;
         });
     }
+    /**
+     * Correlates the elements of two sequences based on matching keys.
+     * @template T2, R, R2
+     * @param {Iterable<T2>} other - The other sequence.
+     * @param {UnaryFunction<T, R>} thisKeySelector - Key selector for this sequence.
+     * @param {UnaryFunction<T2, R>} otherKeySelector - Key selector for the other sequence.
+     * @param {(thisItem: T, otherItem: T2) => R2} resultSelector - Function to create a result element from two matching elements.
+     * @returns {From<R2>} A new From instance.
+     */
     innerJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
         const self = this;
         return From.fn(() => {
@@ -441,6 +668,15 @@ class From {
                 .map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
         });
     }
+    /**
+     * Performs a left join on two sequences.
+     * @template U, K, R
+     * @param {Iterable<U>} other - The other sequence.
+     * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
+     * @param {UnaryFunction<U, K>} otherKeySelector - Key selector for the other sequence.
+     * @param {(thisItem: T, otherItem: U | undefined) => R} resultSelector - Function to create a result element.
+     * @returns {From<R>} A new From instance.
+     */
     leftJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
         const self = this;
         return From.fn(() => {
@@ -451,6 +687,15 @@ class From {
             return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
         });
     }
+    /**
+     * Performs a left group join on two sequences.
+     * @template U, K, R
+     * @param {Iterable<U>} other - The other sequence.
+     * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
+     * @param {UnaryFunction<U, K>} otherKeySelector - Key selector for the other sequence.
+     * @param {(thisItem: T, otherItems: Array<U>) => R} resultSelector - Function to create a result element.
+     * @returns {From<R>} A new From instance.
+     */
     leftGroupJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
         const self = this;
         return From.fn(() => {
@@ -465,6 +710,15 @@ class From {
             return Array.from(self).map(item => resultSelector(item, otherByKeys.get(thisKeySelector(item)) || []));
         });
     }
+    /**
+     * Performs a right group join on two sequences.
+     * @template U, K, R
+     * @param {Iterable<U>} other - The other sequence.
+     * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
+     * @param {UnaryFunction<U, K>} otherKeySelector - Key selector for the other sequence.
+     * @param {(thisItems: Array<T>, otherItem: U) => R} resultSelector - Function to create a result element.
+     * @returns {From<R>} A new From instance.
+     */
     rightGroupJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
         const self = this;
         return From.fn(() => {
@@ -479,6 +733,15 @@ class From {
             return Array.from(other).map(item => resultSelector(thisByKeys.get(otherKeySelector(item)) || [], item));
         });
     }
+    /**
+     * Performs a right join on two sequences.
+     * @template U, K, R
+     * @param {Iterable<U>} other - The other sequence.
+     * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
+     * @param {UnaryFunction<U, K>} otherKeySelector - Key selector for the other sequence.
+     * @param {(thisItem: T | undefined, otherItem: U) => R} resultSelector - Function to create a result element.
+     * @returns {From<R>} A new From instance.
+     */
     rightJoin(other, thisKeySelector, otherKeySelector, resultSelector) {
         const self = this;
         return From.fn(() => {
@@ -491,10 +754,21 @@ class From {
     }
 }
 exports.From = From;
+/**
+ * Represents a group of elements that have a common key.
+ * @template TKey, T
+ */
 class Grouping extends From {
+    /**
+     * Gets the key of the group.
+     */
     get key() {
         return this._key;
     }
+    /**
+     * @param {TKey} key - The group key.
+     * @param {Array<T>} values - The values in the group.
+     */
     constructor(key, values) {
         super(() => values);
         this._key = key;