@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/libs/mnemonist.mjs

@@ -0,0 +1,1978 @@
+import { r as __toESM, t as __commonJSMin } from "../rolldown-runtime.mjs";
+import { a as require_iterator, i as require_typed_arrays, o as require_foreach, r as require_iterables } from "./graphology-dag.mjs";
+
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/bi-map.js
+var require_bi_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist BiMap
+	* ================
+	*
+	* JavaScript implementation of a BiMap.
+	*/
+	var forEach = require_foreach();
+	/**
+	* Inverse Map.
+	*
+	* @constructor
+	*/
+	function InverseMap(original) {
+		this.size = 0;
+		this.items = /* @__PURE__ */ new Map();
+		this.inverse = original;
+	}
+	/**
+	* BiMap.
+	*
+	* @constructor
+	*/
+	function BiMap() {
+		this.size = 0;
+		this.items = /* @__PURE__ */ new Map();
+		this.inverse = new InverseMap(this);
+	}
+	/**
+	* Method used to clear the map.
+	*
+	* @return {undefined}
+	*/
+	function clear() {
+		this.size = 0;
+		this.items.clear();
+		this.inverse.items.clear();
+	}
+	BiMap.prototype.clear = clear;
+	InverseMap.prototype.clear = clear;
+	/**
+	* Method used to set a relation.
+	*
+	* @param  {any} key - Key.
+	* @param  {any} value - Value.
+	* @return {BiMap|InverseMap}
+	*/
+	function set(key, value) {
+		if (this.items.has(key)) {
+			var currentValue = this.items.get(key);
+			if (currentValue === value) return this;
+			else this.inverse.items.delete(currentValue);
+		}
+		if (this.inverse.items.has(value)) {
+			var currentKey = this.inverse.items.get(value);
+			if (currentKey === key) return this;
+			else this.items.delete(currentKey);
+		}
+		this.items.set(key, value);
+		this.inverse.items.set(value, key);
+		this.size = this.items.size;
+		this.inverse.size = this.inverse.items.size;
+		return this;
+	}
+	BiMap.prototype.set = set;
+	InverseMap.prototype.set = set;
+	/**
+	* Method used to delete a relation.
+	*
+	* @param  {any} key - Key.
+	* @return {boolean}
+	*/
+	function del(key) {
+		if (this.items.has(key)) {
+			var currentValue = this.items.get(key);
+			this.items.delete(key);
+			this.inverse.items.delete(currentValue);
+			this.size = this.items.size;
+			this.inverse.size = this.inverse.items.size;
+			return true;
+		}
+		return false;
+	}
+	BiMap.prototype.delete = del;
+	InverseMap.prototype.delete = del;
+	[
+		"has",
+		"get",
+		"forEach",
+		"keys",
+		"values",
+		"entries"
+	].forEach(function(name) {
+		BiMap.prototype[name] = InverseMap.prototype[name] = function() {
+			return Map.prototype[name].apply(this.items, arguments);
+		};
+	});
+	/**
+	* Attaching the #.values method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") {
+		BiMap.prototype[Symbol.iterator] = BiMap.prototype.entries;
+		InverseMap.prototype[Symbol.iterator] = InverseMap.prototype.entries;
+	}
+	/**
+	* Convenience known methods.
+	*/
+	BiMap.prototype.inspect = function() {
+		var dummy = {
+			left: this.items,
+			right: this.inverse.items
+		};
+		Object.defineProperty(dummy, "constructor", {
+			value: BiMap,
+			enumerable: false
+		});
+		return dummy;
+	};
+	if (typeof Symbol !== "undefined") BiMap.prototype[Symbol.for("nodejs.util.inspect.custom")] = BiMap.prototype.inspect;
+	InverseMap.prototype.inspect = function() {
+		var dummy = {
+			left: this.inverse.items,
+			right: this.items
+		};
+		Object.defineProperty(dummy, "constructor", {
+			value: InverseMap,
+			enumerable: false
+		});
+		return dummy;
+	};
+	if (typeof Symbol !== "undefined") InverseMap.prototype[Symbol.for("nodejs.util.inspect.custom")] = InverseMap.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a bimap.
+	*
+	* @param  {Iterable} iterable - Target iterable.
+	* @return {BiMap}
+	*/
+	BiMap.from = function(iterable) {
+		var bimap = new BiMap();
+		forEach(iterable, function(value, key) {
+			bimap.set(key, value);
+		});
+		return bimap;
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = BiMap;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/default-map.js
+var require_default_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist DefaultMap
+	* =====================
+	*
+	* JavaScript implementation of a default map that will return a constructed
+	* value any time one tries to access an inexisting key. It's quite similar
+	* to python's defaultdict.
+	*/
+	/**
+	* DefaultMap.
+	*
+	* @constructor
+	*/
+	function DefaultMap(factory) {
+		if (typeof factory !== "function") throw new Error("mnemonist/DefaultMap.constructor: expecting a function.");
+		this.items = /* @__PURE__ */ new Map();
+		this.factory = factory;
+		this.size = 0;
+	}
+	/**
+	* Method used to clear the structure.
+	*
+	* @return {undefined}
+	*/
+	DefaultMap.prototype.clear = function() {
+		this.items.clear();
+		this.size = 0;
+	};
+	/**
+	* Method used to get the value set for given key. If the key does not exist,
+	* the value will be created using the provided factory.
+	*
+	* @param  {any} key - Target key.
+	* @return {any}
+	*/
+	DefaultMap.prototype.get = function(key) {
+		var value = this.items.get(key);
+		if (typeof value === "undefined") {
+			value = this.factory(key, this.size);
+			this.items.set(key, value);
+			this.size++;
+		}
+		return value;
+	};
+	/**
+	* Method used to get the value set for given key. If the key does not exist,
+	* a value won't be created.
+	*
+	* @param  {any} key - Target key.
+	* @return {any}
+	*/
+	DefaultMap.prototype.peek = function(key) {
+		return this.items.get(key);
+	};
+	/**
+	* Method used to set a value for given key.
+	*
+	* @param  {any} key   - Target key.
+	* @param  {any} value - Value.
+	* @return {DefaultMap}
+	*/
+	DefaultMap.prototype.set = function(key, value) {
+		this.items.set(key, value);
+		this.size = this.items.size;
+		return this;
+	};
+	/**
+	* Method used to test the existence of a key in the map.
+	*
+	* @param  {any} key   - Target key.
+	* @return {boolean}
+	*/
+	DefaultMap.prototype.has = function(key) {
+		return this.items.has(key);
+	};
+	/**
+	* Method used to delete target key.
+	*
+	* @param  {any} key   - Target key.
+	* @return {boolean}
+	*/
+	DefaultMap.prototype.delete = function(key) {
+		var deleted = this.items.delete(key);
+		this.size = this.items.size;
+		return deleted;
+	};
+	/**
+	* Method used to iterate over each of the key/value pairs.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	DefaultMap.prototype.forEach = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		this.items.forEach(callback, scope);
+	};
+	/**
+	* Iterators.
+	*/
+	DefaultMap.prototype.entries = function() {
+		return this.items.entries();
+	};
+	DefaultMap.prototype.keys = function() {
+		return this.items.keys();
+	};
+	DefaultMap.prototype.values = function() {
+		return this.items.values();
+	};
+	/**
+	* Attaching the #.entries method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") DefaultMap.prototype[Symbol.iterator] = DefaultMap.prototype.entries;
+	/**
+	* Convenience known methods.
+	*/
+	DefaultMap.prototype.inspect = function() {
+		return this.items;
+	};
+	if (typeof Symbol !== "undefined") DefaultMap.prototype[Symbol.for("nodejs.util.inspect.custom")] = DefaultMap.prototype.inspect;
+	/**
+	* Typical factories.
+	*/
+	DefaultMap.autoIncrement = function() {
+		var i = 0;
+		return function() {
+			return i++;
+		};
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = DefaultMap;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/default-weak-map.js
+var require_default_weak_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist DefaultWeakMap
+	* =========================
+	*
+	* JavaScript implementation of a default weak map that will return a constructed
+	* value any time one tries to access an non-existing key. It is similar to
+	* DefaultMap but uses ES6 WeakMap that only holds weak reference to keys.
+	*/
+	/**
+	* DefaultWeakMap.
+	*
+	* @constructor
+	*/
+	function DefaultWeakMap(factory) {
+		if (typeof factory !== "function") throw new Error("mnemonist/DefaultWeakMap.constructor: expecting a function.");
+		this.items = /* @__PURE__ */ new WeakMap();
+		this.factory = factory;
+	}
+	/**
+	* Method used to clear the structure.
+	*
+	* @return {undefined}
+	*/
+	DefaultWeakMap.prototype.clear = function() {
+		this.items = /* @__PURE__ */ new WeakMap();
+	};
+	/**
+	* Method used to get the value set for given key. If the key does not exist,
+	* the value will be created using the provided factory.
+	*
+	* @param  {any} key - Target key.
+	* @return {any}
+	*/
+	DefaultWeakMap.prototype.get = function(key) {
+		var value = this.items.get(key);
+		if (typeof value === "undefined") {
+			value = this.factory(key);
+			this.items.set(key, value);
+		}
+		return value;
+	};
+	/**
+	* Method used to get the value set for given key. If the key does not exist,
+	* a value won't be created.
+	*
+	* @param  {any} key - Target key.
+	* @return {any}
+	*/
+	DefaultWeakMap.prototype.peek = function(key) {
+		return this.items.get(key);
+	};
+	/**
+	* Method used to set a value for given key.
+	*
+	* @param  {any} key   - Target key.
+	* @param  {any} value - Value.
+	* @return {DefaultMap}
+	*/
+	DefaultWeakMap.prototype.set = function(key, value) {
+		this.items.set(key, value);
+		return this;
+	};
+	/**
+	* Method used to test the existence of a key in the map.
+	*
+	* @param  {any} key   - Target key.
+	* @return {boolean}
+	*/
+	DefaultWeakMap.prototype.has = function(key) {
+		return this.items.has(key);
+	};
+	/**
+	* Method used to delete target key.
+	*
+	* @param  {any} key   - Target key.
+	* @return {boolean}
+	*/
+	DefaultWeakMap.prototype.delete = function(key) {
+		return this.items.delete(key);
+	};
+	/**
+	* Convenience known methods.
+	*/
+	DefaultWeakMap.prototype.inspect = function() {
+		return this.items;
+	};
+	if (typeof Symbol !== "undefined") DefaultWeakMap.prototype[Symbol.for("nodejs.util.inspect.custom")] = DefaultWeakMap.prototype.inspect;
+	/**
+	* Exporting.
+	*/
+	module.exports = DefaultWeakMap;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/linked-list.js
+var require_linked_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist Linked List
+	* ======================
+	*
+	* Singly linked list implementation. Uses raw JavaScript objects as nodes
+	* as benchmarks proved it was the fastest thing to do.
+	*/
+	var Iterator = require_iterator(), forEach = require_foreach();
+	/**
+	* Linked List.
+	*
+	* @constructor
+	*/
+	function LinkedList() {
+		this.clear();
+	}
+	/**
+	* Method used to clear the list.
+	*
+	* @return {undefined}
+	*/
+	LinkedList.prototype.clear = function() {
+		this.head = null;
+		this.tail = null;
+		this.size = 0;
+	};
+	/**
+	* Method used to get the first item of the list.
+	*
+	* @return {any}
+	*/
+	LinkedList.prototype.first = function() {
+		return this.head ? this.head.item : void 0;
+	};
+	LinkedList.prototype.peek = LinkedList.prototype.first;
+	/**
+	* Method used to get the last item of the list.
+	*
+	* @return {any}
+	*/
+	LinkedList.prototype.last = function() {
+		return this.tail ? this.tail.item : void 0;
+	};
+	/**
+	* Method used to add an item at the end of the list.
+	*
+	* @param  {any}    item - The item to add.
+	* @return {number}
+	*/
+	LinkedList.prototype.push = function(item) {
+		var node = {
+			item,
+			next: null
+		};
+		if (!this.head) {
+			this.head = node;
+			this.tail = node;
+		} else {
+			this.tail.next = node;
+			this.tail = node;
+		}
+		this.size++;
+		return this.size;
+	};
+	/**
+	* Method used to add an item at the beginning of the list.
+	*
+	* @param  {any}    item - The item to add.
+	* @return {number}
+	*/
+	LinkedList.prototype.unshift = function(item) {
+		var node = {
+			item,
+			next: null
+		};
+		if (!this.head) {
+			this.head = node;
+			this.tail = node;
+		} else {
+			if (!this.head.next) this.tail = this.head;
+			node.next = this.head;
+			this.head = node;
+		}
+		this.size++;
+		return this.size;
+	};
+	/**
+	* Method used to retrieve & remove the first item of the list.
+	*
+	* @return {any}
+	*/
+	LinkedList.prototype.shift = function() {
+		if (!this.size) return void 0;
+		var node = this.head;
+		this.head = node.next;
+		this.size--;
+		return node.item;
+	};
+	/**
+	* Method used to iterate over the list.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	LinkedList.prototype.forEach = function(callback, scope) {
+		if (!this.size) return;
+		scope = arguments.length > 1 ? scope : this;
+		var n = this.head, i = 0;
+		while (n) {
+			callback.call(scope, n.item, i, this);
+			n = n.next;
+			i++;
+		}
+	};
+	/**
+	* Method used to convert the list into an array.
+	*
+	* @return {array}
+	*/
+	LinkedList.prototype.toArray = function() {
+		if (!this.size) return [];
+		var array = new Array(this.size);
+		for (var i = 0, l = this.size, n = this.head; i < l; i++) {
+			array[i] = n.item;
+			n = n.next;
+		}
+		return array;
+	};
+	/**
+	* Method used to create an iterator over a list's values.
+	*
+	* @return {Iterator}
+	*/
+	LinkedList.prototype.values = function() {
+		var n = this.head;
+		return new Iterator(function() {
+			if (!n) return { done: true };
+			var value = n.item;
+			n = n.next;
+			return {
+				value,
+				done: false
+			};
+		});
+	};
+	/**
+	* Method used to create an iterator over a list's entries.
+	*
+	* @return {Iterator}
+	*/
+	LinkedList.prototype.entries = function() {
+		var n = this.head, i = 0;
+		return new Iterator(function() {
+			if (!n) return { done: true };
+			var value = n.item;
+			n = n.next;
+			i++;
+			return {
+				value: [i - 1, value],
+				done: false
+			};
+		});
+	};
+	/**
+	* Attaching the #.values method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") LinkedList.prototype[Symbol.iterator] = LinkedList.prototype.values;
+	/**
+	* Convenience known methods.
+	*/
+	LinkedList.prototype.toString = function() {
+		return this.toArray().join(",");
+	};
+	LinkedList.prototype.toJSON = function() {
+		return this.toArray();
+	};
+	LinkedList.prototype.inspect = function() {
+		var array = this.toArray();
+		Object.defineProperty(array, "constructor", {
+			value: LinkedList,
+			enumerable: false
+		});
+		return array;
+	};
+	if (typeof Symbol !== "undefined") LinkedList.prototype[Symbol.for("nodejs.util.inspect.custom")] = LinkedList.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a list.
+	*
+	* @param  {Iterable} iterable   - Target iterable.
+	* @return {LinkedList}
+	*/
+	LinkedList.from = function(iterable) {
+		var list = new LinkedList();
+		forEach(iterable, function(value) {
+			list.push(value);
+		});
+		return list;
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = LinkedList;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/multi-map.js
+var require_multi_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist MultiMap
+	* ===================
+	*
+	* Implementation of a MultiMap with custom container.
+	*/
+	var Iterator = require_iterator(), forEach = require_foreach();
+	/**
+	* MultiMap.
+	*
+	* @constructor
+	*/
+	function MultiMap(Container) {
+		this.Container = Container || Array;
+		this.items = /* @__PURE__ */ new Map();
+		this.clear();
+		Object.defineProperty(this.items, "constructor", {
+			value: MultiMap,
+			enumerable: false
+		});
+	}
+	/**
+	* Method used to clear the structure.
+	*
+	* @return {undefined}
+	*/
+	MultiMap.prototype.clear = function() {
+		this.size = 0;
+		this.dimension = 0;
+		this.items.clear();
+	};
+	/**
+	* Method used to set a value.
+	*
+	* @param  {any}      key   - Key.
+	* @param  {any}      value - Value to add.
+	* @return {MultiMap}
+	*/
+	MultiMap.prototype.set = function(key, value) {
+		var container = this.items.get(key), sizeBefore;
+		if (!container) {
+			this.dimension++;
+			container = new this.Container();
+			this.items.set(key, container);
+		}
+		if (this.Container === Set) {
+			sizeBefore = container.size;
+			container.add(value);
+			if (sizeBefore < container.size) this.size++;
+		} else {
+			container.push(value);
+			this.size++;
+		}
+		return this;
+	};
+	/**
+	* Method used to delete the given key.
+	*
+	* @param  {any}     key - Key to delete.
+	* @return {boolean}
+	*/
+	MultiMap.prototype.delete = function(key) {
+		var container = this.items.get(key);
+		if (!container) return false;
+		this.size -= this.Container === Set ? container.size : container.length;
+		this.dimension--;
+		this.items.delete(key);
+		return true;
+	};
+	/**
+	* Method used to delete the remove an item in the container stored at the
+	* given key.
+	*
+	* @param  {any}     key - Key to delete.
+	* @return {boolean}
+	*/
+	MultiMap.prototype.remove = function(key, value) {
+		var container = this.items.get(key), wasDeleted, index;
+		if (!container) return false;
+		if (this.Container === Set) {
+			wasDeleted = container.delete(value);
+			if (wasDeleted) this.size--;
+			if (container.size === 0) {
+				this.items.delete(key);
+				this.dimension--;
+			}
+			return wasDeleted;
+		} else {
+			index = container.indexOf(value);
+			if (index === -1) return false;
+			this.size--;
+			if (container.length === 1) {
+				this.items.delete(key);
+				this.dimension--;
+				return true;
+			}
+			container.splice(index, 1);
+			return true;
+		}
+	};
+	/**
+	* Method used to return whether the given keys exists in the map.
+	*
+	* @param  {any}     key - Key to check.
+	* @return {boolean}
+	*/
+	MultiMap.prototype.has = function(key) {
+		return this.items.has(key);
+	};
+	/**
+	* Method used to return the container stored at the given key or `undefined`.
+	*
+	* @param  {any}     key - Key to get.
+	* @return {boolean}
+	*/
+	MultiMap.prototype.get = function(key) {
+		return this.items.get(key);
+	};
+	/**
+	* Method used to return the multiplicity of the given key, meaning the number
+	* of times it is set, or, more trivially, the size of the attached container.
+	*
+	* @param  {any}     key - Key to check.
+	* @return {number}
+	*/
+	MultiMap.prototype.multiplicity = function(key) {
+		var container = this.items.get(key);
+		if (typeof container === "undefined") return 0;
+		return this.Container === Set ? container.size : container.length;
+	};
+	MultiMap.prototype.count = MultiMap.prototype.multiplicity;
+	/**
+	* Method used to iterate over each of the key/value pairs.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	MultiMap.prototype.forEach = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		var key;
+		function inner(value) {
+			callback.call(scope, value, key);
+		}
+		this.items.forEach(function(container, k) {
+			key = k;
+			container.forEach(inner);
+		});
+	};
+	/**
+	* Method used to iterate over each of the associations.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	MultiMap.prototype.forEachAssociation = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		this.items.forEach(callback, scope);
+	};
+	/**
+	* Method returning an iterator over the map's keys.
+	*
+	* @return {Iterator}
+	*/
+	MultiMap.prototype.keys = function() {
+		return this.items.keys();
+	};
+	/**
+	* Method returning an iterator over the map's keys.
+	*
+	* @return {Iterator}
+	*/
+	MultiMap.prototype.values = function() {
+		var iterator = this.items.values(), inContainer = false, countainer, step, i, l;
+		if (this.Container === Set) return new Iterator(function next() {
+			if (!inContainer) {
+				step = iterator.next();
+				if (step.done) return { done: true };
+				inContainer = true;
+				countainer = step.value.values();
+			}
+			step = countainer.next();
+			if (step.done) {
+				inContainer = false;
+				return next();
+			}
+			return {
+				done: false,
+				value: step.value
+			};
+		});
+		return new Iterator(function next() {
+			if (!inContainer) {
+				step = iterator.next();
+				if (step.done) return { done: true };
+				inContainer = true;
+				countainer = step.value;
+				i = 0;
+				l = countainer.length;
+			}
+			if (i >= l) {
+				inContainer = false;
+				return next();
+			}
+			return {
+				done: false,
+				value: countainer[i++]
+			};
+		});
+	};
+	/**
+	* Method returning an iterator over the map's entries.
+	*
+	* @return {Iterator}
+	*/
+	MultiMap.prototype.entries = function() {
+		var iterator = this.items.entries(), inContainer = false, countainer, step, key, i, l;
+		if (this.Container === Set) return new Iterator(function next() {
+			if (!inContainer) {
+				step = iterator.next();
+				if (step.done) return { done: true };
+				inContainer = true;
+				key = step.value[0];
+				countainer = step.value[1].values();
+			}
+			step = countainer.next();
+			if (step.done) {
+				inContainer = false;
+				return next();
+			}
+			return {
+				done: false,
+				value: [key, step.value]
+			};
+		});
+		return new Iterator(function next() {
+			if (!inContainer) {
+				step = iterator.next();
+				if (step.done) return { done: true };
+				inContainer = true;
+				key = step.value[0];
+				countainer = step.value[1];
+				i = 0;
+				l = countainer.length;
+			}
+			if (i >= l) {
+				inContainer = false;
+				return next();
+			}
+			return {
+				done: false,
+				value: [key, countainer[i++]]
+			};
+		});
+	};
+	/**
+	* Method returning an iterator over the map's containers.
+	*
+	* @return {Iterator}
+	*/
+	MultiMap.prototype.containers = function() {
+		return this.items.values();
+	};
+	/**
+	* Method returning an iterator over the map's associations.
+	*
+	* @return {Iterator}
+	*/
+	MultiMap.prototype.associations = function() {
+		return this.items.entries();
+	};
+	/**
+	* Attaching the #.entries method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") MultiMap.prototype[Symbol.iterator] = MultiMap.prototype.entries;
+	/**
+	* Convenience known methods.
+	*/
+	MultiMap.prototype.inspect = function() {
+		return this.items;
+	};
+	if (typeof Symbol !== "undefined") MultiMap.prototype[Symbol.for("nodejs.util.inspect.custom")] = MultiMap.prototype.inspect;
+	MultiMap.prototype.toJSON = function() {
+		return this.items;
+	};
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a structure.
+	*
+	* @param  {Iterable} iterable  - Target iterable.
+	* @param  {Class}    Container - Container.
+	* @return {MultiMap}
+	*/
+	MultiMap.from = function(iterable, Container) {
+		var map = new MultiMap(Container);
+		forEach(iterable, function(value, key) {
+			map.set(key, value);
+		});
+		return map;
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = MultiMap;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/queue.js
+var require_queue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist Queue
+	* ================
+	*
+	* Queue implementation based on the ideas of Queue.js that seems to beat
+	* a LinkedList one in performance.
+	*/
+	var Iterator = require_iterator(), forEach = require_foreach();
+	/**
+	* Queue
+	*
+	* @constructor
+	*/
+	function Queue() {
+		this.clear();
+	}
+	/**
+	* Method used to clear the queue.
+	*
+	* @return {undefined}
+	*/
+	Queue.prototype.clear = function() {
+		this.items = [];
+		this.offset = 0;
+		this.size = 0;
+	};
+	/**
+	* Method used to add an item to the queue.
+	*
+	* @param  {any}    item - Item to enqueue.
+	* @return {number}
+	*/
+	Queue.prototype.enqueue = function(item) {
+		this.items.push(item);
+		return ++this.size;
+	};
+	/**
+	* Method used to retrieve & remove the first item of the queue.
+	*
+	* @return {any}
+	*/
+	Queue.prototype.dequeue = function() {
+		if (!this.size) return;
+		var item = this.items[this.offset];
+		if (++this.offset * 2 >= this.items.length) {
+			this.items = this.items.slice(this.offset);
+			this.offset = 0;
+		}
+		this.size--;
+		return item;
+	};
+	/**
+	* Method used to retrieve the first item of the queue.
+	*
+	* @return {any}
+	*/
+	Queue.prototype.peek = function() {
+		if (!this.size) return;
+		return this.items[this.offset];
+	};
+	/**
+	* Method used to iterate over the queue.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	Queue.prototype.forEach = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		for (var i = this.offset, j = 0, l = this.items.length; i < l; i++, j++) callback.call(scope, this.items[i], j, this);
+	};
+	Queue.prototype.toArray = function() {
+		return this.items.slice(this.offset);
+	};
+	/**
+	* Method used to create an iterator over a queue's values.
+	*
+	* @return {Iterator}
+	*/
+	Queue.prototype.values = function() {
+		var items = this.items, i = this.offset;
+		return new Iterator(function() {
+			if (i >= items.length) return { done: true };
+			var value = items[i];
+			i++;
+			return {
+				value,
+				done: false
+			};
+		});
+	};
+	/**
+	* Method used to create an iterator over a queue's entries.
+	*
+	* @return {Iterator}
+	*/
+	Queue.prototype.entries = function() {
+		var items = this.items, i = this.offset, j = 0;
+		return new Iterator(function() {
+			if (i >= items.length) return { done: true };
+			var value = items[i];
+			i++;
+			return {
+				value: [j++, value],
+				done: false
+			};
+		});
+	};
+	/**
+	* Attaching the #.values method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") Queue.prototype[Symbol.iterator] = Queue.prototype.values;
+	/**
+	* Convenience known methods.
+	*/
+	Queue.prototype.toString = function() {
+		return this.toArray().join(",");
+	};
+	Queue.prototype.toJSON = function() {
+		return this.toArray();
+	};
+	Queue.prototype.inspect = function() {
+		var array = this.toArray();
+		Object.defineProperty(array, "constructor", {
+			value: Queue,
+			enumerable: false
+		});
+		return array;
+	};
+	if (typeof Symbol !== "undefined") Queue.prototype[Symbol.for("nodejs.util.inspect.custom")] = Queue.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a queue.
+	*
+	* @param  {Iterable} iterable   - Target iterable.
+	* @return {Queue}
+	*/
+	Queue.from = function(iterable) {
+		var queue = new Queue();
+		forEach(iterable, function(value) {
+			queue.enqueue(value);
+		});
+		return queue;
+	};
+	/**
+	* Static @.of function taking an arbitrary number of arguments & converting it
+	* into a queue.
+	*
+	* @param  {...any} args
+	* @return {Queue}
+	*/
+	Queue.of = function() {
+		return Queue.from(arguments);
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = Queue;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/lru-cache.js
+var require_lru_cache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist LRUCache
+	* ===================
+	*
+	* JavaScript implementation of the LRU Cache data structure. To save up
+	* memory and allocations this implementation represents its underlying
+	* doubly-linked list as static arrays and pointers. Thus, memory is allocated
+	* only once at instantiation and JS objects are never created to serve as
+	* pointers. This also means this implementation does not trigger too many
+	* garbage collections.
+	*
+	* Note that to save up memory, a LRU Cache can be implemented using a singly
+	* linked list by storing predecessors' pointers as hashmap values.
+	* However, this means more hashmap lookups and would probably slow the whole
+	* thing down. What's more, pointers are not the things taking most space in
+	* memory.
+	*/
+	var Iterator = require_iterator(), forEach = require_foreach(), typed = require_typed_arrays(), iterables = require_iterables();
+	/**
+	* LRUCache.
+	*
+	* @constructor
+	* @param {function} Keys     - Array class for storing keys.
+	* @param {function} Values   - Array class for storing values.
+	* @param {number}   capacity - Desired capacity.
+	*/
+	function LRUCache(Keys, Values, capacity) {
+		if (arguments.length < 2) {
+			capacity = Keys;
+			Keys = null;
+			Values = null;
+		}
+		this.capacity = capacity;
+		if (typeof this.capacity !== "number" || this.capacity <= 0) throw new Error("mnemonist/lru-cache: capacity should be positive number.");
+		else if (!isFinite(this.capacity) || Math.floor(this.capacity) !== this.capacity) throw new Error("mnemonist/lru-cache: capacity should be a finite positive integer.");
+		var PointerArray = typed.getPointerArray(capacity);
+		this.forward = new PointerArray(capacity);
+		this.backward = new PointerArray(capacity);
+		this.K = typeof Keys === "function" ? new Keys(capacity) : new Array(capacity);
+		this.V = typeof Values === "function" ? new Values(capacity) : new Array(capacity);
+		this.size = 0;
+		this.head = 0;
+		this.tail = 0;
+		this.items = {};
+	}
+	/**
+	* Method used to clear the structure.
+	*
+	* @return {undefined}
+	*/
+	LRUCache.prototype.clear = function() {
+		this.size = 0;
+		this.head = 0;
+		this.tail = 0;
+		this.items = {};
+	};
+	/**
+	* Method used to splay a value on top.
+	*
+	* @param  {number}   pointer - Pointer of the value to splay on top.
+	* @return {LRUCache}
+	*/
+	LRUCache.prototype.splayOnTop = function(pointer) {
+		var oldHead = this.head;
+		if (this.head === pointer) return this;
+		var previous = this.backward[pointer], next = this.forward[pointer];
+		if (this.tail === pointer) this.tail = previous;
+		else this.backward[next] = previous;
+		this.forward[previous] = next;
+		this.backward[oldHead] = pointer;
+		this.head = pointer;
+		this.forward[pointer] = oldHead;
+		return this;
+	};
+	/**
+	* Method used to set the value for the given key in the cache.
+	*
+	* @param  {any} key   - Key.
+	* @param  {any} value - Value.
+	* @return {undefined}
+	*/
+	LRUCache.prototype.set = function(key, value) {
+		var pointer = this.items[key];
+		if (typeof pointer !== "undefined") {
+			this.splayOnTop(pointer);
+			this.V[pointer] = value;
+			return;
+		}
+		if (this.size < this.capacity) pointer = this.size++;
+		else {
+			pointer = this.tail;
+			this.tail = this.backward[pointer];
+			delete this.items[this.K[pointer]];
+		}
+		this.items[key] = pointer;
+		this.K[pointer] = key;
+		this.V[pointer] = value;
+		this.forward[pointer] = this.head;
+		this.backward[this.head] = pointer;
+		this.head = pointer;
+	};
+	/**
+	* Method used to set the value for the given key in the cache
+	*
+	* @param  {any} key   - Key.
+	* @param  {any} value - Value.
+	* @return {{evicted: boolean, key: any, value: any}} An object containing the
+	* key and value of an item that was overwritten or evicted in the set
+	* operation, as well as a boolean indicating whether it was evicted due to
+	* limited capacity. Return value is null if nothing was evicted or overwritten
+	* during the set operation.
+	*/
+	LRUCache.prototype.setpop = function(key, value) {
+		var oldValue = null;
+		var oldKey = null;
+		var pointer = this.items[key];
+		if (typeof pointer !== "undefined") {
+			this.splayOnTop(pointer);
+			oldValue = this.V[pointer];
+			this.V[pointer] = value;
+			return {
+				evicted: false,
+				key,
+				value: oldValue
+			};
+		}
+		if (this.size < this.capacity) pointer = this.size++;
+		else {
+			pointer = this.tail;
+			this.tail = this.backward[pointer];
+			oldValue = this.V[pointer];
+			oldKey = this.K[pointer];
+			delete this.items[oldKey];
+		}
+		this.items[key] = pointer;
+		this.K[pointer] = key;
+		this.V[pointer] = value;
+		this.forward[pointer] = this.head;
+		this.backward[this.head] = pointer;
+		this.head = pointer;
+		if (oldKey) return {
+			evicted: true,
+			key: oldKey,
+			value: oldValue
+		};
+		else return null;
+	};
+	/**
+	* Method used to check whether the key exists in the cache.
+	*
+	* @param  {any} key   - Key.
+	* @return {boolean}
+	*/
+	LRUCache.prototype.has = function(key) {
+		return key in this.items;
+	};
+	/**
+	* Method used to get the value attached to the given key. Will move the
+	* related key to the front of the underlying linked list.
+	*
+	* @param  {any} key   - Key.
+	* @return {any}
+	*/
+	LRUCache.prototype.get = function(key) {
+		var pointer = this.items[key];
+		if (typeof pointer === "undefined") return;
+		this.splayOnTop(pointer);
+		return this.V[pointer];
+	};
+	/**
+	* Method used to get the value attached to the given key. Does not modify
+	* the ordering of the underlying linked list.
+	*
+	* @param  {any} key   - Key.
+	* @return {any}
+	*/
+	LRUCache.prototype.peek = function(key) {
+		var pointer = this.items[key];
+		if (typeof pointer === "undefined") return;
+		return this.V[pointer];
+	};
+	/**
+	* Method used to iterate over the cache's entries using a callback.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	LRUCache.prototype.forEach = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		var i = 0, l = this.size;
+		var pointer = this.head, keys = this.K, values = this.V, forward = this.forward;
+		while (i < l) {
+			callback.call(scope, values[pointer], keys[pointer], this);
+			pointer = forward[pointer];
+			i++;
+		}
+	};
+	/**
+	* Method used to create an iterator over the cache's keys from most
+	* recently used to least recently used.
+	*
+	* @return {Iterator}
+	*/
+	LRUCache.prototype.keys = function() {
+		var i = 0, l = this.size;
+		var pointer = this.head, keys = this.K, forward = this.forward;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			var key = keys[pointer];
+			i++;
+			if (i < l) pointer = forward[pointer];
+			return {
+				done: false,
+				value: key
+			};
+		});
+	};
+	/**
+	* Method used to create an iterator over the cache's values from most
+	* recently used to least recently used.
+	*
+	* @return {Iterator}
+	*/
+	LRUCache.prototype.values = function() {
+		var i = 0, l = this.size;
+		var pointer = this.head, values = this.V, forward = this.forward;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			var value = values[pointer];
+			i++;
+			if (i < l) pointer = forward[pointer];
+			return {
+				done: false,
+				value
+			};
+		});
+	};
+	/**
+	* Method used to create an iterator over the cache's entries from most
+	* recently used to least recently used.
+	*
+	* @return {Iterator}
+	*/
+	LRUCache.prototype.entries = function() {
+		var i = 0, l = this.size;
+		var pointer = this.head, keys = this.K, values = this.V, forward = this.forward;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			var key = keys[pointer], value = values[pointer];
+			i++;
+			if (i < l) pointer = forward[pointer];
+			return {
+				done: false,
+				value: [key, value]
+			};
+		});
+	};
+	/**
+	* Attaching the #.entries method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") LRUCache.prototype[Symbol.iterator] = LRUCache.prototype.entries;
+	/**
+	* Convenience known methods.
+	*/
+	LRUCache.prototype.inspect = function() {
+		var proxy = /* @__PURE__ */ new Map();
+		var iterator = this.entries(), step;
+		while (step = iterator.next(), !step.done) proxy.set(step.value[0], step.value[1]);
+		Object.defineProperty(proxy, "constructor", {
+			value: LRUCache,
+			enumerable: false
+		});
+		return proxy;
+	};
+	if (typeof Symbol !== "undefined") LRUCache.prototype[Symbol.for("nodejs.util.inspect.custom")] = LRUCache.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a structure.
+	*
+	* @param  {Iterable} iterable - Target iterable.
+	* @param  {function} Keys     - Array class for storing keys.
+	* @param  {function} Values   - Array class for storing values.
+	* @param  {number}   capacity - Cache's capacity.
+	* @return {LRUCache}
+	*/
+	LRUCache.from = function(iterable, Keys, Values, capacity) {
+		if (arguments.length < 2) {
+			capacity = iterables.guessLength(iterable);
+			if (typeof capacity !== "number") throw new Error("mnemonist/lru-cache.from: could not guess iterable length. Please provide desired capacity as last argument.");
+		} else if (arguments.length === 2) {
+			capacity = Keys;
+			Keys = null;
+			Values = null;
+		}
+		var cache = new LRUCache(Keys, Values, capacity);
+		forEach(iterable, function(value, key) {
+			cache.set(key, value);
+		});
+		return cache;
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = LRUCache;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/lru-map.js
+var require_lru_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist LRUMap
+	* =================
+	*
+	* Variant of the LRUCache class that leverages an ES6 Map instead of an object.
+	* It might be faster for some use case but it is still hard to understand
+	* when a Map can outperform an object in v8.
+	*/
+	var LRUCache = require_lru_cache(), forEach = require_foreach(), typed = require_typed_arrays(), iterables = require_iterables();
+	/**
+	* LRUMap.
+	*
+	* @constructor
+	* @param {function} Keys     - Array class for storing keys.
+	* @param {function} Values   - Array class for storing values.
+	* @param {number}   capacity - Desired capacity.
+	*/
+	function LRUMap(Keys, Values, capacity) {
+		if (arguments.length < 2) {
+			capacity = Keys;
+			Keys = null;
+			Values = null;
+		}
+		this.capacity = capacity;
+		if (typeof this.capacity !== "number" || this.capacity <= 0) throw new Error("mnemonist/lru-map: capacity should be positive number.");
+		else if (!isFinite(this.capacity) || Math.floor(this.capacity) !== this.capacity) throw new Error("mnemonist/lru-map: capacity should be a finite positive integer.");
+		var PointerArray = typed.getPointerArray(capacity);
+		this.forward = new PointerArray(capacity);
+		this.backward = new PointerArray(capacity);
+		this.K = typeof Keys === "function" ? new Keys(capacity) : new Array(capacity);
+		this.V = typeof Values === "function" ? new Values(capacity) : new Array(capacity);
+		this.size = 0;
+		this.head = 0;
+		this.tail = 0;
+		this.items = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Method used to clear the structure.
+	*
+	* @return {undefined}
+	*/
+	LRUMap.prototype.clear = function() {
+		this.size = 0;
+		this.head = 0;
+		this.tail = 0;
+		this.items.clear();
+	};
+	/**
+	* Method used to set the value for the given key in the cache.
+	*
+	* @param  {any} key   - Key.
+	* @param  {any} value - Value.
+	* @return {undefined}
+	*/
+	LRUMap.prototype.set = function(key, value) {
+		var pointer = this.items.get(key);
+		if (typeof pointer !== "undefined") {
+			this.splayOnTop(pointer);
+			this.V[pointer] = value;
+			return;
+		}
+		if (this.size < this.capacity) pointer = this.size++;
+		else {
+			pointer = this.tail;
+			this.tail = this.backward[pointer];
+			this.items.delete(this.K[pointer]);
+		}
+		this.items.set(key, pointer);
+		this.K[pointer] = key;
+		this.V[pointer] = value;
+		this.forward[pointer] = this.head;
+		this.backward[this.head] = pointer;
+		this.head = pointer;
+	};
+	/**
+	* Method used to set the value for the given key in the cache.
+	*
+	* @param  {any} key   - Key.
+	* @param  {any} value - Value.
+	* @return {{evicted: boolean, key: any, value: any}} An object containing the
+	* key and value of an item that was overwritten or evicted in the set
+	* operation, as well as a boolean indicating whether it was evicted due to
+	* limited capacity. Return value is null if nothing was evicted or overwritten
+	* during the set operation.
+	*/
+	LRUMap.prototype.setpop = function(key, value) {
+		var oldValue = null;
+		var oldKey = null;
+		var pointer = this.items.get(key);
+		if (typeof pointer !== "undefined") {
+			this.splayOnTop(pointer);
+			oldValue = this.V[pointer];
+			this.V[pointer] = value;
+			return {
+				evicted: false,
+				key,
+				value: oldValue
+			};
+		}
+		if (this.size < this.capacity) pointer = this.size++;
+		else {
+			pointer = this.tail;
+			this.tail = this.backward[pointer];
+			oldValue = this.V[pointer];
+			oldKey = this.K[pointer];
+			this.items.delete(oldKey);
+		}
+		this.items.set(key, pointer);
+		this.K[pointer] = key;
+		this.V[pointer] = value;
+		this.forward[pointer] = this.head;
+		this.backward[this.head] = pointer;
+		this.head = pointer;
+		if (oldKey) return {
+			evicted: true,
+			key: oldKey,
+			value: oldValue
+		};
+		else return null;
+	};
+	/**
+	* Method used to check whether the key exists in the cache.
+	*
+	* @param  {any} key   - Key.
+	* @return {boolean}
+	*/
+	LRUMap.prototype.has = function(key) {
+		return this.items.has(key);
+	};
+	/**
+	* Method used to get the value attached to the given key. Will move the
+	* related key to the front of the underlying linked list.
+	*
+	* @param  {any} key   - Key.
+	* @return {any}
+	*/
+	LRUMap.prototype.get = function(key) {
+		var pointer = this.items.get(key);
+		if (typeof pointer === "undefined") return;
+		this.splayOnTop(pointer);
+		return this.V[pointer];
+	};
+	/**
+	* Method used to get the value attached to the given key. Does not modify
+	* the ordering of the underlying linked list.
+	*
+	* @param  {any} key   - Key.
+	* @return {any}
+	*/
+	LRUMap.prototype.peek = function(key) {
+		var pointer = this.items.get(key);
+		if (typeof pointer === "undefined") return;
+		return this.V[pointer];
+	};
+	/**
+	* Methods that can be reused as-is from LRUCache.
+	*/
+	LRUMap.prototype.splayOnTop = LRUCache.prototype.splayOnTop;
+	LRUMap.prototype.forEach = LRUCache.prototype.forEach;
+	LRUMap.prototype.keys = LRUCache.prototype.keys;
+	LRUMap.prototype.values = LRUCache.prototype.values;
+	LRUMap.prototype.entries = LRUCache.prototype.entries;
+	/**
+	* Attaching the #.entries method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") LRUMap.prototype[Symbol.iterator] = LRUMap.prototype.entries;
+	/**
+	* Convenience known methods.
+	*/
+	LRUMap.prototype.inspect = LRUCache.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a structure.
+	*
+	* @param  {Iterable} iterable - Target iterable.
+	* @param  {function} Keys     - Array class for storing keys.
+	* @param  {function} Values   - Array class for storing values.
+	* @param  {number}   capacity - Cache's capacity.
+	* @return {LRUMap}
+	*/
+	LRUMap.from = function(iterable, Keys, Values, capacity) {
+		if (arguments.length < 2) {
+			capacity = iterables.guessLength(iterable);
+			if (typeof capacity !== "number") throw new Error("mnemonist/lru-cache.from: could not guess iterable length. Please provide desired capacity as last argument.");
+		} else if (arguments.length === 2) {
+			capacity = Keys;
+			Keys = null;
+			Values = null;
+		}
+		var cache = new LRUMap(Keys, Values, capacity);
+		forEach(iterable, function(value, key) {
+			cache.set(key, value);
+		});
+		return cache;
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = LRUMap;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/set.js
+var require_set = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Mnemonist Set
+	* ==============
+	*
+	* Useful function related to sets such as union, intersection and so on...
+	*/
+	/**
+	* Variadic function computing the intersection of multiple sets.
+	*
+	* @param  {...Set} sets - Sets to intersect.
+	* @return {Set}         - The intesection.
+	*/
+	exports.intersection = function() {
+		if (arguments.length < 2) throw new Error("mnemonist/Set.intersection: needs at least two arguments.");
+		var I = /* @__PURE__ */ new Set();
+		var smallestSize = Infinity, smallestSet = null;
+		var s, i, l = arguments.length;
+		for (i = 0; i < l; i++) {
+			s = arguments[i];
+			if (s.size === 0) return I;
+			if (s.size < smallestSize) {
+				smallestSize = s.size;
+				smallestSet = s;
+			}
+		}
+		var iterator = smallestSet.values(), step, item, add, set;
+		while (step = iterator.next(), !step.done) {
+			item = step.value;
+			add = true;
+			for (i = 0; i < l; i++) {
+				set = arguments[i];
+				if (set === smallestSet) continue;
+				if (!set.has(item)) {
+					add = false;
+					break;
+				}
+			}
+			if (add) I.add(item);
+		}
+		return I;
+	};
+	/**
+	* Variadic function computing the union of multiple sets.
+	*
+	* @param  {...Set} sets - Sets to unite.
+	* @return {Set}         - The union.
+	*/
+	exports.union = function() {
+		if (arguments.length < 2) throw new Error("mnemonist/Set.union: needs at least two arguments.");
+		var U = /* @__PURE__ */ new Set();
+		var i, l = arguments.length;
+		var iterator, step;
+		for (i = 0; i < l; i++) {
+			iterator = arguments[i].values();
+			while (step = iterator.next(), !step.done) U.add(step.value);
+		}
+		return U;
+	};
+	/**
+	* Function computing the difference between two sets.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {Set}   - The difference.
+	*/
+	exports.difference = function(A, B) {
+		if (!A.size) return /* @__PURE__ */ new Set();
+		if (!B.size) return new Set(A);
+		var D = /* @__PURE__ */ new Set();
+		var iterator = A.values(), step;
+		while (step = iterator.next(), !step.done) if (!B.has(step.value)) D.add(step.value);
+		return D;
+	};
+	/**
+	* Function computing the symmetric difference between two sets.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {Set}   - The symmetric difference.
+	*/
+	exports.symmetricDifference = function(A, B) {
+		var S = /* @__PURE__ */ new Set();
+		var iterator = A.values(), step;
+		while (step = iterator.next(), !step.done) if (!B.has(step.value)) S.add(step.value);
+		iterator = B.values();
+		while (step = iterator.next(), !step.done) if (!A.has(step.value)) S.add(step.value);
+		return S;
+	};
+	/**
+	* Function returning whether A is a subset of B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {boolean}
+	*/
+	exports.isSubset = function(A, B) {
+		var iterator = A.values(), step;
+		if (A === B) return true;
+		if (A.size > B.size) return false;
+		while (step = iterator.next(), !step.done) if (!B.has(step.value)) return false;
+		return true;
+	};
+	/**
+	* Function returning whether A is a superset of B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {boolean}
+	*/
+	exports.isSuperset = function(A, B) {
+		return exports.isSubset(B, A);
+	};
+	/**
+	* Function adding the items of set B to the set A.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	*/
+	exports.add = function(A, B) {
+		var iterator = B.values(), step;
+		while (step = iterator.next(), !step.done) A.add(step.value);
+	};
+	/**
+	* Function subtracting the items of set B from the set A.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	*/
+	exports.subtract = function(A, B) {
+		var iterator = B.values(), step;
+		while (step = iterator.next(), !step.done) A.delete(step.value);
+	};
+	/**
+	* Function intersecting the items of A & B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	*/
+	exports.intersect = function(A, B) {
+		var iterator = A.values(), step;
+		while (step = iterator.next(), !step.done) if (!B.has(step.value)) A.delete(step.value);
+	};
+	/**
+	* Function disjuncting the items of A & B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	*/
+	exports.disjunct = function(A, B) {
+		var iterator = A.values(), step;
+		var toRemove = [];
+		while (step = iterator.next(), !step.done) if (B.has(step.value)) toRemove.push(step.value);
+		iterator = B.values();
+		while (step = iterator.next(), !step.done) if (!A.has(step.value)) A.add(step.value);
+		for (var i = 0, l = toRemove.length; i < l; i++) A.delete(toRemove[i]);
+	};
+	/**
+	* Function returning the size of the intersection of A & B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {number}
+	*/
+	exports.intersectionSize = function(A, B) {
+		var tmp;
+		if (A.size > B.size) {
+			tmp = A;
+			A = B;
+			B = tmp;
+		}
+		if (A.size === 0) return 0;
+		if (A === B) return A.size;
+		var iterator = A.values(), step;
+		var I = 0;
+		while (step = iterator.next(), !step.done) if (B.has(step.value)) I++;
+		return I;
+	};
+	/**
+	* Function returning the size of the union of A & B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {number}
+	*/
+	exports.unionSize = function(A, B) {
+		var I = exports.intersectionSize(A, B);
+		return A.size + B.size - I;
+	};
+	/**
+	* Function returning the Jaccard similarity between A & B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {number}
+	*/
+	exports.jaccard = function(A, B) {
+		var I = exports.intersectionSize(A, B);
+		if (I === 0) return 0;
+		return I / (A.size + B.size - I);
+	};
+	/**
+	* Function returning the overlap coefficient between A & B.
+	*
+	* @param  {Set} A - First set.
+	* @param  {Set} B - Second set.
+	* @return {number}
+	*/
+	exports.overlap = function(A, B) {
+		var I = exports.intersectionSize(A, B);
+		if (I === 0) return 0;
+		return I / Math.min(A.size, B.size);
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/stack.js
+var require_stack = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist Stack
+	* ================
+	*
+	* Stack implementation relying on JavaScript arrays, which are fast enough &
+	* correctly optimized for this kind of work.
+	*/
+	var Iterator = require_iterator(), forEach = require_foreach();
+	/**
+	* Stack
+	*
+	* @constructor
+	*/
+	function Stack() {
+		this.clear();
+	}
+	/**
+	* Method used to clear the stack.
+	*
+	* @return {undefined}
+	*/
+	Stack.prototype.clear = function() {
+		this.items = [];
+		this.size = 0;
+	};
+	/**
+	* Method used to add an item to the stack.
+	*
+	* @param  {any}    item - Item to add.
+	* @return {number}
+	*/
+	Stack.prototype.push = function(item) {
+		this.items.push(item);
+		return ++this.size;
+	};
+	/**
+	* Method used to retrieve & remove the last item of the stack.
+	*
+	* @return {any}
+	*/
+	Stack.prototype.pop = function() {
+		if (this.size === 0) return;
+		this.size--;
+		return this.items.pop();
+	};
+	/**
+	* Method used to get the last item of the stack.
+	*
+	* @return {any}
+	*/
+	Stack.prototype.peek = function() {
+		return this.items[this.size - 1];
+	};
+	/**
+	* Method used to iterate over the stack.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	Stack.prototype.forEach = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		for (var i = 0, l = this.items.length; i < l; i++) callback.call(scope, this.items[l - i - 1], i, this);
+	};
+	/**
+	* Method used to convert the stack to a JavaScript array.
+	*
+	* @return {array}
+	*/
+	Stack.prototype.toArray = function() {
+		var array = new Array(this.size), l = this.size - 1, i = this.size;
+		while (i--) array[i] = this.items[l - i];
+		return array;
+	};
+	/**
+	* Method used to create an iterator over a stack's values.
+	*
+	* @return {Iterator}
+	*/
+	Stack.prototype.values = function() {
+		var items = this.items, l = items.length, i = 0;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			var value = items[l - i - 1];
+			i++;
+			return {
+				value,
+				done: false
+			};
+		});
+	};
+	/**
+	* Method used to create an iterator over a stack's entries.
+	*
+	* @return {Iterator}
+	*/
+	Stack.prototype.entries = function() {
+		var items = this.items, l = items.length, i = 0;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			var value = items[l - i - 1];
+			return {
+				value: [i++, value],
+				done: false
+			};
+		});
+	};
+	/**
+	* Attaching the #.values method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") Stack.prototype[Symbol.iterator] = Stack.prototype.values;
+	/**
+	* Convenience known methods.
+	*/
+	Stack.prototype.toString = function() {
+		return this.toArray().join(",");
+	};
+	Stack.prototype.toJSON = function() {
+		return this.toArray();
+	};
+	Stack.prototype.inspect = function() {
+		var array = this.toArray();
+		Object.defineProperty(array, "constructor", {
+			value: Stack,
+			enumerable: false
+		});
+		return array;
+	};
+	if (typeof Symbol !== "undefined") Stack.prototype[Symbol.for("nodejs.util.inspect.custom")] = Stack.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a stack.
+	*
+	* @param  {Iterable} iterable   - Target iterable.
+	* @return {Stack}
+	*/
+	Stack.from = function(iterable) {
+		var stack = new Stack();
+		forEach(iterable, function(value) {
+			stack.push(value);
+		});
+		return stack;
+	};
+	/**
+	* Static @.of function taking an arbitrary number of arguments & converting it
+	* into a stack.
+	*
+	* @param  {...any} args
+	* @return {Stack}
+	*/
+	Stack.of = function() {
+		return Stack.from(arguments);
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = Stack;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/patch.mjs
+var import_bi_map = /* @__PURE__ */ __toESM(require_bi_map(), 1);
+var import_default_map = /* @__PURE__ */ __toESM(require_default_map(), 1);
+var import_default_weak_map = /* @__PURE__ */ __toESM(require_default_weak_map(), 1);
+var import_linked_list = /* @__PURE__ */ __toESM(require_linked_list(), 1);
+var import_multi_map = /* @__PURE__ */ __toESM(require_multi_map(), 1);
+var import_queue = /* @__PURE__ */ __toESM(require_queue(), 1);
+var import_lru_map = /* @__PURE__ */ __toESM(require_lru_map(), 1);
+var import_set = require_set();
+var import_stack = /* @__PURE__ */ __toESM(require_stack(), 1);
+
+//#endregion
+export { import_lru_map as a, import_set as c, import_linked_list as i, import_stack as l, import_default_map as n, import_multi_map as o, import_default_weak_map as r, import_queue as s, import_bi_map as t };