| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/badgeurope.eu/node_modules/webpack/lib/util/ |
Upload File : |
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
"use strict";
new Map().entries();
/**
* The StackedCacheMap is a data structure designed as an alternative to a Map
* in situations where you need to handle multiple item additions and
* frequently access the largest map.
*
* It is particularly optimized for efficiently adding multiple items
* at once, which can be achieved using the `addAll` method.
*
* It has a fallback Map that is used when the map to be added is mutable.
*
* Note: `delete` and `has` are not supported for performance reasons.
* @example
* ```js
* const map = new StackedCacheMap();
* map.addAll(new Map([["a", 1], ["b", 2]]), true);
* map.addAll(new Map([["c", 3], ["d", 4]]), true);
* map.get("a"); // 1
* map.get("d"); // 4
* for (const [key, value] of map) {
* console.log(key, value);
* }
* ```
* @template K
* @template V
*/
class StackedCacheMap {
constructor() {
/** @type {Map<K, V>} */
this.map = new Map();
/** @type {ReadonlyMap<K, V>[]} */
this.stack = [];
}
/**
* If `immutable` is true, the map can be referenced by the StackedCacheMap
* and should not be changed afterwards. If the map is mutable, all items
* are copied into a fallback Map.
* @param {ReadonlyMap<K, V>} map map to add
* @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
*/
addAll(map, immutable) {
if (immutable) {
this.stack.push(map);
// largest map should go first
for (let i = this.stack.length - 1; i > 0; i--) {
const beforeLast = this.stack[i - 1];
if (beforeLast.size >= map.size) break;
this.stack[i] = beforeLast;
this.stack[i - 1] = map;
}
} else {
for (const [key, value] of map) {
this.map.set(key, value);
}
}
}
/**
* @param {K} item the key of the element to add
* @param {V} value the value of the element to add
* @returns {void}
*/
set(item, value) {
this.map.set(item, value);
}
/**
* @param {K} item the item to delete
* @returns {void}
*/
delete(item) {
throw new Error("Items can't be deleted from a StackedCacheMap");
}
/**
* @param {K} item the item to test
* @returns {boolean} true if the item exists in this set
*/
has(item) {
throw new Error(
"Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined"
);
}
/**
* @param {K} item the key of the element to return
* @returns {V | undefined} the value of the element
*/
get(item) {
for (const map of this.stack) {
const value = map.get(item);
if (value !== undefined) return value;
}
return this.map.get(item);
}
clear() {
this.stack.length = 0;
this.map.clear();
}
/**
* @returns {number} size of the map
*/
get size() {
let size = this.map.size;
for (const map of this.stack) {
size += map.size;
}
return size;
}
/**
* @returns {Iterator<[K, V]>} iterator
*/
[Symbol.iterator]() {
const iterators = this.stack.map(map => map[Symbol.iterator]());
let current = this.map[Symbol.iterator]();
return {
next() {
let result = current.next();
while (result.done && iterators.length > 0) {
current = /** @type {MapIterator<[K, V]>} */ (iterators.pop());
result = current.next();
}
return result;
}
};
}
}
module.exports = StackedCacheMap;