@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/libs/graphology-dag.mjs

@@ -0,0 +1,703 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+
+//#region ../../node_modules/.pnpm/obliterator@2.0.5/node_modules/obliterator/support.js
+var require_support = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.ARRAY_BUFFER_SUPPORT = typeof ArrayBuffer !== "undefined";
+	exports.SYMBOL_SUPPORT = typeof Symbol !== "undefined";
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/obliterator@2.0.5/node_modules/obliterator/foreach.js
+var require_foreach = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Obliterator ForEach Function
+	* =============================
+	*
+	* Helper function used to easily iterate over mixed values.
+	*/
+	var support = require_support();
+	var ARRAY_BUFFER_SUPPORT = support.ARRAY_BUFFER_SUPPORT;
+	var SYMBOL_SUPPORT = support.SYMBOL_SUPPORT;
+	/**
+	* Function able to iterate over almost any iterable JS value.
+	*
+	* @param  {any}      iterable - Iterable value.
+	* @param  {function} callback - Callback function.
+	*/
+	module.exports = function forEach(iterable, callback) {
+		var iterator, k, i, l, s;
+		if (!iterable) throw new Error("obliterator/forEach: invalid iterable.");
+		if (typeof callback !== "function") throw new Error("obliterator/forEach: expecting a callback.");
+		if (Array.isArray(iterable) || ARRAY_BUFFER_SUPPORT && ArrayBuffer.isView(iterable) || typeof iterable === "string" || iterable.toString() === "[object Arguments]") {
+			for (i = 0, l = iterable.length; i < l; i++) callback(iterable[i], i);
+			return;
+		}
+		if (typeof iterable.forEach === "function") {
+			iterable.forEach(callback);
+			return;
+		}
+		if (SYMBOL_SUPPORT && Symbol.iterator in iterable && typeof iterable.next !== "function") iterable = iterable[Symbol.iterator]();
+		if (typeof iterable.next === "function") {
+			iterator = iterable;
+			i = 0;
+			while (s = iterator.next(), s.done !== true) {
+				callback(s.value, i);
+				i++;
+			}
+			return;
+		}
+		for (k in iterable) if (iterable.hasOwnProperty(k)) callback(iterable[k], k);
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/obliterator@2.0.5/node_modules/obliterator/iterator.js
+var require_iterator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Obliterator Iterator Class
+	* ===========================
+	*
+	* Simple class representing the library's iterators.
+	*/
+	/**
+	* Iterator class.
+	*
+	* @constructor
+	* @param {function} next - Next function.
+	*/
+	function Iterator(next) {
+		if (typeof next !== "function") throw new Error("obliterator/iterator: expecting a function!");
+		this.next = next;
+	}
+	/**
+	* If symbols are supported, we add `next` to `Symbol.iterator`.
+	*/
+	if (typeof Symbol !== "undefined") Iterator.prototype[Symbol.iterator] = function() {
+		return this;
+	};
+	/**
+	* Returning an iterator of the given values.
+	*
+	* @param  {any...} values - Values.
+	* @return {Iterator}
+	*/
+	Iterator.of = function() {
+		var args = arguments, l = args.length, i = 0;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			return {
+				done: false,
+				value: args[i++]
+			};
+		});
+	};
+	/**
+	* Returning an empty iterator.
+	*
+	* @return {Iterator}
+	*/
+	Iterator.empty = function() {
+		return new Iterator(function() {
+			return { done: true };
+		});
+	};
+	/**
+	* Returning an iterator over the given indexed sequence.
+	*
+	* @param  {string|Array} sequence - Target sequence.
+	* @return {Iterator}
+	*/
+	Iterator.fromSequence = function(sequence) {
+		var i = 0, l = sequence.length;
+		return new Iterator(function() {
+			if (i >= l) return { done: true };
+			return {
+				done: false,
+				value: sequence[i++]
+			};
+		});
+	};
+	/**
+	* Returning whether the given value is an iterator.
+	*
+	* @param  {any} value - Value.
+	* @return {boolean}
+	*/
+	Iterator.is = function(value) {
+		if (value instanceof Iterator) return true;
+		return typeof value === "object" && value !== null && typeof value.next === "function";
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = Iterator;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/utils/typed-arrays.js
+var require_typed_arrays = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Mnemonist Typed Array Helpers
+	* ==============================
+	*
+	* Miscellaneous helpers related to typed arrays.
+	*/
+	/**
+	* When using an unsigned integer array to store pointers, one might want to
+	* choose the optimal word size in regards to the actual numbers of pointers
+	* to store.
+	*
+	* This helpers does just that.
+	*
+	* @param  {number} size - Expected size of the array to map.
+	* @return {TypedArray}
+	*/
+	var MAX_8BIT_INTEGER = Math.pow(2, 8) - 1, MAX_16BIT_INTEGER = Math.pow(2, 16) - 1, MAX_32BIT_INTEGER = Math.pow(2, 32) - 1;
+	var MAX_SIGNED_8BIT_INTEGER = Math.pow(2, 7) - 1, MAX_SIGNED_16BIT_INTEGER = Math.pow(2, 15) - 1, MAX_SIGNED_32BIT_INTEGER = Math.pow(2, 31) - 1;
+	exports.getPointerArray = function(size) {
+		var maxIndex = size - 1;
+		if (maxIndex <= MAX_8BIT_INTEGER) return Uint8Array;
+		if (maxIndex <= MAX_16BIT_INTEGER) return Uint16Array;
+		if (maxIndex <= MAX_32BIT_INTEGER) return Uint32Array;
+		throw new Error("mnemonist: Pointer Array of size > 4294967295 is not supported.");
+	};
+	exports.getSignedPointerArray = function(size) {
+		var maxIndex = size - 1;
+		if (maxIndex <= MAX_SIGNED_8BIT_INTEGER) return Int8Array;
+		if (maxIndex <= MAX_SIGNED_16BIT_INTEGER) return Int16Array;
+		if (maxIndex <= MAX_SIGNED_32BIT_INTEGER) return Int32Array;
+		return Float64Array;
+	};
+	/**
+	* Function returning the minimal type able to represent the given number.
+	*
+	* @param  {number} value - Value to test.
+	* @return {TypedArrayClass}
+	*/
+	exports.getNumberType = function(value) {
+		if (value === (value | 0)) if (Math.sign(value) === -1) {
+			if (value <= 127 && value >= -128) return Int8Array;
+			if (value <= 32767 && value >= -32768) return Int16Array;
+			return Int32Array;
+		} else {
+			if (value <= 255) return Uint8Array;
+			if (value <= 65535) return Uint16Array;
+			return Uint32Array;
+		}
+		return Float64Array;
+	};
+	/**
+	* Function returning the minimal type able to represent the given array
+	* of JavaScript numbers.
+	*
+	* @param  {array}    array  - Array to represent.
+	* @param  {function} getter - Optional getter.
+	* @return {TypedArrayClass}
+	*/
+	var TYPE_PRIORITY = {
+		Uint8Array: 1,
+		Int8Array: 2,
+		Uint16Array: 3,
+		Int16Array: 4,
+		Uint32Array: 5,
+		Int32Array: 6,
+		Float32Array: 7,
+		Float64Array: 8
+	};
+	exports.getMinimalRepresentation = function(array, getter) {
+		var maxType = null, maxPriority = 0, p, t, v, i, l;
+		for (i = 0, l = array.length; i < l; i++) {
+			v = getter ? getter(array[i]) : array[i];
+			t = exports.getNumberType(v);
+			p = TYPE_PRIORITY[t.name];
+			if (p > maxPriority) {
+				maxPriority = p;
+				maxType = t;
+			}
+		}
+		return maxType;
+	};
+	/**
+	* Function returning whether the given value is a typed array.
+	*
+	* @param  {any} value - Value to test.
+	* @return {boolean}
+	*/
+	exports.isTypedArray = function(value) {
+		return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+	};
+	/**
+	* Function used to concat byte arrays.
+	*
+	* @param  {...ByteArray}
+	* @return {ByteArray}
+	*/
+	exports.concat = function() {
+		var length = 0, i, o, l;
+		for (i = 0, l = arguments.length; i < l; i++) length += arguments[i].length;
+		var array = new arguments[0].constructor(length);
+		for (i = 0, o = 0; i < l; i++) {
+			array.set(arguments[i], o);
+			o += arguments[i].length;
+		}
+		return array;
+	};
+	/**
+	* Function used to initialize a byte array of indices.
+	*
+	* @param  {number}    length - Length of target.
+	* @return {ByteArray}
+	*/
+	exports.indices = function(length) {
+		var array = new (exports.getPointerArray(length))(length);
+		for (var i = 0; i < length; i++) array[i] = i;
+		return array;
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/utils/iterables.js
+var require_iterables = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Mnemonist Iterable Function
+	* ============================
+	*
+	* Harmonized iteration helpers over mixed iterable targets.
+	*/
+	var forEach = require_foreach();
+	var typed = require_typed_arrays();
+	/**
+	* Function used to determine whether the given object supports array-like
+	* random access.
+	*
+	* @param  {any} target - Target object.
+	* @return {boolean}
+	*/
+	function isArrayLike(target) {
+		return Array.isArray(target) || typed.isTypedArray(target);
+	}
+	/**
+	* Function used to guess the length of the structure over which we are going
+	* to iterate.
+	*
+	* @param  {any} target - Target object.
+	* @return {number|undefined}
+	*/
+	function guessLength(target) {
+		if (typeof target.length === "number") return target.length;
+		if (typeof target.size === "number") return target.size;
+	}
+	/**
+	* Function used to convert an iterable to an array.
+	*
+	* @param  {any}   target - Iteration target.
+	* @return {array}
+	*/
+	function toArray(target) {
+		var l = guessLength(target);
+		var array = typeof l === "number" ? new Array(l) : [];
+		var i = 0;
+		forEach(target, function(value) {
+			array[i++] = value;
+		});
+		return array;
+	}
+	/**
+	* Same as above but returns a supplementary indices array.
+	*
+	* @param  {any}   target - Iteration target.
+	* @return {array}
+	*/
+	function toArrayWithIndices(target) {
+		var l = guessLength(target);
+		var IndexArray = typeof l === "number" ? typed.getPointerArray(l) : Array;
+		var array = typeof l === "number" ? new Array(l) : [];
+		var indices = typeof l === "number" ? new IndexArray(l) : [];
+		var i = 0;
+		forEach(target, function(value) {
+			array[i] = value;
+			indices[i] = i++;
+		});
+		return [array, indices];
+	}
+	/**
+	* Exporting.
+	*/
+	exports.isArrayLike = isArrayLike;
+	exports.guessLength = guessLength;
+	exports.toArray = toArray;
+	exports.toArrayWithIndices = toArrayWithIndices;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graphology-utils@2.5.2_graphology-types@0.24.8/node_modules/graphology-utils/is-graph.js
+var require_is_graph = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Graphology isGraph
+	* ===================
+	*
+	* Very simple function aiming at ensuring the given variable is a
+	* graphology instance.
+	*/
+	/**
+	* Checking the value is a graphology instance.
+	*
+	* @param  {any}     value - Target value.
+	* @return {boolean}
+	*/
+	module.exports = function isGraph(value) {
+		return value !== null && typeof value === "object" && typeof value.addUndirectedEdgeWithKey === "function" && typeof value.dropNode === "function" && typeof value.multi === "boolean";
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/mnemonist@0.40.3_patch_hash=70301b9c235e13bc146bb9528b7979c278952196d5dac8048ab3850adac8f4cf/node_modules/mnemonist/fixed-deque.js
+var require_fixed_deque = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Mnemonist FixedDeque
+	* =====================
+	*
+	* Fixed capacity double-ended queue implemented as ring deque.
+	*/
+	var iterables = require_iterables(), Iterator = require_iterator();
+	/**
+	* FixedDeque.
+	*
+	* @constructor
+	*/
+	function FixedDeque(ArrayClass, capacity) {
+		if (arguments.length < 2) throw new Error("mnemonist/fixed-deque: expecting an Array class and a capacity.");
+		if (typeof capacity !== "number" || capacity <= 0) throw new Error("mnemonist/fixed-deque: `capacity` should be a positive number.");
+		this.ArrayClass = ArrayClass;
+		this.capacity = capacity;
+		this.items = new ArrayClass(this.capacity);
+		this.clear();
+	}
+	/**
+	* Method used to clear the structure.
+	*
+	* @return {undefined}
+	*/
+	FixedDeque.prototype.clear = function() {
+		this.start = 0;
+		this.size = 0;
+	};
+	/**
+	* Method used to append a value to the deque.
+	*
+	* @param  {any}    item - Item to append.
+	* @return {number}      - Returns the new size of the deque.
+	*/
+	FixedDeque.prototype.push = function(item) {
+		if (this.size === this.capacity) throw new Error("mnemonist/fixed-deque.push: deque capacity (" + this.capacity + ") exceeded!");
+		var index = this.start + this.size;
+		if (index >= this.capacity) index -= this.capacity;
+		this.items[index] = item;
+		return ++this.size;
+	};
+	/**
+	* Method used to prepend a value to the deque.
+	*
+	* @param  {any}    item - Item to prepend.
+	* @return {number}      - Returns the new size of the deque.
+	*/
+	FixedDeque.prototype.unshift = function(item) {
+		if (this.size === this.capacity) throw new Error("mnemonist/fixed-deque.unshift: deque capacity (" + this.capacity + ") exceeded!");
+		var index = this.start - 1;
+		if (this.start === 0) index = this.capacity - 1;
+		this.items[index] = item;
+		this.start = index;
+		return ++this.size;
+	};
+	/**
+	* Method used to pop the deque.
+	*
+	* @return {any} - Returns the popped item.
+	*/
+	FixedDeque.prototype.pop = function() {
+		if (this.size === 0) return;
+		this.size--;
+		var index = this.start + this.size;
+		if (index >= this.capacity) index -= this.capacity;
+		return this.items[index];
+	};
+	/**
+	* Method used to shift the deque.
+	*
+	* @return {any} - Returns the shifted item.
+	*/
+	FixedDeque.prototype.shift = function() {
+		if (this.size === 0) return;
+		var index = this.start;
+		this.size--;
+		this.start++;
+		if (this.start === this.capacity) this.start = 0;
+		return this.items[index];
+	};
+	/**
+	* Method used to peek the first value of the deque.
+	*
+	* @return {any}
+	*/
+	FixedDeque.prototype.peekFirst = function() {
+		if (this.size === 0) return;
+		return this.items[this.start];
+	};
+	/**
+	* Method used to peek the last value of the deque.
+	*
+	* @return {any}
+	*/
+	FixedDeque.prototype.peekLast = function() {
+		if (this.size === 0) return;
+		var index = this.start + this.size - 1;
+		if (index >= this.capacity) index -= this.capacity;
+		return this.items[index];
+	};
+	/**
+	* Method used to get the desired value of the deque.
+	*
+	* @param  {number} index
+	* @return {any}
+	*/
+	FixedDeque.prototype.get = function(index) {
+		if (this.size === 0 || index >= this.capacity) return;
+		index = this.start + index;
+		if (index >= this.capacity) index -= this.capacity;
+		return this.items[index];
+	};
+	/**
+	* Method used to iterate over the deque.
+	*
+	* @param  {function}  callback - Function to call for each item.
+	* @param  {object}    scope    - Optional scope.
+	* @return {undefined}
+	*/
+	FixedDeque.prototype.forEach = function(callback, scope) {
+		scope = arguments.length > 1 ? scope : this;
+		var c = this.capacity, l = this.size, i = this.start, j = 0;
+		while (j < l) {
+			callback.call(scope, this.items[i], j, this);
+			i++;
+			j++;
+			if (i === c) i = 0;
+		}
+	};
+	/**
+	* Method used to convert the deque to a JavaScript array.
+	*
+	* @return {array}
+	*/
+	FixedDeque.prototype.toArray = function() {
+		var offset = this.start + this.size;
+		if (offset < this.capacity) return this.items.slice(this.start, offset);
+		var array = new this.ArrayClass(this.size), c = this.capacity, l = this.size, i = this.start, j = 0;
+		while (j < l) {
+			array[j] = this.items[i];
+			i++;
+			j++;
+			if (i === c) i = 0;
+		}
+		return array;
+	};
+	/**
+	* Method used to create an iterator over the deque's values.
+	*
+	* @return {Iterator}
+	*/
+	FixedDeque.prototype.values = function() {
+		var items = this.items, c = this.capacity, l = this.size, i = this.start, j = 0;
+		return new Iterator(function() {
+			if (j >= l) return { done: true };
+			var value = items[i];
+			i++;
+			j++;
+			if (i === c) i = 0;
+			return {
+				value,
+				done: false
+			};
+		});
+	};
+	/**
+	* Method used to create an iterator over the deque's entries.
+	*
+	* @return {Iterator}
+	*/
+	FixedDeque.prototype.entries = function() {
+		var items = this.items, c = this.capacity, l = this.size, i = this.start, j = 0;
+		return new Iterator(function() {
+			if (j >= l) return { done: true };
+			var value = items[i];
+			i++;
+			if (i === c) i = 0;
+			return {
+				value: [j++, value],
+				done: false
+			};
+		});
+	};
+	/**
+	* Attaching the #.values method to Symbol.iterator if possible.
+	*/
+	if (typeof Symbol !== "undefined") FixedDeque.prototype[Symbol.iterator] = FixedDeque.prototype.values;
+	/**
+	* Convenience known methods.
+	*/
+	FixedDeque.prototype.inspect = function() {
+		var array = this.toArray();
+		array.type = this.ArrayClass.name;
+		array.capacity = this.capacity;
+		Object.defineProperty(array, "constructor", {
+			value: FixedDeque,
+			enumerable: false
+		});
+		return array;
+	};
+	if (typeof Symbol !== "undefined") FixedDeque.prototype[Symbol.for("nodejs.util.inspect.custom")] = FixedDeque.prototype.inspect;
+	/**
+	* Static @.from function taking an arbitrary iterable & converting it into
+	* a deque.
+	*
+	* @param  {Iterable} iterable   - Target iterable.
+	* @param  {function} ArrayClass - Array class to use.
+	* @param  {number}   capacity   - Desired capacity.
+	* @return {FiniteStack}
+	*/
+	FixedDeque.from = function(iterable, ArrayClass, capacity) {
+		if (arguments.length < 3) {
+			capacity = iterables.guessLength(iterable);
+			if (typeof capacity !== "number") throw new Error("mnemonist/fixed-deque.from: could not guess iterable length. Please provide desired capacity as last argument.");
+		}
+		var deque = new FixedDeque(ArrayClass, capacity);
+		if (iterables.isArrayLike(iterable)) {
+			var i, l;
+			for (i = 0, l = iterable.length; i < l; i++) deque.items[i] = iterable[i];
+			deque.size = l;
+			return deque;
+		}
+		iterables.forEach(iterable, function(value) {
+			deque.push(value);
+		});
+		return deque;
+	};
+	/**
+	* Exporting.
+	*/
+	module.exports = FixedDeque;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graphology-dag@0.4.1_graphology-types@0.24.8/node_modules/graphology-dag/topological-sort.js
+var require_topological_sort = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Graphology Topological Sort
+	* ============================
+	*
+	* Function performing topological sort over the given DAG using Kahn's
+	* algorithm.
+	*
+	* This function also works on disconnected graphs.
+	*
+	* [Reference]:
+	* https://en.wikipedia.org/wiki/Topological_sorting
+	*/
+	const isGraph = require_is_graph();
+	const FixedDeque = require_fixed_deque();
+	function simpleInDegree(graph, node) {
+		let degree = 0;
+		graph.forEachInNeighbor(node, () => {
+			degree++;
+		});
+		return degree;
+	}
+	function forEachNodeInTopologicalOrder(graph, callback) {
+		if (!isGraph(graph)) throw new Error("graphology-dag/topological-sort: the given graph is not a valid graphology instance.");
+		if (graph.type === "undirected" || graph.undirectedSize !== 0) throw new Error("graphology-dag/topological-sort: cannot work if graph is not directed.");
+		if (graph.order === 0) return;
+		const queue = new FixedDeque(Array, graph.order);
+		const inDegrees = {};
+		let total = 0;
+		graph.forEachNode((node, attr) => {
+			const inDegree = graph.multi ? simpleInDegree(graph, node) : graph.inDegree(node);
+			if (inDegree === 0) queue.push([
+				node,
+				attr,
+				0
+			]);
+			else {
+				inDegrees[node] = inDegree;
+				total += inDegree;
+			}
+		});
+		let currentGeneration = 0;
+		function neighborCallback(neighbor, attr) {
+			const neighborInDegree = --inDegrees[neighbor];
+			total--;
+			if (neighborInDegree === 0) queue.push([
+				neighbor,
+				attr,
+				currentGeneration + 1
+			]);
+			inDegrees[neighbor] = neighborInDegree;
+		}
+		while (queue.size !== 0) {
+			const [node, attr, gen] = queue.shift();
+			currentGeneration = gen;
+			callback(node, attr, gen);
+			graph.forEachOutNeighbor(node, neighborCallback);
+		}
+		if (total !== 0) throw new Error("graphology-dag/topological-sort: given graph is not acyclic.");
+	}
+	function topologicalSort(graph) {
+		if (!isGraph(graph)) throw new Error("graphology-dag/topological-sort: the given graph is not a valid graphology instance.");
+		const sortedNodes = new Array(graph.order);
+		let i = 0;
+		forEachNodeInTopologicalOrder(graph, (node) => {
+			sortedNodes[i++] = node;
+		});
+		return sortedNodes;
+	}
+	/**
+	* Exporting.
+	*/
+	exports.topologicalSort = topologicalSort;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/graphology-dag@0.4.1_graphology-types@0.24.8/node_modules/graphology-dag/will-create-cycle.js
+var require_will_create_cycle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Graphology Cycle Creation Checker
+	* ==================================
+	*
+	* Function returning whether adding the given directed edge to a DAG will
+	* create a cycle.
+	*
+	* Note that this function requires the given graph to be a valid DAG forest
+	* and will not check it beforehand for performance reasons.
+	*/
+	const isGraph = require_is_graph();
+	module.exports = function willCreateCycle(graph, source, target) {
+		if (!isGraph(graph)) throw new Error("graphology-dag/will-create-cycle: the given graph is not a valid graphology instance.");
+		source = "" + source;
+		target = "" + target;
+		if (source === target) return true;
+		if (!graph.hasNode(source) || !graph.hasNode(target)) return false;
+		if (graph.hasDirectedEdge(source, target)) return false;
+		if (graph.hasDirectedEdge(target, source)) return true;
+		const stack = graph.outNeighbors(target);
+		function push(neighbor) {
+			stack.push(neighbor);
+		}
+		while (stack.length !== 0) {
+			const node = stack.pop();
+			if (node === source) return true;
+			graph.forEachOutNeighbor(node, push);
+		}
+		return false;
+	};
+}));
+
+//#endregion
+export { require_iterator as a, require_typed_arrays as i, require_topological_sort as n, require_foreach as o, require_iterables as r, require_will_create_cycle as t };