@webskill/sdk 0.21.0 → 0.22.0

package/dist/dagre-6A5THRUB-D0w2W27v.js

@@ -0,0 +1,4816 @@
+import { n as __name } from "./chunk-Y2CYZVJY-U3QOMqrW.js";
+import { m as log } from "./src-NkhI3UMl.js";
+import { x as getConfig2 } from "./chunk-O7XYJQB3-B6K0KOSL.js";
+import "./chunk-ZIGJFQKS-DqEFBuHR.js";
+import "./chunk-742MDFTN-CPmgCGwC.js";
+import "./chunk-MBY4JIJT-C34L7a4f.js";
+import "./chunk-7PRAP22T-BHED6GVs.js";
+import { c as updateNodeBounds } from "./chunk-7INBJB4K-C9jq9o66.js";
+import { a as setNodeElem, i as positionNode, n as getSubGraphTitleMargins } from "./chunk-5DYCD2WN-Bt97YGTd.js";
+import { a as insertEdgeLabel, i as insertEdge, l as positionEdgeLabel } from "./chunk-Z7XXMR3K-oLg1h8F3.js";
+import { $ as arrayMap, A as baseKeys, B as baseRest, C as baseFlatten, D as castPath, E as toKey, F as baseUnary, G as arrayEach, H as eq, I as isBuffer, J as constant, K as setToString, L as isArguments, M as arrayLikeKeys, N as isTypedArray, O as toString, P as nodeUtil, Q as isArray, R as isPrototype, S as Stack, T as baseGet, U as isIndex, V as overRest, W as baseFindIndex, X as identity, Y as isFunction, Z as isObject, _ as _getTag_default, a as filter, b as getSymbols, c as isArrayLikeObject, d as baseFor, et as isSymbol, f as baseIteratee, g as Uint8Array, h as hasPath, i as values, it as root, j as overArg, k as keys, l as baseEach, m as hasIn, n as reduce, nt as baseGetTag, o as forEach, p as baseProperty, q as defineProperty, r as isUndefined, rt as Symbol, s as castFunction, t as Graph, tt as isObjectLike, u as baseForOwn, v as getAllKeys, w as arrayPush, x as stubArray, y as baseGetAllKeys, z as isArrayLike } from "./graphlib-tk9gQYuN.js";
+import { r as insertCluster } from "./chunk-UA2S7LBM-DxHM29_K.js";
+import { c as sortNodesByHierarchy, i as createLayoutElementGroups, n as clusterDb, o as findNonClusterChild, r as createCommonLayoutRenderer, s as insertMeasuredNode, t as adjustClustersAndEdges } from "./chunk-3FUC2YCW-tr6jmbQf.js";
+
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_trimmedEndIndex.js
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+/**
+* Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+* character of `string`.
+*
+* @private
+* @param {string} string The string to inspect.
+* @returns {number} Returns the index of the last non-whitespace character.
+*/
+function trimmedEndIndex(string) {
+	var index = string.length;
+	while (index-- && reWhitespace.test(string.charAt(index)));
+	return index;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseTrim.js
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+/**
+* The base implementation of `_.trim`.
+*
+* @private
+* @param {string} string The string to trim.
+* @returns {string} Returns the trimmed string.
+*/
+function baseTrim(string) {
+	return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/toNumber.js
+/** Used as references for various `Number` constants. */
+var NAN = NaN;
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+/**
+* Converts `value` to a number.
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to process.
+* @returns {number} Returns the number.
+* @example
+*
+* _.toNumber(3.2);
+* // => 3.2
+*
+* _.toNumber(Number.MIN_VALUE);
+* // => 5e-324
+*
+* _.toNumber(Infinity);
+* // => Infinity
+*
+* _.toNumber('3.2');
+* // => 3.2
+*/
+function toNumber(value) {
+	if (typeof value == "number") return value;
+	if (isSymbol(value)) return NAN;
+	if (isObject(value)) {
+		var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+		value = isObject(other) ? other + "" : other;
+	}
+	if (typeof value != "string") return value === 0 ? value : +value;
+	value = baseTrim(value);
+	var isBinary = reIsBinary.test(value);
+	return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/toFinite.js
+/** Used as references for various `Number` constants. */
+var INFINITY = Infinity;
+var MAX_INTEGER = 17976931348623157e292;
+/**
+* Converts `value` to a finite number.
+*
+* @static
+* @memberOf _
+* @since 4.12.0
+* @category Lang
+* @param {*} value The value to convert.
+* @returns {number} Returns the converted number.
+* @example
+*
+* _.toFinite(3.2);
+* // => 3.2
+*
+* _.toFinite(Number.MIN_VALUE);
+* // => 5e-324
+*
+* _.toFinite(Infinity);
+* // => 1.7976931348623157e+308
+*
+* _.toFinite('3.2');
+* // => 3.2
+*/
+function toFinite(value) {
+	if (!value) return value === 0 ? value : 0;
+	value = toNumber(value);
+	if (value === INFINITY || value === -INFINITY) return (value < 0 ? -1 : 1) * MAX_INTEGER;
+	return value === value ? value : 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/toInteger.js
+/**
+* Converts `value` to an integer.
+*
+* **Note:** This method is loosely based on
+* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Lang
+* @param {*} value The value to convert.
+* @returns {number} Returns the converted integer.
+* @example
+*
+* _.toInteger(3.2);
+* // => 3
+*
+* _.toInteger(Number.MIN_VALUE);
+* // => 0
+*
+* _.toInteger(Infinity);
+* // => 1.7976931348623157e+308
+*
+* _.toInteger('3.2');
+* // => 3
+*/
+function toInteger(value) {
+	var result = toFinite(value), remainder = result % 1;
+	return result === result ? remainder ? result - remainder : result : 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseCreate.js
+/** Built-in value references. */
+var objectCreate = Object.create;
+/**
+* The base implementation of `_.create` without support for assigning
+* properties to the created object.
+*
+* @private
+* @param {Object} proto The object to inherit from.
+* @returns {Object} Returns the new object.
+*/
+var baseCreate = function() {
+	function object() {}
+	return function(proto) {
+		if (!isObject(proto)) return {};
+		if (objectCreate) return objectCreate(proto);
+		object.prototype = proto;
+		var result = new object();
+		object.prototype = void 0;
+		return result;
+	};
+}();
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copyArray.js
+/**
+* Copies the values of `source` to `array`.
+*
+* @private
+* @param {Array} source The array to copy values from.
+* @param {Array} [array=[]] The array to copy values to.
+* @returns {Array} Returns `array`.
+*/
+function copyArray(source, array) {
+	var index = -1, length = source.length;
+	array || (array = Array(length));
+	while (++index < length) array[index] = source[index];
+	return array;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssignValue.js
+/**
+* The base implementation of `assignValue` and `assignMergeValue` without
+* value checks.
+*
+* @private
+* @param {Object} object The object to modify.
+* @param {string} key The key of the property to assign.
+* @param {*} value The value to assign.
+*/
+function baseAssignValue(object, key, value) {
+	if (key == "__proto__" && defineProperty) defineProperty(object, key, {
+		"configurable": true,
+		"enumerable": true,
+		"value": value,
+		"writable": true
+	});
+	else object[key] = value;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_assignValue.js
+/** Used to check objects for own properties. */
+var hasOwnProperty$5 = Object.prototype.hasOwnProperty;
+/**
+* Assigns `value` to `key` of `object` if the existing value is not equivalent
+* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+* for equality comparisons.
+*
+* @private
+* @param {Object} object The object to modify.
+* @param {string} key The key of the property to assign.
+* @param {*} value The value to assign.
+*/
+function assignValue(object, key, value) {
+	var objValue = object[key];
+	if (!(hasOwnProperty$5.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) baseAssignValue(object, key, value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copyObject.js
+/**
+* Copies properties of `source` to `object`.
+*
+* @private
+* @param {Object} source The object to copy properties from.
+* @param {Array} props The property identifiers to copy.
+* @param {Object} [object={}] The object to copy properties to.
+* @param {Function} [customizer] The function to customize copied values.
+* @returns {Object} Returns `object`.
+*/
+function copyObject(source, props, object, customizer) {
+	var isNew = !object;
+	object || (object = {});
+	var index = -1, length = props.length;
+	while (++index < length) {
+		var key = props[index];
+		var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+		if (newValue === void 0) newValue = source[key];
+		if (isNew) baseAssignValue(object, key, newValue);
+		else assignValue(object, key, newValue);
+	}
+	return object;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_isIterateeCall.js
+/**
+* Checks if the given arguments are from an iteratee call.
+*
+* @private
+* @param {*} value The potential iteratee value argument.
+* @param {*} index The potential iteratee index or key argument.
+* @param {*} object The potential iteratee object argument.
+* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+*  else `false`.
+*/
+function isIterateeCall(value, index, object) {
+	if (!isObject(object)) return false;
+	var type = typeof index;
+	if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) return eq(object[index], value);
+	return false;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_createAssigner.js
+/**
+* Creates a function like `_.assign`.
+*
+* @private
+* @param {Function} assigner The function to assign values.
+* @returns {Function} Returns the new assigner function.
+*/
+function createAssigner(assigner) {
+	return baseRest(function(object, sources) {
+		var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+		customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+		if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+			customizer = length < 3 ? void 0 : customizer;
+			length = 1;
+		}
+		object = Object(object);
+		while (++index < length) {
+			var source = sources[index];
+			if (source) assigner(object, source, index, customizer);
+		}
+		return object;
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_nativeKeysIn.js
+/**
+* This function is like
+* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+* except that it includes inherited enumerable properties.
+*
+* @private
+* @param {Object} object The object to query.
+* @returns {Array} Returns the array of property names.
+*/
+function nativeKeysIn(object) {
+	var result = [];
+	if (object != null) for (var key in Object(object)) result.push(key);
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseKeysIn.js
+/** Used to check objects for own properties. */
+var hasOwnProperty$4 = Object.prototype.hasOwnProperty;
+/**
+* The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+*
+* @private
+* @param {Object} object The object to query.
+* @returns {Array} Returns the array of property names.
+*/
+function baseKeysIn(object) {
+	if (!isObject(object)) return nativeKeysIn(object);
+	var isProto = isPrototype(object), result = [];
+	for (var key in object) if (!(key == "constructor" && (isProto || !hasOwnProperty$4.call(object, key)))) result.push(key);
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/keysIn.js
+/**
+* Creates an array of the own and inherited enumerable property names of `object`.
+*
+* **Note:** Non-object values are coerced to objects.
+*
+* @static
+* @memberOf _
+* @since 3.0.0
+* @category Object
+* @param {Object} object The object to query.
+* @returns {Array} Returns the array of property names.
+* @example
+*
+* function Foo() {
+*   this.a = 1;
+*   this.b = 2;
+* }
+*
+* Foo.prototype.c = 3;
+*
+* _.keysIn(new Foo);
+* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+*/
+function keysIn(object) {
+	return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/flatten.js
+/**
+* Flattens `array` a single level deep.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Array
+* @param {Array} array The array to flatten.
+* @returns {Array} Returns the new flattened array.
+* @example
+*
+* _.flatten([1, [2, [3, [4]], 5]]);
+* // => [1, 2, [3, [4]], 5]
+*/
+function flatten(array) {
+	return (array == null ? 0 : array.length) ? baseFlatten(array, 1) : [];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_flatRest.js
+/**
+* A specialized version of `baseRest` which flattens the rest array.
+*
+* @private
+* @param {Function} func The function to apply a rest parameter to.
+* @returns {Function} Returns the new function.
+*/
+function flatRest(func) {
+	return setToString(overRest(func, void 0, flatten), func + "");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getPrototype.js
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isPlainObject.js
+/** `Object#toString` result references. */
+var objectTag$1 = "[object Object]";
+/** Used for built-in method references. */
+var funcProto = Function.prototype;
+var objectProto$1 = Object.prototype;
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+/** Used to check objects for own properties. */
+var hasOwnProperty$3 = objectProto$1.hasOwnProperty;
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+/**
+* Checks if `value` is a plain object, that is, an object created by the
+* `Object` constructor or one with a `[[Prototype]]` of `null`.
+*
+* @static
+* @memberOf _
+* @since 0.8.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+* @example
+*
+* function Foo() {
+*   this.a = 1;
+* }
+*
+* _.isPlainObject(new Foo);
+* // => false
+*
+* _.isPlainObject([1, 2, 3]);
+* // => false
+*
+* _.isPlainObject({ 'x': 0, 'y': 0 });
+* // => true
+*
+* _.isPlainObject(Object.create(null));
+* // => true
+*/
+function isPlainObject(value) {
+	if (!isObjectLike(value) || baseGetTag(value) != objectTag$1) return false;
+	var proto = getPrototype(value);
+	if (proto === null) return true;
+	var Ctor = hasOwnProperty$3.call(proto, "constructor") && proto.constructor;
+	return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_hasUnicode.js
+/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+var reHasUnicode = RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");
+/**
+* Checks if `string` contains Unicode symbols.
+*
+* @private
+* @param {string} string The string to inspect.
+* @returns {boolean} Returns `true` if a symbol is found, else `false`.
+*/
+function hasUnicode(string) {
+	return reHasUnicode.test(string);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssign.js
+/**
+* The base implementation of `_.assign` without support for multiple sources
+* or `customizer` functions.
+*
+* @private
+* @param {Object} object The destination object.
+* @param {Object} source The source object.
+* @returns {Object} Returns `object`.
+*/
+function baseAssign(object, source) {
+	return object && copyObject(source, keys(source), object);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseAssignIn.js
+/**
+* The base implementation of `_.assignIn` without support for multiple sources
+* or `customizer` functions.
+*
+* @private
+* @param {Object} object The destination object.
+* @param {Object} source The source object.
+* @returns {Object} Returns `object`.
+*/
+function baseAssignIn(object, source) {
+	return object && copyObject(source, keysIn(source), object);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneBuffer.js
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+/** Built-in value references. */
+var Buffer = freeModule && freeModule.exports === freeExports ? root.Buffer : void 0;
+var allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+/**
+* Creates a clone of  `buffer`.
+*
+* @private
+* @param {Buffer} buffer The buffer to clone.
+* @param {boolean} [isDeep] Specify a deep clone.
+* @returns {Buffer} Returns the cloned buffer.
+*/
+function cloneBuffer(buffer, isDeep) {
+	if (isDeep) return buffer.slice();
+	var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+	buffer.copy(result);
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copySymbols.js
+/**
+* Copies own symbols of `source` to `object`.
+*
+* @private
+* @param {Object} source The object to copy symbols from.
+* @param {Object} [object={}] The object to copy symbols to.
+* @returns {Object} Returns `object`.
+*/
+function copySymbols(source, object) {
+	return copyObject(source, getSymbols(source), object);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getSymbolsIn.js
+/**
+* Creates an array of the own and inherited enumerable symbols of `object`.
+*
+* @private
+* @param {Object} object The object to query.
+* @returns {Array} Returns the array of symbols.
+*/
+var getSymbolsIn = !Object.getOwnPropertySymbols ? stubArray : function(object) {
+	var result = [];
+	while (object) {
+		arrayPush(result, getSymbols(object));
+		object = getPrototype(object);
+	}
+	return result;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_copySymbolsIn.js
+/**
+* Copies own and inherited symbols of `source` to `object`.
+*
+* @private
+* @param {Object} source The object to copy symbols from.
+* @param {Object} [object={}] The object to copy symbols to.
+* @returns {Object} Returns `object`.
+*/
+function copySymbolsIn(source, object) {
+	return copyObject(source, getSymbolsIn(source), object);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_getAllKeysIn.js
+/**
+* Creates an array of own and inherited enumerable property names and
+* symbols of `object`.
+*
+* @private
+* @param {Object} object The object to query.
+* @returns {Array} Returns the array of property names and symbols.
+*/
+function getAllKeysIn(object) {
+	return baseGetAllKeys(object, keysIn, getSymbolsIn);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneArray.js
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+/**
+* Initializes an array clone.
+*
+* @private
+* @param {Array} array The array to clone.
+* @returns {Array} Returns the initialized clone.
+*/
+function initCloneArray(array) {
+	var length = array.length, result = new array.constructor(length);
+	if (length && typeof array[0] == "string" && hasOwnProperty$2.call(array, "index")) {
+		result.index = array.index;
+		result.input = array.input;
+	}
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneArrayBuffer.js
+/**
+* Creates a clone of `arrayBuffer`.
+*
+* @private
+* @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+* @returns {ArrayBuffer} Returns the cloned array buffer.
+*/
+function cloneArrayBuffer(arrayBuffer) {
+	var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+	new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneDataView.js
+/**
+* Creates a clone of `dataView`.
+*
+* @private
+* @param {Object} dataView The data view to clone.
+* @param {boolean} [isDeep] Specify a deep clone.
+* @returns {Object} Returns the cloned data view.
+*/
+function cloneDataView(dataView, isDeep) {
+	var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+	return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneRegExp.js
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+/**
+* Creates a clone of `regexp`.
+*
+* @private
+* @param {Object} regexp The regexp to clone.
+* @returns {Object} Returns the cloned regexp.
+*/
+function cloneRegExp(regexp) {
+	var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+	result.lastIndex = regexp.lastIndex;
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneSymbol.js
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : void 0;
+var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+/**
+* Creates a clone of the `symbol` object.
+*
+* @private
+* @param {Object} symbol The symbol object to clone.
+* @returns {Object} Returns the cloned symbol object.
+*/
+function cloneSymbol(symbol) {
+	return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_cloneTypedArray.js
+/**
+* Creates a clone of `typedArray`.
+*
+* @private
+* @param {Object} typedArray The typed array to clone.
+* @param {boolean} [isDeep] Specify a deep clone.
+* @returns {Object} Returns the cloned typed array.
+*/
+function cloneTypedArray(typedArray, isDeep) {
+	var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+	return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneByTag.js
+/** `Object#toString` result references. */
+var boolTag$1 = "[object Boolean]";
+var dateTag$1 = "[object Date]";
+var mapTag$3 = "[object Map]";
+var numberTag$1 = "[object Number]";
+var regexpTag$1 = "[object RegExp]";
+var setTag$3 = "[object Set]";
+var stringTag$2 = "[object String]";
+var symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]";
+var dataViewTag$1 = "[object DataView]";
+var float32Tag$1 = "[object Float32Array]";
+var float64Tag$1 = "[object Float64Array]";
+var int8Tag$1 = "[object Int8Array]";
+var int16Tag$1 = "[object Int16Array]";
+var int32Tag$1 = "[object Int32Array]";
+var uint8Tag$1 = "[object Uint8Array]";
+var uint8ClampedTag$1 = "[object Uint8ClampedArray]";
+var uint16Tag$1 = "[object Uint16Array]";
+var uint32Tag$1 = "[object Uint32Array]";
+/**
+* Initializes an object clone based on its `toStringTag`.
+*
+* **Note:** This function only supports cloning values with tags of
+* `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+*
+* @private
+* @param {Object} object The object to clone.
+* @param {string} tag The `toStringTag` of the object to clone.
+* @param {boolean} [isDeep] Specify a deep clone.
+* @returns {Object} Returns the initialized clone.
+*/
+function initCloneByTag(object, tag, isDeep) {
+	var Ctor = object.constructor;
+	switch (tag) {
+		case arrayBufferTag$1: return cloneArrayBuffer(object);
+		case boolTag$1:
+		case dateTag$1: return new Ctor(+object);
+		case dataViewTag$1: return cloneDataView(object, isDeep);
+		case float32Tag$1:
+		case float64Tag$1:
+		case int8Tag$1:
+		case int16Tag$1:
+		case int32Tag$1:
+		case uint8Tag$1:
+		case uint8ClampedTag$1:
+		case uint16Tag$1:
+		case uint32Tag$1: return cloneTypedArray(object, isDeep);
+		case mapTag$3: return new Ctor();
+		case numberTag$1:
+		case stringTag$2: return new Ctor(object);
+		case regexpTag$1: return cloneRegExp(object);
+		case setTag$3: return new Ctor();
+		case symbolTag$1: return cloneSymbol(object);
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_initCloneObject.js
+/**
+* Initializes an object clone.
+*
+* @private
+* @param {Object} object The object to clone.
+* @returns {Object} Returns the initialized clone.
+*/
+function initCloneObject(object) {
+	return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsMap.js
+/** `Object#toString` result references. */
+var mapTag$2 = "[object Map]";
+/**
+* The base implementation of `_.isMap` without Node.js optimizations.
+*
+* @private
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a map, else `false`.
+*/
+function baseIsMap(value) {
+	return isObjectLike(value) && _getTag_default(value) == mapTag$2;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isMap.js
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+/**
+* Checks if `value` is classified as a `Map` object.
+*
+* @static
+* @memberOf _
+* @since 4.3.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a map, else `false`.
+* @example
+*
+* _.isMap(new Map);
+* // => true
+*
+* _.isMap(new WeakMap);
+* // => false
+*/
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseIsSet.js
+/** `Object#toString` result references. */
+var setTag$2 = "[object Set]";
+/**
+* The base implementation of `_.isSet` without Node.js optimizations.
+*
+* @private
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a set, else `false`.
+*/
+function baseIsSet(value) {
+	return isObjectLike(value) && _getTag_default(value) == setTag$2;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isSet.js
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+/**
+* Checks if `value` is classified as a `Set` object.
+*
+* @static
+* @memberOf _
+* @since 4.3.0
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a set, else `false`.
+* @example
+*
+* _.isSet(new Set);
+* // => true
+*
+* _.isSet(new WeakSet);
+* // => false
+*/
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseClone.js
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG$1 = 1;
+var CLONE_FLAT_FLAG = 2;
+var CLONE_SYMBOLS_FLAG$1 = 4;
+/** `Object#toString` result references. */
+var argsTag = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var mapTag$1 = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag$1 = "[object Set]";
+var stringTag$1 = "[object String]";
+var symbolTag = "[object Symbol]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+/**
+* The base implementation of `_.clone` and `_.cloneDeep` which tracks
+* traversed objects.
+*
+* @private
+* @param {*} value The value to clone.
+* @param {boolean} bitmask The bitmask flags.
+*  1 - Deep clone
+*  2 - Flatten inherited properties
+*  4 - Clone symbols
+* @param {Function} [customizer] The function to customize cloning.
+* @param {string} [key] The key of `value`.
+* @param {Object} [object] The parent object of `value`.
+* @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+* @returns {*} Returns the cloned value.
+*/
+function baseClone(value, bitmask, customizer, key, object, stack) {
+	var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
+	if (customizer) result = object ? customizer(value, key, object, stack) : customizer(value);
+	if (result !== void 0) return result;
+	if (!isObject(value)) return value;
+	var isArr = isArray(value);
+	if (isArr) {
+		result = initCloneArray(value);
+		if (!isDeep) return copyArray(value, result);
+	} else {
+		var tag = _getTag_default(value), isFunc = tag == funcTag || tag == genTag;
+		if (isBuffer(value)) return cloneBuffer(value, isDeep);
+		if (tag == objectTag || tag == argsTag || isFunc && !object) {
+			result = isFlat || isFunc ? {} : initCloneObject(value);
+			if (!isDeep) return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
+		} else {
+			if (!cloneableTags[tag]) return object ? value : {};
+			result = initCloneByTag(value, tag, isDeep);
+		}
+	}
+	stack || (stack = new Stack());
+	var stacked = stack.get(value);
+	if (stacked) return stacked;
+	stack.set(value, result);
+	if (isSet(value)) value.forEach(function(subValue) {
+		result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+	});
+	else if (isMap(value)) value.forEach(function(subValue, key) {
+		result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+	});
+	var props = isArr ? void 0 : (isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys)(value);
+	arrayEach(props || value, function(subValue, key) {
+		if (props) {
+			key = subValue;
+			subValue = value[key];
+		}
+		assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+	});
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/cloneDeep.js
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1;
+var CLONE_SYMBOLS_FLAG = 4;
+/**
+* This method is like `_.clone` except that it recursively clones `value`.
+*
+* @static
+* @memberOf _
+* @since 1.0.0
+* @category Lang
+* @param {*} value The value to recursively clone.
+* @returns {*} Returns the deep cloned value.
+* @see _.clone
+* @example
+*
+* var objects = [{ 'a': 1 }, { 'b': 2 }];
+*
+* var deep = _.cloneDeep(objects);
+* console.log(deep[0] === objects[0]);
+* // => false
+*/
+function cloneDeep(value) {
+	return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/now.js
+/**
+* Gets the timestamp of the number of milliseconds that have elapsed since
+* the Unix epoch (1 January 1970 00:00:00 UTC).
+*
+* @static
+* @memberOf _
+* @since 2.4.0
+* @category Date
+* @returns {number} Returns the timestamp.
+* @example
+*
+* _.defer(function(stamp) {
+*   console.log(_.now() - stamp);
+* }, _.now());
+* // => Logs the number of milliseconds it took for the deferred invocation.
+*/
+var now = function() {
+	return root.Date.now();
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/defaults.js
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto.hasOwnProperty;
+/**
+* Assigns own and inherited enumerable string keyed properties of source
+* objects to the destination object for all destination properties that
+* resolve to `undefined`. Source objects are applied from left to right.
+* Once a property is set, additional values of the same property are ignored.
+*
+* **Note:** This method mutates `object`.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Object
+* @param {Object} object The destination object.
+* @param {...Object} [sources] The source objects.
+* @returns {Object} Returns `object`.
+* @see _.defaultsDeep
+* @example
+*
+* _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+* // => { 'a': 1, 'b': 2 }
+*/
+var defaults = baseRest(function(object, sources) {
+	object = Object(object);
+	var index = -1;
+	var length = sources.length;
+	var guard = length > 2 ? sources[2] : void 0;
+	if (guard && isIterateeCall(sources[0], sources[1], guard)) length = 1;
+	while (++index < length) {
+		var source = sources[index];
+		var props = keysIn(source);
+		var propsIndex = -1;
+		var propsLength = props.length;
+		while (++propsIndex < propsLength) {
+			var key = props[propsIndex];
+			var value = object[key];
+			if (value === void 0 || eq(value, objectProto[key]) && !hasOwnProperty$1.call(object, key)) object[key] = source[key];
+		}
+	}
+	return object;
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_assignMergeValue.js
+/**
+* This function is like `assignValue` except that it doesn't assign
+* `undefined` values.
+*
+* @private
+* @param {Object} object The object to modify.
+* @param {string} key The key of the property to assign.
+* @param {*} value The value to assign.
+*/
+function assignMergeValue(object, key, value) {
+	if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) baseAssignValue(object, key, value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_safeGet.js
+/**
+* Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+*
+* @private
+* @param {Object} object The object to query.
+* @param {string} key The key of the property to get.
+* @returns {*} Returns the property value.
+*/
+function safeGet(object, key) {
+	if (key === "constructor" && typeof object[key] === "function") return;
+	if (key == "__proto__") return;
+	return object[key];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/toPlainObject.js
+/**
+* Converts `value` to a plain object flattening inherited enumerable string
+* keyed properties of `value` to own properties of the plain object.
+*
+* @static
+* @memberOf _
+* @since 3.0.0
+* @category Lang
+* @param {*} value The value to convert.
+* @returns {Object} Returns the converted plain object.
+* @example
+*
+* function Foo() {
+*   this.b = 2;
+* }
+*
+* Foo.prototype.c = 3;
+*
+* _.assign({ 'a': 1 }, new Foo);
+* // => { 'a': 1, 'b': 2 }
+*
+* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+* // => { 'a': 1, 'b': 2, 'c': 3 }
+*/
+function toPlainObject(value) {
+	return copyObject(value, keysIn(value));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseMergeDeep.js
+/**
+* A specialized version of `baseMerge` for arrays and objects which performs
+* deep merges and tracks traversed objects enabling objects with circular
+* references to be merged.
+*
+* @private
+* @param {Object} object The destination object.
+* @param {Object} source The source object.
+* @param {string} key The key of the value to merge.
+* @param {number} srcIndex The index of `source`.
+* @param {Function} mergeFunc The function to merge values.
+* @param {Function} [customizer] The function to customize assigned values.
+* @param {Object} [stack] Tracks traversed source values and their merged
+*  counterparts.
+*/
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+	var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
+	if (stacked) {
+		assignMergeValue(object, key, stacked);
+		return;
+	}
+	var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+	var isCommon = newValue === void 0;
+	if (isCommon) {
+		var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+		newValue = srcValue;
+		if (isArr || isBuff || isTyped) if (isArray(objValue)) newValue = objValue;
+		else if (isArrayLikeObject(objValue)) newValue = copyArray(objValue);
+		else if (isBuff) {
+			isCommon = false;
+			newValue = cloneBuffer(srcValue, true);
+		} else if (isTyped) {
+			isCommon = false;
+			newValue = cloneTypedArray(srcValue, true);
+		} else newValue = [];
+		else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+			newValue = objValue;
+			if (isArguments(objValue)) newValue = toPlainObject(objValue);
+			else if (!isObject(objValue) || isFunction(objValue)) newValue = initCloneObject(srcValue);
+		} else isCommon = false;
+	}
+	if (isCommon) {
+		stack.set(srcValue, newValue);
+		mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+		stack["delete"](srcValue);
+	}
+	assignMergeValue(object, key, newValue);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseMerge.js
+/**
+* The base implementation of `_.merge` without support for multiple sources.
+*
+* @private
+* @param {Object} object The destination object.
+* @param {Object} source The source object.
+* @param {number} srcIndex The index of `source`.
+* @param {Function} [customizer] The function to customize merged values.
+* @param {Object} [stack] Tracks traversed source values and their merged
+*  counterparts.
+*/
+function baseMerge(object, source, srcIndex, customizer, stack) {
+	if (object === source) return;
+	baseFor(source, function(srcValue, key) {
+		stack || (stack = new Stack());
+		if (isObject(srcValue)) baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+		else {
+			var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+			if (newValue === void 0) newValue = srcValue;
+			assignMergeValue(object, key, newValue);
+		}
+	}, keysIn);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/last.js
+/**
+* Gets the last element of `array`.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Array
+* @param {Array} array The array to query.
+* @returns {*} Returns the last element of `array`.
+* @example
+*
+* _.last([1, 2, 3]);
+* // => 3
+*/
+function last(array) {
+	var length = array == null ? 0 : array.length;
+	return length ? array[length - 1] : void 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_createFind.js
+/**
+* Creates a `_.find` or `_.findLast` function.
+*
+* @private
+* @param {Function} findIndexFunc The function to find the collection index.
+* @returns {Function} Returns the new find function.
+*/
+function createFind(findIndexFunc) {
+	return function(collection, predicate, fromIndex) {
+		var iterable = Object(collection);
+		if (!isArrayLike(collection)) {
+			var iteratee = baseIteratee(predicate, 3);
+			collection = keys(collection);
+			predicate = function(key) {
+				return iteratee(iterable[key], key, iterable);
+			};
+		}
+		var index = findIndexFunc(collection, predicate, fromIndex);
+		return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/findIndex.js
+var nativeMax$1 = Math.max;
+/**
+* This method is like `_.find` except that it returns the index of the first
+* element `predicate` returns truthy for instead of the element itself.
+*
+* @static
+* @memberOf _
+* @since 1.1.0
+* @category Array
+* @param {Array} array The array to inspect.
+* @param {Function} [predicate=_.identity] The function invoked per iteration.
+* @param {number} [fromIndex=0] The index to search from.
+* @returns {number} Returns the index of the found element, else `-1`.
+* @example
+*
+* var users = [
+*   { 'user': 'barney',  'active': false },
+*   { 'user': 'fred',    'active': false },
+*   { 'user': 'pebbles', 'active': true }
+* ];
+*
+* _.findIndex(users, function(o) { return o.user == 'barney'; });
+* // => 0
+*
+* // The `_.matches` iteratee shorthand.
+* _.findIndex(users, { 'user': 'fred', 'active': false });
+* // => 1
+*
+* // The `_.matchesProperty` iteratee shorthand.
+* _.findIndex(users, ['active', false]);
+* // => 0
+*
+* // The `_.property` iteratee shorthand.
+* _.findIndex(users, 'active');
+* // => 2
+*/
+function findIndex(array, predicate, fromIndex) {
+	var length = array == null ? 0 : array.length;
+	if (!length) return -1;
+	var index = fromIndex == null ? 0 : toInteger(fromIndex);
+	if (index < 0) index = nativeMax$1(length + index, 0);
+	return baseFindIndex(array, baseIteratee(predicate, 3), index);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/find.js
+/**
+* Iterates over elements of `collection`, returning the first element
+* `predicate` returns truthy for. The predicate is invoked with three
+* arguments: (value, index|key, collection).
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Collection
+* @param {Array|Object} collection The collection to inspect.
+* @param {Function} [predicate=_.identity] The function invoked per iteration.
+* @param {number} [fromIndex=0] The index to search from.
+* @returns {*} Returns the matched element, else `undefined`.
+* @example
+*
+* var users = [
+*   { 'user': 'barney',  'age': 36, 'active': true },
+*   { 'user': 'fred',    'age': 40, 'active': false },
+*   { 'user': 'pebbles', 'age': 1,  'active': true }
+* ];
+*
+* _.find(users, function(o) { return o.age < 40; });
+* // => object for 'barney'
+*
+* // The `_.matches` iteratee shorthand.
+* _.find(users, { 'age': 1, 'active': true });
+* // => object for 'pebbles'
+*
+* // The `_.matchesProperty` iteratee shorthand.
+* _.find(users, ['active', false]);
+* // => object for 'fred'
+*
+* // The `_.property` iteratee shorthand.
+* _.find(users, 'active');
+* // => object for 'barney'
+*/
+var find = createFind(findIndex);
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseMap.js
+/**
+* The base implementation of `_.map` without support for iteratee shorthands.
+*
+* @private
+* @param {Array|Object} collection The collection to iterate over.
+* @param {Function} iteratee The function invoked per iteration.
+* @returns {Array} Returns the new mapped array.
+*/
+function baseMap(collection, iteratee) {
+	var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+	baseEach(collection, function(value, key, collection) {
+		result[++index] = iteratee(value, key, collection);
+	});
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/map.js
+/**
+* Creates an array of values by running each element in `collection` thru
+* `iteratee`. The iteratee is invoked with three arguments:
+* (value, index|key, collection).
+*
+* Many lodash methods are guarded to work as iteratees for methods like
+* `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+*
+* The guarded methods are:
+* `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
+* `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
+* `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+* `template`, `trim`, `trimEnd`, `trimStart`, and `words`
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Collection
+* @param {Array|Object} collection The collection to iterate over.
+* @param {Function} [iteratee=_.identity] The function invoked per iteration.
+* @returns {Array} Returns the new mapped array.
+* @example
+*
+* function square(n) {
+*   return n * n;
+* }
+*
+* _.map([4, 8], square);
+* // => [16, 64]
+*
+* _.map({ 'a': 4, 'b': 8 }, square);
+* // => [16, 64] (iteration order is not guaranteed)
+*
+* var users = [
+*   { 'user': 'barney' },
+*   { 'user': 'fred' }
+* ];
+*
+* // The `_.property` iteratee shorthand.
+* _.map(users, 'user');
+* // => ['barney', 'fred']
+*/
+function map(collection, iteratee) {
+	return (isArray(collection) ? arrayMap : baseMap)(collection, baseIteratee(iteratee, 3));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/forIn.js
+/**
+* Iterates over own and inherited enumerable string keyed properties of an
+* object and invokes `iteratee` for each property. The iteratee is invoked
+* with three arguments: (value, key, object). Iteratee functions may exit
+* iteration early by explicitly returning `false`.
+*
+* @static
+* @memberOf _
+* @since 0.3.0
+* @category Object
+* @param {Object} object The object to iterate over.
+* @param {Function} [iteratee=_.identity] The function invoked per iteration.
+* @returns {Object} Returns `object`.
+* @see _.forInRight
+* @example
+*
+* function Foo() {
+*   this.a = 1;
+*   this.b = 2;
+* }
+*
+* Foo.prototype.c = 3;
+*
+* _.forIn(new Foo, function(value, key) {
+*   console.log(key);
+* });
+* // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
+*/
+function forIn(object, iteratee) {
+	return object == null ? object : baseFor(object, castFunction(iteratee), keysIn);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/forOwn.js
+/**
+* Iterates over own enumerable string keyed properties of an object and
+* invokes `iteratee` for each property. The iteratee is invoked with three
+* arguments: (value, key, object). Iteratee functions may exit iteration
+* early by explicitly returning `false`.
+*
+* @static
+* @memberOf _
+* @since 0.3.0
+* @category Object
+* @param {Object} object The object to iterate over.
+* @param {Function} [iteratee=_.identity] The function invoked per iteration.
+* @returns {Object} Returns `object`.
+* @see _.forOwnRight
+* @example
+*
+* function Foo() {
+*   this.a = 1;
+*   this.b = 2;
+* }
+*
+* Foo.prototype.c = 3;
+*
+* _.forOwn(new Foo, function(value, key) {
+*   console.log(key);
+* });
+* // => Logs 'a' then 'b' (iteration order is not guaranteed).
+*/
+function forOwn(object, iteratee) {
+	return object && baseForOwn(object, castFunction(iteratee));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseGt.js
+/**
+* The base implementation of `_.gt` which doesn't coerce arguments.
+*
+* @private
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @returns {boolean} Returns `true` if `value` is greater than `other`,
+*  else `false`.
+*/
+function baseGt(value, other) {
+	return value > other;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseHas.js
+/** Used to check objects for own properties. */
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+/**
+* The base implementation of `_.has` without support for deep paths.
+*
+* @private
+* @param {Object} [object] The object to query.
+* @param {Array|string} key The key to check.
+* @returns {boolean} Returns `true` if `key` exists, else `false`.
+*/
+function baseHas(object, key) {
+	return object != null && hasOwnProperty.call(object, key);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/has.js
+/**
+* Checks if `path` is a direct property of `object`.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Object
+* @param {Object} object The object to query.
+* @param {Array|string} path The path to check.
+* @returns {boolean} Returns `true` if `path` exists, else `false`.
+* @example
+*
+* var object = { 'a': { 'b': 2 } };
+* var other = _.create({ 'a': _.create({ 'b': 2 }) });
+*
+* _.has(object, 'a');
+* // => true
+*
+* _.has(object, 'a.b');
+* // => true
+*
+* _.has(object, ['a', 'b']);
+* // => true
+*
+* _.has(other, 'a');
+* // => false
+*/
+function has(object, path) {
+	return object != null && hasPath(object, path, baseHas);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isString.js
+/** `Object#toString` result references. */
+var stringTag = "[object String]";
+/**
+* Checks if `value` is classified as a `String` primitive or object.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Lang
+* @param {*} value The value to check.
+* @returns {boolean} Returns `true` if `value` is a string, else `false`.
+* @example
+*
+* _.isString('abc');
+* // => true
+*
+* _.isString(1);
+* // => false
+*/
+function isString(value) {
+	return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseLt.js
+/**
+* The base implementation of `_.lt` which doesn't coerce arguments.
+*
+* @private
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @returns {boolean} Returns `true` if `value` is less than `other`,
+*  else `false`.
+*/
+function baseLt(value, other) {
+	return value < other;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/mapValues.js
+/**
+* Creates an object with the same keys as `object` and values generated
+* by running each own enumerable string keyed property of `object` thru
+* `iteratee`. The iteratee is invoked with three arguments:
+* (value, key, object).
+*
+* @static
+* @memberOf _
+* @since 2.4.0
+* @category Object
+* @param {Object} object The object to iterate over.
+* @param {Function} [iteratee=_.identity] The function invoked per iteration.
+* @returns {Object} Returns the new mapped object.
+* @see _.mapKeys
+* @example
+*
+* var users = {
+*   'fred':    { 'user': 'fred',    'age': 40 },
+*   'pebbles': { 'user': 'pebbles', 'age': 1 }
+* };
+*
+* _.mapValues(users, function(o) { return o.age; });
+* // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+*
+* // The `_.property` iteratee shorthand.
+* _.mapValues(users, 'age');
+* // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+*/
+function mapValues(object, iteratee) {
+	var result = {};
+	iteratee = baseIteratee(iteratee, 3);
+	baseForOwn(object, function(value, key, object) {
+		baseAssignValue(result, key, iteratee(value, key, object));
+	});
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseExtremum.js
+/**
+* The base implementation of methods like `_.max` and `_.min` which accepts a
+* `comparator` to determine the extremum value.
+*
+* @private
+* @param {Array} array The array to iterate over.
+* @param {Function} iteratee The iteratee invoked per iteration.
+* @param {Function} comparator The comparator used to compare values.
+* @returns {*} Returns the extremum value.
+*/
+function baseExtremum(array, iteratee, comparator) {
+	var index = -1, length = array.length;
+	while (++index < length) {
+		var value = array[index], current = iteratee(value);
+		if (current != null && (computed === void 0 ? current === current && !isSymbol(current) : comparator(current, computed))) var computed = current, result = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/max.js
+/**
+* Computes the maximum value of `array`. If `array` is empty or falsey,
+* `undefined` is returned.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Math
+* @param {Array} array The array to iterate over.
+* @returns {*} Returns the maximum value.
+* @example
+*
+* _.max([4, 2, 8, 6]);
+* // => 8
+*
+* _.max([]);
+* // => undefined
+*/
+function max(array) {
+	return array && array.length ? baseExtremum(array, identity, baseGt) : void 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/merge.js
+/**
+* This method is like `_.assign` except that it recursively merges own and
+* inherited enumerable string keyed properties of source objects into the
+* destination object. Source properties that resolve to `undefined` are
+* skipped if a destination value exists. Array and plain object properties
+* are merged recursively. Other objects and value types are overridden by
+* assignment. Source objects are applied from left to right. Subsequent
+* sources overwrite property assignments of previous sources.
+*
+* **Note:** This method mutates `object`.
+*
+* @static
+* @memberOf _
+* @since 0.5.0
+* @category Object
+* @param {Object} object The destination object.
+* @param {...Object} [sources] The source objects.
+* @returns {Object} Returns `object`.
+* @example
+*
+* var object = {
+*   'a': [{ 'b': 2 }, { 'd': 4 }]
+* };
+*
+* var other = {
+*   'a': [{ 'c': 3 }, { 'e': 5 }]
+* };
+*
+* _.merge(object, other);
+* // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+*/
+var merge = createAssigner(function(object, source, srcIndex) {
+	baseMerge(object, source, srcIndex);
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/min.js
+/**
+* Computes the minimum value of `array`. If `array` is empty or falsey,
+* `undefined` is returned.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Math
+* @param {Array} array The array to iterate over.
+* @returns {*} Returns the minimum value.
+* @example
+*
+* _.min([4, 2, 8, 6]);
+* // => 2
+*
+* _.min([]);
+* // => undefined
+*/
+function min(array) {
+	return array && array.length ? baseExtremum(array, identity, baseLt) : void 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/minBy.js
+/**
+* This method is like `_.min` except that it accepts `iteratee` which is
+* invoked for each element in `array` to generate the criterion by which
+* the value is ranked. The iteratee is invoked with one argument: (value).
+*
+* @static
+* @memberOf _
+* @since 4.0.0
+* @category Math
+* @param {Array} array The array to iterate over.
+* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+* @returns {*} Returns the minimum value.
+* @example
+*
+* var objects = [{ 'n': 1 }, { 'n': 2 }];
+*
+* _.minBy(objects, function(o) { return o.n; });
+* // => { 'n': 1 }
+*
+* // The `_.property` iteratee shorthand.
+* _.minBy(objects, 'n');
+* // => { 'n': 1 }
+*/
+function minBy(array, iteratee) {
+	return array && array.length ? baseExtremum(array, baseIteratee(iteratee, 2), baseLt) : void 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseSet.js
+/**
+* The base implementation of `_.set`.
+*
+* @private
+* @param {Object} object The object to modify.
+* @param {Array|string} path The path of the property to set.
+* @param {*} value The value to set.
+* @param {Function} [customizer] The function to customize path creation.
+* @returns {Object} Returns `object`.
+*/
+function baseSet(object, path, value, customizer) {
+	if (!isObject(object)) return object;
+	path = castPath(path, object);
+	var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+	while (nested != null && ++index < length) {
+		var key = toKey(path[index]), newValue = value;
+		if (key === "__proto__" || key === "constructor" || key === "prototype") return object;
+		if (index != lastIndex) {
+			var objValue = nested[key];
+			newValue = customizer ? customizer(objValue, key, nested) : void 0;
+			if (newValue === void 0) newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+		}
+		assignValue(nested, key, newValue);
+		nested = nested[key];
+	}
+	return object;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_basePickBy.js
+/**
+* The base implementation of  `_.pickBy` without support for iteratee shorthands.
+*
+* @private
+* @param {Object} object The source object.
+* @param {string[]} paths The property paths to pick.
+* @param {Function} predicate The function invoked per property.
+* @returns {Object} Returns the new object.
+*/
+function basePickBy(object, paths, predicate) {
+	var index = -1, length = paths.length, result = {};
+	while (++index < length) {
+		var path = paths[index], value = baseGet(object, path);
+		if (predicate(value, path)) baseSet(result, castPath(path, object), value);
+	}
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseSortBy.js
+/**
+* The base implementation of `_.sortBy` which uses `comparer` to define the
+* sort order of `array` and replaces criteria objects with their corresponding
+* values.
+*
+* @private
+* @param {Array} array The array to sort.
+* @param {Function} comparer The function to define sort order.
+* @returns {Array} Returns `array`.
+*/
+function baseSortBy(array, comparer) {
+	var length = array.length;
+	array.sort(comparer);
+	while (length--) array[length] = array[length].value;
+	return array;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_compareAscending.js
+/**
+* Compares values to sort them in ascending order.
+*
+* @private
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @returns {number} Returns the sort order indicator for `value`.
+*/
+function compareAscending(value, other) {
+	if (value !== other) {
+		var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
+		var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
+		if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) return 1;
+		if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) return -1;
+	}
+	return 0;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_compareMultiple.js
+/**
+* Used by `_.orderBy` to compare multiple properties of a value to another
+* and stable sort them.
+*
+* If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
+* specify an order of "desc" for descending or "asc" for ascending sort order
+* of corresponding values.
+*
+* @private
+* @param {Object} object The object to compare.
+* @param {Object} other The other object to compare.
+* @param {boolean[]|string[]} orders The order to sort by for each property.
+* @returns {number} Returns the sort order indicator for `object`.
+*/
+function compareMultiple(object, other, orders) {
+	var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+	while (++index < length) {
+		var result = compareAscending(objCriteria[index], othCriteria[index]);
+		if (result) {
+			if (index >= ordersLength) return result;
+			return result * (orders[index] == "desc" ? -1 : 1);
+		}
+	}
+	return object.index - other.index;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseOrderBy.js
+/**
+* The base implementation of `_.orderBy` without param guards.
+*
+* @private
+* @param {Array|Object} collection The collection to iterate over.
+* @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
+* @param {string[]} orders The sort orders of `iteratees`.
+* @returns {Array} Returns the new sorted array.
+*/
+function baseOrderBy(collection, iteratees, orders) {
+	if (iteratees.length) iteratees = arrayMap(iteratees, function(iteratee) {
+		if (isArray(iteratee)) return function(value) {
+			return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+		};
+		return iteratee;
+	});
+	else iteratees = [identity];
+	var index = -1;
+	iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
+	return baseSortBy(baseMap(collection, function(value, key, collection) {
+		return {
+			"criteria": arrayMap(iteratees, function(iteratee) {
+				return iteratee(value);
+			}),
+			"index": ++index,
+			"value": value
+		};
+	}), function(object, other) {
+		return compareMultiple(object, other, orders);
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_asciiSize.js
+/**
+* Gets the size of an ASCII `string`.
+*
+* @private
+* @param {string} string The string inspect.
+* @returns {number} Returns the string size.
+*/
+var asciiSize = baseProperty("length");
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_unicodeSize.js
+/** Used to compose unicode character classes. */
+var rsAstralRange = "\\ud800-\\udfff";
+var rsComboRange = "\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff";
+var rsVarRange = "\\ufe0e\\ufe0f";
+/** Used to compose unicode capture groups. */
+var rsAstral = "[" + rsAstralRange + "]";
+var rsCombo = "[" + rsComboRange + "]";
+var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+var rsNonAstral = "[^" + rsAstralRange + "]";
+var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+var rsZWJ = "\\u200d";
+/** Used to compose unicode regexes. */
+var reOptMod = rsModifier + "?";
+var rsOptVar = "[" + rsVarRange + "]?";
+var rsOptJoin = "(?:" + rsZWJ + "(?:" + [
+	rsNonAstral,
+	rsRegional,
+	rsSurrPair
+].join("|") + ")" + rsOptVar + reOptMod + ")*";
+var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+var rsSymbol = "(?:" + [
+	rsNonAstral + rsCombo + "?",
+	rsCombo,
+	rsRegional,
+	rsSurrPair,
+	rsAstral
+].join("|") + ")";
+/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+/**
+* Gets the size of a Unicode `string`.
+*
+* @private
+* @param {string} string The string inspect.
+* @returns {number} Returns the string size.
+*/
+function unicodeSize(string) {
+	var result = reUnicode.lastIndex = 0;
+	while (reUnicode.test(string)) ++result;
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_stringSize.js
+/**
+* Gets the number of symbols in `string`.
+*
+* @private
+* @param {string} string The string to inspect.
+* @returns {number} Returns the string size.
+*/
+function stringSize(string) {
+	return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_basePick.js
+/**
+* The base implementation of `_.pick` without support for individual
+* property identifiers.
+*
+* @private
+* @param {Object} object The source object.
+* @param {string[]} paths The property paths to pick.
+* @returns {Object} Returns the new object.
+*/
+function basePick(object, paths) {
+	return basePickBy(object, paths, function(value, path) {
+		return hasIn(object, path);
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/pick.js
+/**
+* Creates an object composed of the picked `object` properties.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Object
+* @param {Object} object The source object.
+* @param {...(string|string[])} [paths] The property paths to pick.
+* @returns {Object} Returns the new object.
+* @example
+*
+* var object = { 'a': 1, 'b': '2', 'c': 3 };
+*
+* _.pick(object, ['a', 'c']);
+* // => { 'a': 1, 'c': 3 }
+*/
+var pick = flatRest(function(object, paths) {
+	return object == null ? {} : basePick(object, paths);
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseRange.js
+var nativeCeil = Math.ceil;
+var nativeMax = Math.max;
+/**
+* The base implementation of `_.range` and `_.rangeRight` which doesn't
+* coerce arguments.
+*
+* @private
+* @param {number} start The start of the range.
+* @param {number} end The end of the range.
+* @param {number} step The value to increment or decrement by.
+* @param {boolean} [fromRight] Specify iterating from right to left.
+* @returns {Array} Returns the range of numbers.
+*/
+function baseRange(start, end, step, fromRight) {
+	var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result = Array(length);
+	while (length--) {
+		result[fromRight ? length : ++index] = start;
+		start += step;
+	}
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_createRange.js
+/**
+* Creates a `_.range` or `_.rangeRight` function.
+*
+* @private
+* @param {boolean} [fromRight] Specify iterating from right to left.
+* @returns {Function} Returns the new range function.
+*/
+function createRange(fromRight) {
+	return function(start, end, step) {
+		if (step && typeof step != "number" && isIterateeCall(start, end, step)) end = step = void 0;
+		start = toFinite(start);
+		if (end === void 0) {
+			end = start;
+			start = 0;
+		} else end = toFinite(end);
+		step = step === void 0 ? start < end ? 1 : -1 : toFinite(step);
+		return baseRange(start, end, step, fromRight);
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/range.js
+/**
+* Creates an array of numbers (positive and/or negative) progressing from
+* `start` up to, but not including, `end`. A step of `-1` is used if a negative
+* `start` is specified without an `end` or `step`. If `end` is not specified,
+* it's set to `start` with `start` then set to `0`.
+*
+* **Note:** JavaScript follows the IEEE-754 standard for resolving
+* floating-point values which can produce unexpected results.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Util
+* @param {number} [start=0] The start of the range.
+* @param {number} end The end of the range.
+* @param {number} [step=1] The value to increment or decrement by.
+* @returns {Array} Returns the range of numbers.
+* @see _.inRange, _.rangeRight
+* @example
+*
+* _.range(4);
+* // => [0, 1, 2, 3]
+*
+* _.range(-4);
+* // => [0, -1, -2, -3]
+*
+* _.range(1, 5);
+* // => [1, 2, 3, 4]
+*
+* _.range(0, 20, 5);
+* // => [0, 5, 10, 15]
+*
+* _.range(0, -4, -1);
+* // => [0, -1, -2, -3]
+*
+* _.range(1, 4, 0);
+* // => [1, 1, 1]
+*
+* _.range(0);
+* // => []
+*/
+var range = createRange();
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/size.js
+/** `Object#toString` result references. */
+var mapTag = "[object Map]";
+var setTag = "[object Set]";
+/**
+* Gets the size of `collection` by returning its length for array-like
+* values or the number of own enumerable string keyed properties for objects.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Collection
+* @param {Array|Object|string} collection The collection to inspect.
+* @returns {number} Returns the collection size.
+* @example
+*
+* _.size([1, 2, 3]);
+* // => 3
+*
+* _.size({ 'a': 1, 'b': 2 });
+* // => 2
+*
+* _.size('pebbles');
+* // => 7
+*/
+function size(collection) {
+	if (collection == null) return 0;
+	if (isArrayLike(collection)) return isString(collection) ? stringSize(collection) : collection.length;
+	var tag = _getTag_default(collection);
+	if (tag == mapTag || tag == setTag) return collection.size;
+	return baseKeys(collection).length;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/sortBy.js
+/**
+* Creates an array of elements, sorted in ascending order by the results of
+* running each element in a collection thru each iteratee. This method
+* performs a stable sort, that is, it preserves the original sort order of
+* equal elements. The iteratees are invoked with one argument: (value).
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Collection
+* @param {Array|Object} collection The collection to iterate over.
+* @param {...(Function|Function[])} [iteratees=[_.identity]]
+*  The iteratees to sort by.
+* @returns {Array} Returns the new sorted array.
+* @example
+*
+* var users = [
+*   { 'user': 'fred',   'age': 48 },
+*   { 'user': 'barney', 'age': 36 },
+*   { 'user': 'fred',   'age': 30 },
+*   { 'user': 'barney', 'age': 34 }
+* ];
+*
+* _.sortBy(users, [function(o) { return o.user; }]);
+* // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
+*
+* _.sortBy(users, ['user', 'age']);
+* // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
+*/
+var sortBy = baseRest(function(collection, iteratees) {
+	if (collection == null) return [];
+	var length = iteratees.length;
+	if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) iteratees = [];
+	else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) iteratees = [iteratees[0]];
+	return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/uniqueId.js
+/** Used to generate unique IDs. */
+var idCounter = 0;
+/**
+* Generates a unique ID. If `prefix` is given, the ID is appended to it.
+*
+* @static
+* @since 0.1.0
+* @memberOf _
+* @category Util
+* @param {string} [prefix=''] The value to prefix the ID with.
+* @returns {string} Returns the unique ID.
+* @example
+*
+* _.uniqueId('contact_');
+* // => 'contact_104'
+*
+* _.uniqueId();
+* // => '105'
+*/
+function uniqueId(prefix) {
+	var id = ++idCounter;
+	return toString(prefix) + id;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/_baseZipObject.js
+/**
+* This base implementation of `_.zipObject` which assigns values using `assignFunc`.
+*
+* @private
+* @param {Array} props The property identifiers.
+* @param {Array} values The property values.
+* @param {Function} assignFunc The function to assign values.
+* @returns {Object} Returns the new object.
+*/
+function baseZipObject(props, values, assignFunc) {
+	var index = -1, length = props.length, valsLength = values.length, result = {};
+	while (++index < length) {
+		var value = index < valsLength ? values[index] : void 0;
+		assignFunc(result, props[index], value);
+	}
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/zipObject.js
+/**
+* This method is like `_.fromPairs` except that it accepts two arrays,
+* one of property identifiers and one of corresponding values.
+*
+* @static
+* @memberOf _
+* @since 0.4.0
+* @category Array
+* @param {Array} [props=[]] The property identifiers.
+* @param {Array} [values=[]] The property values.
+* @returns {Object} Returns the new object.
+* @example
+*
+* _.zipObject(['a', 'b'], [1, 2]);
+* // => { 'a': 1, 'b': 2 }
+*/
+function zipObject(props, values) {
+	return baseZipObject(props || [], values || [], assignValue);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/data/list.js
+var List = class {
+	constructor() {
+		var sentinel = {};
+		sentinel._next = sentinel._prev = sentinel;
+		this._sentinel = sentinel;
+	}
+	dequeue() {
+		var sentinel = this._sentinel;
+		var entry = sentinel._prev;
+		if (entry !== sentinel) {
+			unlink(entry);
+			return entry;
+		}
+	}
+	enqueue(entry) {
+		var sentinel = this._sentinel;
+		if (entry._prev && entry._next) unlink(entry);
+		entry._next = sentinel._next;
+		sentinel._next._prev = entry;
+		sentinel._next = entry;
+		entry._prev = sentinel;
+	}
+	toString() {
+		var strs = [];
+		var sentinel = this._sentinel;
+		var curr = sentinel._prev;
+		while (curr !== sentinel) {
+			strs.push(JSON.stringify(curr, filterOutLinks));
+			curr = curr._prev;
+		}
+		return "[" + strs.join(", ") + "]";
+	}
+};
+function unlink(entry) {
+	entry._prev._next = entry._next;
+	entry._next._prev = entry._prev;
+	delete entry._next;
+	delete entry._prev;
+}
+function filterOutLinks(k, v) {
+	if (k !== "_next" && k !== "_prev") return v;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/greedy-fas.js
+var DEFAULT_WEIGHT_FN = constant(1);
+function greedyFAS(g, weightFn) {
+	if (g.nodeCount() <= 1) return [];
+	var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+	var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+	return flatten(map(results, function(e) {
+		return g.outEdges(e.v, e.w);
+	}));
+}
+function doGreedyFAS(g, buckets, zeroIdx) {
+	var results = [];
+	var sources = buckets[buckets.length - 1];
+	var sinks = buckets[0];
+	var entry;
+	while (g.nodeCount()) {
+		while (entry = sinks.dequeue()) removeNode(g, buckets, zeroIdx, entry);
+		while (entry = sources.dequeue()) removeNode(g, buckets, zeroIdx, entry);
+		if (g.nodeCount()) for (var i = buckets.length - 2; i > 0; --i) {
+			entry = buckets[i].dequeue();
+			if (entry) {
+				results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
+				break;
+			}
+		}
+	}
+	return results;
+}
+function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
+	var results = collectPredecessors ? [] : void 0;
+	forEach(g.inEdges(entry.v), function(edge) {
+		var weight = g.edge(edge);
+		var uEntry = g.node(edge.v);
+		if (collectPredecessors) results.push({
+			v: edge.v,
+			w: edge.w
+		});
+		uEntry.out -= weight;
+		assignBucket(buckets, zeroIdx, uEntry);
+	});
+	forEach(g.outEdges(entry.v), function(edge) {
+		var weight = g.edge(edge);
+		var w = edge.w;
+		var wEntry = g.node(w);
+		wEntry["in"] -= weight;
+		assignBucket(buckets, zeroIdx, wEntry);
+	});
+	g.removeNode(entry.v);
+	return results;
+}
+function buildState(g, weightFn) {
+	var fasGraph = new Graph();
+	var maxIn = 0;
+	var maxOut = 0;
+	forEach(g.nodes(), function(v) {
+		fasGraph.setNode(v, {
+			v,
+			in: 0,
+			out: 0
+		});
+	});
+	forEach(g.edges(), function(e) {
+		var prevWeight = fasGraph.edge(e.v, e.w) || 0;
+		var weight = weightFn(e);
+		var edgeWeight = prevWeight + weight;
+		fasGraph.setEdge(e.v, e.w, edgeWeight);
+		maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
+		maxIn = Math.max(maxIn, fasGraph.node(e.w)["in"] += weight);
+	});
+	var buckets = range(maxOut + maxIn + 3).map(function() {
+		return new List();
+	});
+	var zeroIdx = maxIn + 1;
+	forEach(fasGraph.nodes(), function(v) {
+		assignBucket(buckets, zeroIdx, fasGraph.node(v));
+	});
+	return {
+		graph: fasGraph,
+		buckets,
+		zeroIdx
+	};
+}
+function assignBucket(buckets, zeroIdx, entry) {
+	if (!entry.out) buckets[0].enqueue(entry);
+	else if (!entry["in"]) buckets[buckets.length - 1].enqueue(entry);
+	else buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/acyclic.js
+function run$2(g) {
+	var fas = g.graph().acyclicer === "greedy" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+	forEach(fas, function(e) {
+		var label = g.edge(e);
+		g.removeEdge(e);
+		label.forwardName = e.name;
+		label.reversed = true;
+		g.setEdge(e.w, e.v, label, uniqueId("rev"));
+	});
+	function weightFn(g) {
+		return function(e) {
+			return g.edge(e).weight;
+		};
+	}
+}
+function dfsFAS(g) {
+	var fas = [];
+	var stack = {};
+	var visited = {};
+	function dfs(v) {
+		if (Object.prototype.hasOwnProperty.call(visited, v)) return;
+		visited[v] = true;
+		stack[v] = true;
+		forEach(g.outEdges(v), function(e) {
+			if (Object.prototype.hasOwnProperty.call(stack, e.w)) fas.push(e);
+			else dfs(e.w);
+		});
+		delete stack[v];
+	}
+	forEach(g.nodes(), dfs);
+	return fas;
+}
+function undo$2(g) {
+	forEach(g.edges(), function(e) {
+		var label = g.edge(e);
+		if (label.reversed) {
+			g.removeEdge(e);
+			var forwardName = label.forwardName;
+			delete label.reversed;
+			delete label.forwardName;
+			g.setEdge(e.w, e.v, label, forwardName);
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/util.js
+function addDummyNode(g, type, attrs, name) {
+	var v;
+	do
+		v = uniqueId(name);
+	while (g.hasNode(v));
+	attrs.dummy = type;
+	g.setNode(v, attrs);
+	return v;
+}
+function simplify(g) {
+	var simplified = new Graph().setGraph(g.graph());
+	forEach(g.nodes(), function(v) {
+		simplified.setNode(v, g.node(v));
+	});
+	forEach(g.edges(), function(e) {
+		var simpleLabel = simplified.edge(e.v, e.w) || {
+			weight: 0,
+			minlen: 1
+		};
+		var label = g.edge(e);
+		simplified.setEdge(e.v, e.w, {
+			weight: simpleLabel.weight + label.weight,
+			minlen: Math.max(simpleLabel.minlen, label.minlen)
+		});
+	});
+	return simplified;
+}
+function asNonCompoundGraph(g) {
+	var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+	forEach(g.nodes(), function(v) {
+		if (!g.children(v).length) simplified.setNode(v, g.node(v));
+	});
+	forEach(g.edges(), function(e) {
+		simplified.setEdge(e, g.edge(e));
+	});
+	return simplified;
+}
+function intersectRect(rect, point) {
+	var x = rect.x;
+	var y = rect.y;
+	var dx = point.x - x;
+	var dy = point.y - y;
+	var w = rect.width / 2;
+	var h = rect.height / 2;
+	if (!dx && !dy) throw new Error("Not possible to find intersection inside of the rectangle");
+	var sx, sy;
+	if (Math.abs(dy) * w > Math.abs(dx) * h) {
+		if (dy < 0) h = -h;
+		sx = h * dx / dy;
+		sy = h;
+	} else {
+		if (dx < 0) w = -w;
+		sx = w;
+		sy = w * dy / dx;
+	}
+	return {
+		x: x + sx,
+		y: y + sy
+	};
+}
+function buildLayerMatrix(g) {
+	var layering = map(range(maxRank(g) + 1), function() {
+		return [];
+	});
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v);
+		var rank = node.rank;
+		if (!isUndefined(rank)) layering[rank][node.order] = v;
+	});
+	return layering;
+}
+function normalizeRanks(g) {
+	var min$1 = min(map(g.nodes(), function(v) {
+		return g.node(v).rank;
+	}));
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v);
+		if (has(node, "rank")) node.rank -= min$1;
+	});
+}
+function removeEmptyRanks(g) {
+	var offset = min(map(g.nodes(), function(v) {
+		return g.node(v).rank;
+	}));
+	var layers = [];
+	forEach(g.nodes(), function(v) {
+		var rank = g.node(v).rank - offset;
+		if (!layers[rank]) layers[rank] = [];
+		layers[rank].push(v);
+	});
+	var delta = 0;
+	var nodeRankFactor = g.graph().nodeRankFactor;
+	forEach(layers, function(vs, i) {
+		if (isUndefined(vs) && i % nodeRankFactor !== 0) --delta;
+		else if (delta) forEach(vs, function(v) {
+			g.node(v).rank += delta;
+		});
+	});
+}
+function addBorderNode$1(g, prefix, rank, order) {
+	var node = {
+		width: 0,
+		height: 0
+	};
+	if (arguments.length >= 4) {
+		node.rank = rank;
+		node.order = order;
+	}
+	return addDummyNode(g, "border", node, prefix);
+}
+function maxRank(g) {
+	return max(map(g.nodes(), function(v) {
+		var rank = g.node(v).rank;
+		if (!isUndefined(rank)) return rank;
+	}));
+}
+function partition(collection, fn) {
+	var result = {
+		lhs: [],
+		rhs: []
+	};
+	forEach(collection, function(value) {
+		if (fn(value)) result.lhs.push(value);
+		else result.rhs.push(value);
+	});
+	return result;
+}
+function time(name, fn) {
+	var start = now();
+	try {
+		return fn();
+	} finally {
+		console.log(name + " time: " + (now() - start) + "ms");
+	}
+}
+function notime(name, fn) {
+	return fn();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/add-border-segments.js
+function addBorderSegments(g) {
+	function dfs(v) {
+		var children = g.children(v);
+		var node = g.node(v);
+		if (children.length) forEach(children, dfs);
+		if (Object.prototype.hasOwnProperty.call(node, "minRank")) {
+			node.borderLeft = [];
+			node.borderRight = [];
+			for (var rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
+				addBorderNode(g, "borderLeft", "_bl", v, node, rank);
+				addBorderNode(g, "borderRight", "_br", v, node, rank);
+			}
+		}
+	}
+	forEach(g.children(), dfs);
+}
+function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
+	var label = {
+		width: 0,
+		height: 0,
+		rank,
+		borderType: prop
+	};
+	var prev = sgNode[prop][rank - 1];
+	var curr = addDummyNode(g, "border", label, prefix);
+	sgNode[prop][rank] = curr;
+	g.setParent(curr, sg);
+	if (prev) g.setEdge(prev, curr, { weight: 1 });
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/coordinate-system.js
+function adjust(g) {
+	var rankDir = g.graph().rankdir.toLowerCase();
+	if (rankDir === "lr" || rankDir === "rl") swapWidthHeight(g);
+}
+function undo$1(g) {
+	var rankDir = g.graph().rankdir.toLowerCase();
+	if (rankDir === "bt" || rankDir === "rl") reverseY(g);
+	if (rankDir === "lr" || rankDir === "rl") {
+		swapXY(g);
+		swapWidthHeight(g);
+	}
+}
+function swapWidthHeight(g) {
+	forEach(g.nodes(), function(v) {
+		swapWidthHeightOne(g.node(v));
+	});
+	forEach(g.edges(), function(e) {
+		swapWidthHeightOne(g.edge(e));
+	});
+}
+function swapWidthHeightOne(attrs) {
+	var w = attrs.width;
+	attrs.width = attrs.height;
+	attrs.height = w;
+}
+function reverseY(g) {
+	forEach(g.nodes(), function(v) {
+		reverseYOne(g.node(v));
+	});
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		forEach(edge.points, reverseYOne);
+		if (Object.prototype.hasOwnProperty.call(edge, "y")) reverseYOne(edge);
+	});
+}
+function reverseYOne(attrs) {
+	attrs.y = -attrs.y;
+}
+function swapXY(g) {
+	forEach(g.nodes(), function(v) {
+		swapXYOne(g.node(v));
+	});
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		forEach(edge.points, swapXYOne);
+		if (Object.prototype.hasOwnProperty.call(edge, "x")) swapXYOne(edge);
+	});
+}
+function swapXYOne(attrs) {
+	var x = attrs.x;
+	attrs.x = attrs.y;
+	attrs.y = x;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/normalize.js
+/**
+* TypeScript type imports:
+*
+* @import { Graph } from '../graphlib/graph.js';
+*/
+function run$1(g) {
+	g.graph().dummyChains = [];
+	forEach(g.edges(), function(edge) {
+		normalizeEdge(g, edge);
+	});
+}
+/**
+* @param {Graph} g
+*/
+function normalizeEdge(g, e) {
+	var v = e.v;
+	var vRank = g.node(v).rank;
+	var w = e.w;
+	var wRank = g.node(w).rank;
+	var name = e.name;
+	var edgeLabel = g.edge(e);
+	var labelRank = edgeLabel.labelRank;
+	if (wRank === vRank + 1) return;
+	g.removeEdge(e);
+	/**
+	* @typedef {Object} Attrs
+	* @property {number} width
+	* @property {number} height
+	* @property {ReturnType<Graph["node"]>} edgeLabel
+	* @property {any} edgeObj
+	* @property {ReturnType<Graph["node"]>["rank"]} rank
+	* @property {string} [dummy]
+	* @property {ReturnType<Graph["node"]>["labelpos"]} [labelpos]
+	*/
+	/** @type {Attrs | undefined} */
+	var attrs = void 0;
+	var dummy, i;
+	for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+		edgeLabel.points = [];
+		attrs = {
+			width: 0,
+			height: 0,
+			edgeLabel,
+			edgeObj: e,
+			rank: vRank
+		};
+		dummy = addDummyNode(g, "edge", attrs, "_d");
+		if (vRank === labelRank) {
+			attrs.width = edgeLabel.width;
+			attrs.height = edgeLabel.height;
+			attrs.dummy = "edge-label";
+			attrs.labelpos = edgeLabel.labelpos;
+		}
+		g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
+		if (i === 0) g.graph().dummyChains.push(dummy);
+		v = dummy;
+	}
+	g.setEdge(v, w, { weight: edgeLabel.weight }, name);
+}
+function undo(g) {
+	forEach(g.graph().dummyChains, function(v) {
+		var node = g.node(v);
+		var origLabel = node.edgeLabel;
+		var w;
+		g.setEdge(node.edgeObj, origLabel);
+		while (node.dummy) {
+			w = g.successors(v)[0];
+			g.removeNode(v);
+			origLabel.points.push({
+				x: node.x,
+				y: node.y
+			});
+			if (node.dummy === "edge-label") {
+				origLabel.x = node.x;
+				origLabel.y = node.y;
+				origLabel.width = node.width;
+				origLabel.height = node.height;
+			}
+			v = w;
+			node = g.node(v);
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/rank/util.js
+function longestPath(g) {
+	var visited = {};
+	function dfs(v) {
+		var label = g.node(v);
+		if (Object.prototype.hasOwnProperty.call(visited, v)) return label.rank;
+		visited[v] = true;
+		var rank = min(map(g.outEdges(v), function(e) {
+			return dfs(e.w) - g.edge(e).minlen;
+		}));
+		if (rank === Number.POSITIVE_INFINITY || rank === void 0 || rank === null) rank = 0;
+		return label.rank = rank;
+	}
+	forEach(g.sources(), dfs);
+}
+function slack(g, e) {
+	return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js
+function feasibleTree(g) {
+	var t = new Graph({ directed: false });
+	var start = g.nodes()[0];
+	var size = g.nodeCount();
+	t.setNode(start, {});
+	var edge, delta;
+	while (tightTree(t, g) < size) {
+		edge = findMinSlackEdge(t, g);
+		delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+		shiftRanks(t, g, delta);
+	}
+	return t;
+}
+function tightTree(t, g) {
+	function dfs(v) {
+		forEach(g.nodeEdges(v), function(e) {
+			var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
+			if (!t.hasNode(w) && !slack(g, e)) {
+				t.setNode(w, {});
+				t.setEdge(v, w, {});
+				dfs(w);
+			}
+		});
+	}
+	forEach(t.nodes(), dfs);
+	return t.nodeCount();
+}
+function findMinSlackEdge(t, g) {
+	return minBy(g.edges(), function(e) {
+		if (t.hasNode(e.v) !== t.hasNode(e.w)) return slack(g, e);
+	});
+}
+function shiftRanks(t, g, delta) {
+	forEach(t.nodes(), function(v) {
+		g.node(v).rank += delta;
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra.js
+var DEFAULT_WEIGHT_FUNC$1 = constant(1);
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/alg/floyd-warshall.js
+var DEFAULT_WEIGHT_FUNC = constant(1);
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/alg/topsort.js
+topsort.CycleException = CycleException;
+/**
+* An implementation of [topological sorting](https://en.wikipedia.org/wiki/Topological_sorting).
+*
+* @remarks Takes `O(|V| + |E|)` time.
+*
+* @example
+*
+* ![](https://github.com/dagrejs/graphlib/wiki/images/topsort.png)
+*
+* ```js
+* graphlib.alg.topsort(g)
+* // [ '1', '2', '3', '4' ] or [ '1', '3', '2', '4' ]
+* ```
+*
+* @param {Graph} g - The graph to sort.
+* @returns {NodeID[]} an array of nodes
+* such that for each edge `u -> v`, `u` appears before `v` in the array.
+* @throws {CycleException} If the graph has a cycle so that it is impossible
+* to generate a topological sort.
+*/
+function topsort(g) {
+	/** @type {Record<NodeID, true>} */
+	var visited = {};
+	/** @type {Record<NodeID, true>} */
+	var stack = {};
+	/** @type {NodeID[]} */
+	var results = [];
+	/**
+	* @param {NodeID} node - Node to recursively visit.
+	*/
+	function visit(node) {
+		if (Object.prototype.hasOwnProperty.call(stack, node)) throw new CycleException();
+		if (!Object.prototype.hasOwnProperty.call(visited, node)) {
+			stack[node] = true;
+			visited[node] = true;
+			forEach(g.predecessors(node), visit);
+			delete stack[node];
+			results.push(node);
+		}
+	}
+	forEach(g.sinks(), visit);
+	if (size(visited) !== g.nodeCount()) throw new CycleException();
+	return results;
+}
+/**
+* @class
+*/
+function CycleException() {}
+CycleException.prototype = /* @__PURE__ */ new Error();
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/alg/dfs.js
+/**
+* A helper that preforms a pre- or post-order traversal on the input graph
+* and returns the nodes in the order they were visited. If the graph is
+* undirected then this algorithm will navigate using neighbors. If the graph
+* is directed then this algorithm will navigate using successors.
+*
+* @param {Graph} g - Input graph.
+* @param {NodeID[] | NodeID} vs - Starting node or array of nodes.
+* @param {'post' | 'pre'} order - The order to use. Must be one of "pre" or "post".
+* @returns {NodeID[]} The nodes in the order they were visited.
+*/
+function dfs$1(g, vs, order) {
+	if (!isArray(vs)) vs = [vs];
+	/** @type {Parameters<typeof doDfs>[4]} */
+	var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
+	/** @type {Parameters<typeof doDfs>[5]} */
+	var acc = [];
+	/** @type {Parameters<typeof doDfs>[3]} */
+	var visited = {};
+	forEach(vs, function(v) {
+		if (!g.hasNode(v)) throw new Error("Graph does not have node: " + v);
+		doDfs(g, v, order === "post", visited, navigation, acc);
+	});
+	return acc;
+}
+/**
+* @param {Graph} g - Input graph.
+* @param {NodeID} v - The node to visit.
+* @param {boolean} postorder - Whether to do postorder traversal.
+* @param {Record<NodeID, true>} visited - Visited nodes.
+* @param {(node: NodeID) => (NodeID[] | undefined)} navigation - Function to get
+* neighbors/successors.
+* @param {NodeID[]} acc - Accumulator for visited nodes.
+*/
+function doDfs(g, v, postorder, visited, navigation, acc) {
+	if (!Object.prototype.hasOwnProperty.call(visited, v)) {
+		visited[v] = true;
+		if (!postorder) acc.push(v);
+		forEach(navigation(v), function(w) {
+			doDfs(g, w, postorder, visited, navigation, acc);
+		});
+		if (postorder) acc.push(v);
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/alg/postorder.js
+/**
+* This function performs a [postorder traversal][] of the graph `g` starting
+* at the nodes `vs`. For each node visited, `v`,  the function `callback(v)`
+* is called.
+*
+* [postorder traversal]: https://en.wikipedia.org/wiki/Tree_traversal#Depth-first
+*
+* @example
+*
+* ![](https://github.com/dagrejs/graphlib/wiki/images/preorder.png)
+*
+* ```js
+* graphlib.alg.postorder(g, "A");
+* // => One of:
+* // [ "B", "D", "E", C", "A" ]
+* // [ "B", "E", "D", C", "A" ]
+* // [ "D", "E", "C", B", "A" ]
+* // [ "E", "D", "C", B", "A" ]
+* ```
+*
+* @param {Parameters<typeof dfs>[0]} g - The graph to traverse.
+* @param {Parameters<typeof dfs>[1]} vs - Nodes to start the traversal from.
+* @returns {ReturnType<typeof dfs>} The nodes in the order they were visited.
+*/
+function postorder$1(g, vs) {
+	return dfs$1(g, vs, "post");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/graphlib/alg/preorder.js
+/**
+* This function performs a [preorder traversal][] of the graph `g` starting
+* at the nodes `vs`. For each node visited, `v`,  the function `callback(v)`
+* is called.
+*
+* [preorder traversal]: https://en.wikipedia.org/wiki/Tree_traversal#Depth-first
+*
+* @example
+*
+* ![](https://github.com/dagrejs/graphlib/wiki/images/preorder.png)
+* <!-- SOURCE:
+* http://dagrejs.github.io/project/dagre-d3/latest/demo/interactive-demo.html?graph=digraph%20%7B%0Anode%20%5Bshape%3Dcircle%2C%20style%3D%22fill%3Awhite%3Bstroke%3A%23333%3Bstroke-width%3A1.5px%22%5D%0Aedge%20%5Blabeloffset%3D2%20labelpos%3Dr%5D%0Arankdir%3Dlr%0A%20%20A%20-%3E%20B%0A%20%20A%20-%3E%20C%0A%20%20C%20-%3E%20D%0A%20%20C%20-%3E%20E%0A%7D
+* -->
+*
+* ```js
+* graphlib.alg.preorder(g, "A");
+* // => One of:
+* // [ "A", "B", "C", "D", "E" ]
+* // [ "A", "B", "C", "E", "D" ]
+* // [ "A", "C", "D", "E", "B" ]
+* // [ "A", "C", "E", "D", "B" ]
+* ```
+*
+* @param {Parameters<typeof dfs>[0]} g - The graph to traverse.
+* @param {Parameters<typeof dfs>[1]} vs - Nodes to start the traversal from.
+* @returns {ReturnType<typeof dfs>} The nodes in the order they were visited.
+*/
+function preorder(g, vs) {
+	return dfs$1(g, vs, "pre");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js
+networkSimplex.initLowLimValues = initLowLimValues;
+networkSimplex.initCutValues = initCutValues;
+networkSimplex.calcCutValue = calcCutValue;
+networkSimplex.leaveEdge = leaveEdge;
+networkSimplex.enterEdge = enterEdge;
+networkSimplex.exchangeEdges = exchangeEdges;
+function networkSimplex(g) {
+	g = simplify(g);
+	longestPath(g);
+	var t = feasibleTree(g);
+	initLowLimValues(t);
+	initCutValues(t, g);
+	var e, f;
+	while (e = leaveEdge(t)) {
+		f = enterEdge(t, g, e);
+		exchangeEdges(t, g, e, f);
+	}
+}
+function initCutValues(t, g) {
+	var vs = postorder$1(t, t.nodes());
+	vs = vs.slice(0, vs.length - 1);
+	forEach(vs, function(v) {
+		assignCutValue(t, g, v);
+	});
+}
+function assignCutValue(t, g, child) {
+	var parent = t.node(child).parent;
+	t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+}
+function calcCutValue(t, g, child) {
+	var parent = t.node(child).parent;
+	var childIsTail = true;
+	var graphEdge = g.edge(child, parent);
+	var cutValue = 0;
+	if (!graphEdge) {
+		childIsTail = false;
+		graphEdge = g.edge(parent, child);
+	}
+	cutValue = graphEdge.weight;
+	forEach(g.nodeEdges(child), function(e) {
+		var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
+		if (other !== parent) {
+			var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
+			cutValue += pointsToHead ? otherWeight : -otherWeight;
+			if (isTreeEdge(t, child, other)) {
+				var otherCutValue = t.edge(child, other).cutvalue;
+				cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+			}
+		}
+	});
+	return cutValue;
+}
+function initLowLimValues(tree, root) {
+	if (arguments.length < 2) root = tree.nodes()[0];
+	dfsAssignLowLim(tree, {}, 1, root);
+}
+function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+	var low = nextLim;
+	var label = tree.node(v);
+	visited[v] = true;
+	forEach(tree.neighbors(v), function(w) {
+		if (!Object.prototype.hasOwnProperty.call(visited, w)) nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+	});
+	label.low = low;
+	label.lim = nextLim++;
+	if (parent) label.parent = parent;
+	else delete label.parent;
+	return nextLim;
+}
+function leaveEdge(tree) {
+	return find(tree.edges(), function(e) {
+		return tree.edge(e).cutvalue < 0;
+	});
+}
+function enterEdge(t, g, edge) {
+	var v = edge.v;
+	var w = edge.w;
+	if (!g.hasEdge(v, w)) {
+		v = edge.w;
+		w = edge.v;
+	}
+	var vLabel = t.node(v);
+	var wLabel = t.node(w);
+	var tailLabel = vLabel;
+	var flip = false;
+	if (vLabel.lim > wLabel.lim) {
+		tailLabel = wLabel;
+		flip = true;
+	}
+	var candidates = filter(g.edges(), function(edge) {
+		return flip === isDescendant(t, t.node(edge.v), tailLabel) && flip !== isDescendant(t, t.node(edge.w), tailLabel);
+	});
+	return minBy(candidates, function(edge) {
+		return slack(g, edge);
+	});
+}
+function exchangeEdges(t, g, e, f) {
+	var v = e.v;
+	var w = e.w;
+	t.removeEdge(v, w);
+	t.setEdge(f.v, f.w, {});
+	initLowLimValues(t);
+	initCutValues(t, g);
+	updateRanks(t, g);
+}
+function updateRanks(t, g) {
+	var root = find(t.nodes(), function(v) {
+		return !g.node(v).parent;
+	});
+	var vs = preorder(t, root);
+	vs = vs.slice(1);
+	forEach(vs, function(v) {
+		var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
+		if (!edge) {
+			edge = g.edge(parent, v);
+			flipped = true;
+		}
+		g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+	});
+}
+function isTreeEdge(tree, u, v) {
+	return tree.hasEdge(u, v);
+}
+function isDescendant(tree, vLabel, rootLabel) {
+	return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/rank/index.js
+function rank(g) {
+	switch (g.graph().ranker) {
+		case "network-simplex":
+			networkSimplexRanker(g);
+			break;
+		case "tight-tree":
+			tightTreeRanker(g);
+			break;
+		case "longest-path":
+			longestPathRanker(g);
+			break;
+		default: networkSimplexRanker(g);
+	}
+}
+var longestPathRanker = longestPath;
+function tightTreeRanker(g) {
+	longestPath(g);
+	feasibleTree(g);
+}
+function networkSimplexRanker(g) {
+	networkSimplex(g);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/nesting-graph.js
+function run(g) {
+	var root = addDummyNode(g, "root", {}, "_root");
+	var depths = treeDepths(g);
+	var height = max(values(depths)) - 1;
+	var nodeSep = 2 * height + 1;
+	g.graph().nestingRoot = root;
+	forEach(g.edges(), function(e) {
+		g.edge(e).minlen *= nodeSep;
+	});
+	var weight = sumWeights(g) + 1;
+	forEach(g.children(), function(child) {
+		dfs(g, root, nodeSep, weight, height, depths, child);
+	});
+	g.graph().nodeRankFactor = nodeSep;
+}
+function dfs(g, root, nodeSep, weight, height, depths, v) {
+	var children = g.children(v);
+	if (!children.length) {
+		if (v !== root) g.setEdge(root, v, {
+			weight: 0,
+			minlen: nodeSep
+		});
+		return;
+	}
+	var top = addBorderNode$1(g, "_bt");
+	var bottom = addBorderNode$1(g, "_bb");
+	var label = g.node(v);
+	g.setParent(top, v);
+	label.borderTop = top;
+	g.setParent(bottom, v);
+	label.borderBottom = bottom;
+	forEach(children, function(child) {
+		dfs(g, root, nodeSep, weight, height, depths, child);
+		var childNode = g.node(child);
+		var childTop = childNode.borderTop ? childNode.borderTop : child;
+		var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+		var thisWeight = childNode.borderTop ? weight : 2 * weight;
+		var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+		g.setEdge(top, childTop, {
+			weight: thisWeight,
+			minlen,
+			nestingEdge: true
+		});
+		g.setEdge(childBottom, bottom, {
+			weight: thisWeight,
+			minlen,
+			nestingEdge: true
+		});
+	});
+	if (!g.parent(v)) g.setEdge(root, top, {
+		weight: 0,
+		minlen: height + depths[v]
+	});
+}
+function treeDepths(g) {
+	var depths = {};
+	function dfs(v, depth) {
+		var children = g.children(v);
+		if (children && children.length) forEach(children, function(child) {
+			dfs(child, depth + 1);
+		});
+		depths[v] = depth;
+	}
+	forEach(g.children(), function(v) {
+		dfs(v, 1);
+	});
+	return depths;
+}
+function sumWeights(g) {
+	return reduce(g.edges(), function(acc, e) {
+		return acc + g.edge(e).weight;
+	}, 0);
+}
+function cleanup(g) {
+	var graphLabel = g.graph();
+	g.removeNode(graphLabel.nestingRoot);
+	delete graphLabel.nestingRoot;
+	forEach(g.edges(), function(e) {
+		if (g.edge(e).nestingEdge) g.removeEdge(e);
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/add-subgraph-constraints.js
+function addSubgraphConstraints(g, cg, vs) {
+	var prev = {}, rootPrev;
+	forEach(vs, function(v) {
+		var child = g.parent(v), parent, prevChild;
+		while (child) {
+			parent = g.parent(child);
+			if (parent) {
+				prevChild = prev[parent];
+				prev[parent] = child;
+			} else {
+				prevChild = rootPrev;
+				rootPrev = child;
+			}
+			if (prevChild && prevChild !== child) {
+				cg.setEdge(prevChild, child);
+				return;
+			}
+			child = parent;
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js
+function buildLayerGraph(g, rank, relationship) {
+	var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel(function(v) {
+		return g.node(v);
+	});
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v), parent = g.parent(v);
+		if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
+			result.setNode(v);
+			result.setParent(v, parent || root);
+			forEach(g[relationship](v), function(e) {
+				var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !isUndefined(edge) ? edge.weight : 0;
+				result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+			});
+			if (Object.prototype.hasOwnProperty.call(node, "minRank")) result.setNode(v, {
+				borderLeft: node.borderLeft[rank],
+				borderRight: node.borderRight[rank]
+			});
+		}
+	});
+	return result;
+}
+function createRootNode(g) {
+	var v;
+	while (g.hasNode(v = uniqueId("_root")));
+	return v;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/cross-count.js
+function crossCount(g, layering) {
+	var cc = 0;
+	for (var i = 1; i < layering.length; ++i) cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+	return cc;
+}
+function twoLayerCrossCount(g, northLayer, southLayer) {
+	var southPos = zipObject(southLayer, map(southLayer, function(v, i) {
+		return i;
+	}));
+	var southEntries = flatten(map(northLayer, function(v) {
+		return sortBy(map(g.outEdges(v), function(e) {
+			return {
+				pos: southPos[e.w],
+				weight: g.edge(e).weight
+			};
+		}), "pos");
+	}));
+	var firstIndex = 1;
+	while (firstIndex < southLayer.length) firstIndex <<= 1;
+	var treeSize = 2 * firstIndex - 1;
+	firstIndex -= 1;
+	var tree = map(new Array(treeSize), function() {
+		return 0;
+	});
+	var cc = 0;
+	forEach(southEntries.forEach(function(entry) {
+		var index = entry.pos + firstIndex;
+		tree[index] += entry.weight;
+		var weightSum = 0;
+		while (index > 0) {
+			if (index % 2) weightSum += tree[index + 1];
+			index = index - 1 >> 1;
+			tree[index] += entry.weight;
+		}
+		cc += entry.weight * weightSum;
+	}));
+	return cc;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/init-order.js
+function initOrder(g) {
+	var visited = {};
+	var simpleNodes = filter(g.nodes(), function(v) {
+		return !g.children(v).length;
+	});
+	var maxRank = max(map(simpleNodes, function(v) {
+		return g.node(v).rank;
+	}));
+	var layers = map(range(maxRank + 1), function() {
+		return [];
+	});
+	function dfs(v) {
+		if (has(visited, v)) return;
+		visited[v] = true;
+		layers[g.node(v).rank].push(v);
+		forEach(g.successors(v), dfs);
+	}
+	var orderedVs = sortBy(simpleNodes, function(v) {
+		return g.node(v).rank;
+	});
+	forEach(orderedVs, dfs);
+	return layers;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/barycenter.js
+function barycenter(g, movable) {
+	return map(movable, function(v) {
+		var inV = g.inEdges(v);
+		if (!inV.length) return { v };
+		else {
+			var result = reduce(inV, function(acc, e) {
+				var edge = g.edge(e), nodeU = g.node(e.v);
+				return {
+					sum: acc.sum + edge.weight * nodeU.order,
+					weight: acc.weight + edge.weight
+				};
+			}, {
+				sum: 0,
+				weight: 0
+			});
+			return {
+				v,
+				barycenter: result.sum / result.weight,
+				weight: result.weight
+			};
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.js
+function resolveConflicts(entries, cg) {
+	var mappedEntries = {};
+	forEach(entries, function(entry, i) {
+		var tmp = mappedEntries[entry.v] = {
+			indegree: 0,
+			in: [],
+			out: [],
+			vs: [entry.v],
+			i
+		};
+		if (!isUndefined(entry.barycenter)) {
+			tmp.barycenter = entry.barycenter;
+			tmp.weight = entry.weight;
+		}
+	});
+	forEach(cg.edges(), function(e) {
+		var entryV = mappedEntries[e.v];
+		var entryW = mappedEntries[e.w];
+		if (!isUndefined(entryV) && !isUndefined(entryW)) {
+			entryW.indegree++;
+			entryV.out.push(mappedEntries[e.w]);
+		}
+	});
+	return doResolveConflicts(filter(mappedEntries, function(entry) {
+		return !entry.indegree;
+	}));
+}
+function doResolveConflicts(sourceSet) {
+	var entries = [];
+	function handleIn(vEntry) {
+		return function(uEntry) {
+			if (uEntry.merged) return;
+			if (isUndefined(uEntry.barycenter) || isUndefined(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) mergeEntries(vEntry, uEntry);
+		};
+	}
+	function handleOut(vEntry) {
+		return function(wEntry) {
+			wEntry["in"].push(vEntry);
+			if (--wEntry.indegree === 0) sourceSet.push(wEntry);
+		};
+	}
+	while (sourceSet.length) {
+		var entry = sourceSet.pop();
+		entries.push(entry);
+		forEach(entry["in"].reverse(), handleIn(entry));
+		forEach(entry.out, handleOut(entry));
+	}
+	return map(filter(entries, function(entry) {
+		return !entry.merged;
+	}), function(entry) {
+		return pick(entry, [
+			"vs",
+			"i",
+			"barycenter",
+			"weight"
+		]);
+	});
+}
+function mergeEntries(target, source) {
+	var sum = 0;
+	var weight = 0;
+	if (target.weight) {
+		sum += target.barycenter * target.weight;
+		weight += target.weight;
+	}
+	if (source.weight) {
+		sum += source.barycenter * source.weight;
+		weight += source.weight;
+	}
+	target.vs = source.vs.concat(target.vs);
+	target.barycenter = sum / weight;
+	target.weight = weight;
+	target.i = Math.min(source.i, target.i);
+	source.merged = true;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/sort.js
+function sort(entries, biasRight) {
+	var parts = partition(entries, function(entry) {
+		return Object.prototype.hasOwnProperty.call(entry, "barycenter");
+	});
+	var sortable = parts.lhs, unsortable = sortBy(parts.rhs, function(entry) {
+		return -entry.i;
+	}), vs = [], sum = 0, weight = 0, vsIndex = 0;
+	sortable.sort(compareWithBias(!!biasRight));
+	vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+	forEach(sortable, function(entry) {
+		vsIndex += entry.vs.length;
+		vs.push(entry.vs);
+		sum += entry.barycenter * entry.weight;
+		weight += entry.weight;
+		vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+	});
+	var result = { vs: flatten(vs) };
+	if (weight) {
+		result.barycenter = sum / weight;
+		result.weight = weight;
+	}
+	return result;
+}
+function consumeUnsortable(vs, unsortable, index) {
+	var last$1;
+	while (unsortable.length && (last$1 = last(unsortable)).i <= index) {
+		unsortable.pop();
+		vs.push(last$1.vs);
+		index++;
+	}
+	return index;
+}
+function compareWithBias(bias) {
+	return function(entryV, entryW) {
+		if (entryV.barycenter < entryW.barycenter) return -1;
+		else if (entryV.barycenter > entryW.barycenter) return 1;
+		return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js
+function sortSubgraph(g, v, cg, biasRight) {
+	var movable = g.children(v);
+	var node = g.node(v);
+	var bl = node ? node.borderLeft : void 0;
+	var br = node ? node.borderRight : void 0;
+	var subgraphs = {};
+	if (bl) movable = filter(movable, function(w) {
+		return w !== bl && w !== br;
+	});
+	var barycenters = barycenter(g, movable);
+	forEach(barycenters, function(entry) {
+		if (g.children(entry.v).length) {
+			var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+			subgraphs[entry.v] = subgraphResult;
+			if (Object.prototype.hasOwnProperty.call(subgraphResult, "barycenter")) mergeBarycenters(entry, subgraphResult);
+		}
+	});
+	var entries = resolveConflicts(barycenters, cg);
+	expandSubgraphs(entries, subgraphs);
+	var result = sort(entries, biasRight);
+	if (bl) {
+		result.vs = flatten([
+			bl,
+			result.vs,
+			br
+		]);
+		if (g.predecessors(bl).length) {
+			var blPred = g.node(g.predecessors(bl)[0]), brPred = g.node(g.predecessors(br)[0]);
+			if (!Object.prototype.hasOwnProperty.call(result, "barycenter")) {
+				result.barycenter = 0;
+				result.weight = 0;
+			}
+			result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+			result.weight += 2;
+		}
+	}
+	return result;
+}
+function expandSubgraphs(entries, subgraphs) {
+	forEach(entries, function(entry) {
+		entry.vs = flatten(entry.vs.map(function(v) {
+			if (subgraphs[v]) return subgraphs[v].vs;
+			return v;
+		}));
+	});
+}
+function mergeBarycenters(target, other) {
+	if (!isUndefined(target.barycenter)) {
+		target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
+		target.weight += other.weight;
+	} else {
+		target.barycenter = other.barycenter;
+		target.weight = other.weight;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/order/index.js
+function order(g) {
+	var maxRank$1 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, range(1, maxRank$1 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g, range(maxRank$1 - 1, -1, -1), "outEdges");
+	var layering = initOrder(g);
+	assignOrder(g, layering);
+	var bestCC = Number.POSITIVE_INFINITY, best;
+	for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+		sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+		layering = buildLayerMatrix(g);
+		var cc = crossCount(g, layering);
+		if (cc < bestCC) {
+			lastBest = 0;
+			best = cloneDeep(layering);
+			bestCC = cc;
+		}
+	}
+	assignOrder(g, best);
+}
+function buildLayerGraphs(g, ranks, relationship) {
+	return map(ranks, function(rank) {
+		return buildLayerGraph(g, rank, relationship);
+	});
+}
+function sweepLayerGraphs(layerGraphs, biasRight) {
+	var cg = new Graph();
+	forEach(layerGraphs, function(lg) {
+		var root = lg.graph().root;
+		var sorted = sortSubgraph(lg, root, cg, biasRight);
+		forEach(sorted.vs, function(v, i) {
+			lg.node(v).order = i;
+		});
+		addSubgraphConstraints(lg, cg, sorted.vs);
+	});
+}
+function assignOrder(g, layering) {
+	forEach(layering, function(layer) {
+		forEach(layer, function(v, i) {
+			g.node(v).order = i;
+		});
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js
+function parentDummyChains(g) {
+	var postorderNums = postorder(g);
+	forEach(g.graph().dummyChains, function(v) {
+		var node = g.node(v);
+		var edgeObj = node.edgeObj;
+		var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+		var path = pathData.path;
+		var lca = pathData.lca;
+		var pathIdx = 0;
+		var pathV = path[pathIdx];
+		var ascending = true;
+		while (v !== edgeObj.w) {
+			node = g.node(v);
+			if (ascending) {
+				while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) pathIdx++;
+				if (pathV === lca) ascending = false;
+			}
+			if (!ascending) {
+				while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) pathIdx++;
+				pathV = path[pathIdx];
+			}
+			g.setParent(v, pathV);
+			v = g.successors(v)[0];
+		}
+	});
+}
+function findPath(g, postorderNums, v, w) {
+	var vPath = [];
+	var wPath = [];
+	var low = Math.min(postorderNums[v].low, postorderNums[w].low);
+	var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+	var parent;
+	var lca;
+	parent = v;
+	do {
+		parent = g.parent(parent);
+		vPath.push(parent);
+	} while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+	lca = parent;
+	parent = w;
+	while ((parent = g.parent(parent)) !== lca) wPath.push(parent);
+	return {
+		path: vPath.concat(wPath.reverse()),
+		lca
+	};
+}
+function postorder(g) {
+	var result = {};
+	var lim = 0;
+	function dfs(v) {
+		var low = lim;
+		forEach(g.children(v), dfs);
+		result[v] = {
+			low,
+			lim: lim++
+		};
+	}
+	forEach(g.children(), dfs);
+	return result;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/position/bk.js
+function findType1Conflicts(g, layering) {
+	/** @type {{[nodeId: string | number]: {[nodeId: string | number]: true}}} */
+	var conflicts = {};
+	function visitLayer(prevLayer, layer) {
+		var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = last(layer);
+		forEach(layer, function(v, i) {
+			var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
+			if (w || v === lastNode) {
+				forEach(layer.slice(scanPos, i + 1), function(scanNode) {
+					forEach(g.predecessors(scanNode), function(u) {
+						var uLabel = g.node(u), uPos = uLabel.order;
+						if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) addConflict(conflicts, u, scanNode);
+					});
+				});
+				scanPos = i + 1;
+				k0 = k1;
+			}
+		});
+		return layer;
+	}
+	reduce(layering, visitLayer);
+	return conflicts;
+}
+function findType2Conflicts(g, layering) {
+	/** @type {{[nodeId: string | number]: {[nodeId: string | number]: true}}} */
+	var conflicts = {};
+	function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+		var v;
+		forEach(range(southPos, southEnd), function(i) {
+			v = south[i];
+			if (g.node(v).dummy) forEach(g.predecessors(v), function(u) {
+				var uNode = g.node(u);
+				if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) addConflict(conflicts, u, v);
+			});
+		});
+	}
+	function visitLayer(north, south) {
+		var prevNorthPos = -1, nextNorthPos, southPos = 0;
+		forEach(south, function(v, southLookahead) {
+			if (g.node(v).dummy === "border") {
+				var predecessors = g.predecessors(v);
+				if (predecessors.length) {
+					nextNorthPos = g.node(predecessors[0]).order;
+					scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
+					southPos = southLookahead;
+					prevNorthPos = nextNorthPos;
+				}
+			}
+			scan(south, southPos, south.length, nextNorthPos, north.length);
+		});
+		return south;
+	}
+	reduce(layering, visitLayer);
+	return conflicts;
+}
+function findOtherInnerSegmentNode(g, v) {
+	if (g.node(v).dummy) return find(g.predecessors(v), function(u) {
+		return g.node(u).dummy;
+	});
+}
+/**
+* Sets `conflicts[v][w] = true`, creating objects if needed.
+*
+* @param {{[nodeId: string | number]: {[nodeId: string | number]: true}}} conflicts - Object to set.
+* @param {string | number} v - First Node ID
+* @param {string | number} w - Second Node ID
+*/
+function addConflict(conflicts, v, w) {
+	if (v > w) {
+		var tmp = v;
+		v = w;
+		w = tmp;
+	}
+	if (!Object.prototype.hasOwnProperty.call(conflicts, v)) Object.defineProperty(conflicts, v, {
+		enumerable: true,
+		configurable: true,
+		value: {},
+		writable: true
+	});
+	var conflictsV = conflicts[v];
+	Object.defineProperty(conflictsV, w, {
+		enumerable: true,
+		configurable: true,
+		value: true,
+		writable: true
+	});
+}
+function hasConflict(conflicts, v, w) {
+	if (v > w) {
+		var tmp = v;
+		v = w;
+		w = tmp;
+	}
+	return !!conflicts[v] && Object.prototype.hasOwnProperty.call(conflicts[v], w);
+}
+function verticalAlignment(g, layering, conflicts, neighborFn) {
+	var root = {}, align = {}, pos = {};
+	forEach(layering, function(layer) {
+		forEach(layer, function(v, order) {
+			root[v] = v;
+			align[v] = v;
+			pos[v] = order;
+		});
+	});
+	forEach(layering, function(layer) {
+		var prevIdx = -1;
+		forEach(layer, function(v) {
+			var ws = neighborFn(v);
+			if (ws.length) {
+				ws = sortBy(ws, function(w) {
+					return pos[w];
+				});
+				var mp = (ws.length - 1) / 2;
+				for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+					var w = ws[i];
+					if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+						align[w] = v;
+						align[v] = root[v] = root[w];
+						prevIdx = pos[w];
+					}
+				}
+			}
+		});
+	});
+	return {
+		root,
+		align
+	};
+}
+function horizontalCompaction(g, layering, root, align, reverseSep) {
+	/** @type {Record<import('../../graphlib/graph.js').NodeID, number>} */
+	var xs = {}, blockG = buildBlockGraph(g, layering, root, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
+	function iterate(setXsFunc, nextNodesFunc) {
+		var stack = blockG.nodes();
+		var elem = stack.pop();
+		var visited = {};
+		while (elem) {
+			if (visited[elem]) setXsFunc(elem);
+			else {
+				visited[elem] = true;
+				stack.push(elem);
+				stack = stack.concat(nextNodesFunc(elem));
+			}
+			elem = stack.pop();
+		}
+	}
+	function pass1(elem) {
+		xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {
+			return Math.max(acc, xs[e.v] + blockG.edge(e));
+		}, 0);
+	}
+	function pass2(elem) {
+		var min = blockG.outEdges(elem).reduce(function(acc, e) {
+			return Math.min(acc, xs[e.w] - blockG.edge(e));
+		}, Number.POSITIVE_INFINITY);
+		var node = g.node(elem);
+		if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) xs[elem] = Math.max(xs[elem], min);
+	}
+	iterate(pass1, blockG.predecessors.bind(blockG));
+	iterate(pass2, blockG.successors.bind(blockG));
+	forEach(align, function(v) {
+		xs[v] = xs[root[v]];
+	});
+	return xs;
+}
+function buildBlockGraph(g, layering, root, reverseSep) {
+	var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+	forEach(layering, function(layer) {
+		var u;
+		forEach(layer, function(v) {
+			var vRoot = root[v];
+			blockGraph.setNode(vRoot);
+			if (u) {
+				var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
+				blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
+			}
+			u = v;
+		});
+	});
+	return blockGraph;
+}
+function findSmallestWidthAlignment(g, xss) {
+	return minBy(values(xss), function(xs) {
+		var max = Number.NEGATIVE_INFINITY;
+		var min = Number.POSITIVE_INFINITY;
+		forIn(xs, function(x, v) {
+			var halfWidth = width(g, v) / 2;
+			max = Math.max(x + halfWidth, max);
+			min = Math.min(x - halfWidth, min);
+		});
+		return max - min;
+	});
+}
+function alignCoordinates(xss, alignTo) {
+	var alignToVals = values(alignTo), alignToMin = min(alignToVals), alignToMax = max(alignToVals);
+	forEach(["u", "d"], function(vert) {
+		forEach(["l", "r"], function(horiz) {
+			var alignment = vert + horiz, xs = xss[alignment], delta;
+			if (xs === alignTo) return;
+			var xsVals = values(xs);
+			delta = horiz === "l" ? alignToMin - min(xsVals) : alignToMax - max(xsVals);
+			if (delta) xss[alignment] = mapValues(xs, function(x) {
+				return x + delta;
+			});
+		});
+	});
+}
+function balance(xss, align) {
+	return mapValues(xss.ul, function(ignore, v) {
+		if (align) return xss[align.toLowerCase()][v];
+		else {
+			var xs = sortBy(map(xss, v));
+			return (xs[1] + xs[2]) / 2;
+		}
+	});
+}
+function positionX(g) {
+	var layering = buildLayerMatrix(g);
+	var conflicts = merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+	var xss = {};
+	var adjustedLayering;
+	forEach(["u", "d"], function(vert) {
+		adjustedLayering = vert === "u" ? layering : values(layering).reverse();
+		forEach(["l", "r"], function(horiz) {
+			if (horiz === "r") adjustedLayering = map(adjustedLayering, function(inner) {
+				return values(inner).reverse();
+			});
+			var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
+			var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+			var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === "r");
+			if (horiz === "r") xs = mapValues(xs, function(x) {
+				return -x;
+			});
+			xss[vert + horiz] = xs;
+		});
+	});
+	alignCoordinates(xss, findSmallestWidthAlignment(g, xss));
+	return balance(xss, g.graph().align);
+}
+function sep(nodeSep, edgeSep, reverseSep) {
+	return function(g, v, w) {
+		var vLabel = g.node(v);
+		var wLabel = g.node(w);
+		var sum = 0;
+		var delta;
+		sum += vLabel.width / 2;
+		if (Object.prototype.hasOwnProperty.call(vLabel, "labelpos")) switch (vLabel.labelpos.toLowerCase()) {
+			case "l":
+				delta = -vLabel.width / 2;
+				break;
+			case "r":
+				delta = vLabel.width / 2;
+				break;
+		}
+		if (delta) sum += reverseSep ? delta : -delta;
+		delta = 0;
+		sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
+		sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
+		sum += wLabel.width / 2;
+		if (Object.prototype.hasOwnProperty.call(wLabel, "labelpos")) switch (wLabel.labelpos.toLowerCase()) {
+			case "l":
+				delta = wLabel.width / 2;
+				break;
+			case "r":
+				delta = -wLabel.width / 2;
+				break;
+		}
+		if (delta) sum += reverseSep ? delta : -delta;
+		delta = 0;
+		return sum;
+	};
+}
+function width(g, v) {
+	return g.node(v).width;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/position/index.js
+function position(g) {
+	g = asNonCompoundGraph(g);
+	positionY(g);
+	forOwn(positionX(g), function(x, v) {
+		g.node(v).x = x;
+	});
+}
+function positionY(g) {
+	var layering = buildLayerMatrix(g);
+	var rankSep = g.graph().ranksep;
+	var prevY = 0;
+	forEach(layering, function(layer) {
+		var maxHeight = max(map(layer, function(v) {
+			return g.node(v).height;
+		}));
+		forEach(layer, function(v) {
+			g.node(v).y = prevY + maxHeight / 2;
+		});
+		prevY += maxHeight + rankSep;
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/dagre-d3-es@7.0.14/node_modules/dagre-d3-es/src/dagre/layout.js
+function layout(g, opts) {
+	var time$1 = opts && opts.debugTiming ? time : notime;
+	time$1("layout", () => {
+		var layoutGraph = time$1("  buildLayoutGraph", () => buildLayoutGraph(g));
+		time$1("  runLayout", () => runLayout(layoutGraph, time$1));
+		time$1("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
+	});
+}
+function runLayout(g, time) {
+	time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
+	time("    removeSelfEdges", () => removeSelfEdges(g));
+	time("    acyclic", () => run$2(g));
+	time("    nestingGraph.run", () => run(g));
+	time("    rank", () => rank(asNonCompoundGraph(g)));
+	time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
+	time("    removeEmptyRanks", () => removeEmptyRanks(g));
+	time("    nestingGraph.cleanup", () => cleanup(g));
+	time("    normalizeRanks", () => normalizeRanks(g));
+	time("    assignRankMinMax", () => assignRankMinMax(g));
+	time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
+	time("    normalize.run", () => run$1(g));
+	time("    parentDummyChains", () => parentDummyChains(g));
+	time("    addBorderSegments", () => addBorderSegments(g));
+	time("    order", () => order(g));
+	time("    insertSelfEdges", () => insertSelfEdges(g));
+	time("    adjustCoordinateSystem", () => adjust(g));
+	time("    position", () => position(g));
+	time("    positionSelfEdges", () => positionSelfEdges(g));
+	time("    removeBorderNodes", () => removeBorderNodes(g));
+	time("    normalize.undo", () => undo(g));
+	time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
+	time("    undoCoordinateSystem", () => undo$1(g));
+	time("    translateGraph", () => translateGraph(g));
+	time("    assignNodeIntersects", () => assignNodeIntersects(g));
+	time("    reversePoints", () => reversePointsForReversedEdges(g));
+	time("    acyclic.undo", () => undo$2(g));
+}
+function updateInputGraph(inputGraph, layoutGraph) {
+	forEach(inputGraph.nodes(), function(v) {
+		var inputLabel = inputGraph.node(v);
+		var layoutLabel = layoutGraph.node(v);
+		if (inputLabel) {
+			inputLabel.x = layoutLabel.x;
+			inputLabel.y = layoutLabel.y;
+			if (layoutGraph.children(v).length) {
+				inputLabel.width = layoutLabel.width;
+				inputLabel.height = layoutLabel.height;
+			}
+		}
+	});
+	forEach(inputGraph.edges(), function(e) {
+		var inputLabel = inputGraph.edge(e);
+		var layoutLabel = layoutGraph.edge(e);
+		inputLabel.points = layoutLabel.points;
+		if (Object.prototype.hasOwnProperty.call(layoutLabel, "x")) {
+			inputLabel.x = layoutLabel.x;
+			inputLabel.y = layoutLabel.y;
+		}
+	});
+	inputGraph.graph().width = layoutGraph.graph().width;
+	inputGraph.graph().height = layoutGraph.graph().height;
+}
+var graphNumAttrs = [
+	"nodesep",
+	"edgesep",
+	"ranksep",
+	"marginx",
+	"marginy"
+];
+var graphDefaults = {
+	ranksep: 50,
+	edgesep: 20,
+	nodesep: 50,
+	rankdir: "tb"
+};
+var graphAttrs = [
+	"acyclicer",
+	"ranker",
+	"rankdir",
+	"align"
+];
+var nodeNumAttrs = ["width", "height"];
+var nodeDefaults = {
+	width: 0,
+	height: 0
+};
+var edgeNumAttrs = [
+	"minlen",
+	"weight",
+	"width",
+	"height",
+	"labeloffset"
+];
+var edgeDefaults = {
+	minlen: 1,
+	weight: 1,
+	width: 0,
+	height: 0,
+	labeloffset: 10,
+	labelpos: "r"
+};
+var edgeAttrs = ["labelpos"];
+function buildLayoutGraph(inputGraph) {
+	var g = new Graph({
+		multigraph: true,
+		compound: true
+	});
+	var graph = canonicalize(inputGraph.graph());
+	g.setGraph(merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), pick(graph, graphAttrs)));
+	forEach(inputGraph.nodes(), function(v) {
+		var node = canonicalize(inputGraph.node(v));
+		g.setNode(v, defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+		g.setParent(v, inputGraph.parent(v));
+	});
+	forEach(inputGraph.edges(), function(e) {
+		var edge = canonicalize(inputGraph.edge(e));
+		g.setEdge(e, merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), pick(edge, edgeAttrs)));
+	});
+	return g;
+}
+function makeSpaceForEdgeLabels(g) {
+	var graph = g.graph();
+	graph.ranksep /= 2;
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		edge.minlen *= 2;
+		if (edge.labelpos.toLowerCase() !== "c") if (graph.rankdir === "TB" || graph.rankdir === "BT") edge.width += edge.labeloffset;
+		else edge.height += edge.labeloffset;
+	});
+}
+function injectEdgeLabelProxies(g) {
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		if (edge.width && edge.height) {
+			var v = g.node(e.v);
+			var label = {
+				rank: (g.node(e.w).rank - v.rank) / 2 + v.rank,
+				e
+			};
+			addDummyNode(g, "edge-proxy", label, "_ep");
+		}
+	});
+}
+function assignRankMinMax(g) {
+	var maxRank = 0;
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v);
+		if (node.borderTop) {
+			node.minRank = g.node(node.borderTop).rank;
+			node.maxRank = g.node(node.borderBottom).rank;
+			maxRank = max(maxRank, node.maxRank);
+		}
+	});
+	g.graph().maxRank = maxRank;
+}
+function removeEdgeLabelProxies(g) {
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v);
+		if (node.dummy === "edge-proxy") {
+			g.edge(node.e).labelRank = node.rank;
+			g.removeNode(v);
+		}
+	});
+}
+function translateGraph(g) {
+	var minX = Number.POSITIVE_INFINITY;
+	var maxX = 0;
+	var minY = Number.POSITIVE_INFINITY;
+	var maxY = 0;
+	var graphLabel = g.graph();
+	var marginX = graphLabel.marginx || 0;
+	var marginY = graphLabel.marginy || 0;
+	function getExtremes(attrs) {
+		var x = attrs.x;
+		var y = attrs.y;
+		var w = attrs.width;
+		var h = attrs.height;
+		minX = Math.min(minX, x - w / 2);
+		maxX = Math.max(maxX, x + w / 2);
+		minY = Math.min(minY, y - h / 2);
+		maxY = Math.max(maxY, y + h / 2);
+	}
+	forEach(g.nodes(), function(v) {
+		getExtremes(g.node(v));
+	});
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		if (Object.prototype.hasOwnProperty.call(edge, "x")) getExtremes(edge);
+	});
+	minX -= marginX;
+	minY -= marginY;
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v);
+		node.x -= minX;
+		node.y -= minY;
+	});
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		forEach(edge.points, function(p) {
+			p.x -= minX;
+			p.y -= minY;
+		});
+		if (Object.prototype.hasOwnProperty.call(edge, "x")) edge.x -= minX;
+		if (Object.prototype.hasOwnProperty.call(edge, "y")) edge.y -= minY;
+	});
+	graphLabel.width = maxX - minX + marginX;
+	graphLabel.height = maxY - minY + marginY;
+}
+function assignNodeIntersects(g) {
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		var nodeV = g.node(e.v);
+		var nodeW = g.node(e.w);
+		var p1, p2;
+		if (!edge.points) {
+			edge.points = [];
+			p1 = nodeW;
+			p2 = nodeV;
+		} else {
+			p1 = edge.points[0];
+			p2 = edge.points[edge.points.length - 1];
+		}
+		edge.points.unshift(intersectRect(nodeV, p1));
+		edge.points.push(intersectRect(nodeW, p2));
+	});
+}
+function fixupEdgeLabelCoords(g) {
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		if (Object.prototype.hasOwnProperty.call(edge, "x")) {
+			if (edge.labelpos === "l" || edge.labelpos === "r") edge.width -= edge.labeloffset;
+			switch (edge.labelpos) {
+				case "l":
+					edge.x -= edge.width / 2 + edge.labeloffset;
+					break;
+				case "r":
+					edge.x += edge.width / 2 + edge.labeloffset;
+					break;
+			}
+		}
+	});
+}
+function reversePointsForReversedEdges(g) {
+	forEach(g.edges(), function(e) {
+		var edge = g.edge(e);
+		if (edge.reversed) edge.points.reverse();
+	});
+}
+function removeBorderNodes(g) {
+	forEach(g.nodes(), function(v) {
+		if (g.children(v).length) {
+			var node = g.node(v);
+			var t = g.node(node.borderTop);
+			var b = g.node(node.borderBottom);
+			var l = g.node(last(node.borderLeft));
+			var r = g.node(last(node.borderRight));
+			node.width = Math.abs(r.x - l.x);
+			node.height = Math.abs(b.y - t.y);
+			node.x = l.x + node.width / 2;
+			node.y = t.y + node.height / 2;
+		}
+	});
+	forEach(g.nodes(), function(v) {
+		if (g.node(v).dummy === "border") g.removeNode(v);
+	});
+}
+function removeSelfEdges(g) {
+	forEach(g.edges(), function(e) {
+		if (e.v === e.w) {
+			var node = g.node(e.v);
+			if (!node.selfEdges) node.selfEdges = [];
+			node.selfEdges.push({
+				e,
+				label: g.edge(e)
+			});
+			g.removeEdge(e);
+		}
+	});
+}
+function insertSelfEdges(g) {
+	var layers = buildLayerMatrix(g);
+	forEach(layers, function(layer) {
+		var orderShift = 0;
+		forEach(layer, function(v, i) {
+			var node = g.node(v);
+			node.order = i + orderShift;
+			forEach(node.selfEdges, function(selfEdge) {
+				addDummyNode(g, "selfedge", {
+					width: selfEdge.label.width,
+					height: selfEdge.label.height,
+					rank: node.rank,
+					order: i + ++orderShift,
+					e: selfEdge.e,
+					label: selfEdge.label
+				}, "_se");
+			});
+			delete node.selfEdges;
+		});
+	});
+}
+function positionSelfEdges(g) {
+	forEach(g.nodes(), function(v) {
+		var node = g.node(v);
+		if (node.dummy === "selfedge") {
+			var selfNode = g.node(node.e.v);
+			var x = selfNode.x + selfNode.width / 2;
+			var y = selfNode.y;
+			var dx = node.x - x;
+			var dy = selfNode.height / 2;
+			g.setEdge(node.e, node.label);
+			g.removeNode(v);
+			node.label.points = [
+				{
+					x: x + 2 * dx / 3,
+					y: y - dy
+				},
+				{
+					x: x + 5 * dx / 6,
+					y: y - dy
+				},
+				{
+					x: x + dx,
+					y
+				},
+				{
+					x: x + 5 * dx / 6,
+					y: y + dy
+				},
+				{
+					x: x + 2 * dx / 3,
+					y: y + dy
+				}
+			];
+			node.label.x = node.x;
+			node.label.y = node.y;
+		}
+	});
+}
+function selectNumberAttrs(obj, attrs) {
+	return mapValues(pick(obj, attrs), Number);
+}
+function canonicalize(attrs) {
+	var newAttrs = {};
+	forEach(attrs, function(v, k) {
+		newAttrs[k.toLowerCase()] = v;
+	});
+	return newAttrs;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/mermaid@12.0.0/node_modules/mermaid/dist/chunks/mermaid.core/dagre-6A5THRUB.mjs
+var clamp = /* @__PURE__ */ __name((value, min, max) => Math.max(min, Math.min(max, value)), "clamp");
+var getDefaultSelfLoopSide = /* @__PURE__ */ __name((rankdir = "TB") => {
+	switch (rankdir) {
+		case "BT": return "bottom";
+		case "LR": return "right";
+		case "RL": return "left";
+		default: return "top";
+	}
+}, "getDefaultSelfLoopSide");
+var shouldMergeSelfLoopSegments = /* @__PURE__ */ __name((diagramType) => diagramType === "flowchart" || diagramType === "flowchart-v2" || diagramType === "stateDiagram" || diagramType === "er" || diagramType === "classDiagram", "shouldMergeSelfLoopSegments");
+var DAGRE_NODE_LAYOUT_PROPERTIES = [
+	"x",
+	"y",
+	"width",
+	"height",
+	"labelBBox",
+	"intersect",
+	"calcIntersect",
+	"diff",
+	"clusterNode"
+];
+var getSelfLoopSide = /* @__PURE__ */ __name((graph, node, segments, originalNodeId, rankdir) => {
+	const layoutHints = [];
+	const dummyNodeIds = /* @__PURE__ */ new Set();
+	segments.forEach(({ start, end }) => {
+		if (start !== originalNodeId) dummyNodeIds.add(start);
+		if (end !== originalNodeId) dummyNodeIds.add(end);
+	});
+	dummyNodeIds.forEach((id) => {
+		const dummyNode = graph.node(id);
+		if (typeof dummyNode?.x === "number" && typeof dummyNode?.y === "number") layoutHints.push(dummyNode);
+	});
+	if (layoutHints.length === 0) segments.forEach(({ edge }) => {
+		(edge.points ?? []).forEach((point) => {
+			if (typeof point?.x === "number" && typeof point?.y === "number") layoutHints.push(point);
+		});
+	});
+	if (layoutHints.length === 0) return getDefaultSelfLoopSide(rankdir);
+	const center = layoutHints.reduce((acc, point) => ({
+		x: acc.x + point.x / layoutHints.length,
+		y: acc.y + point.y / layoutHints.length
+	}), {
+		x: 0,
+		y: 0
+	});
+	const dx = center.x - node.x;
+	const dy = center.y - node.y;
+	if (Math.abs(dx) > Math.abs(dy)) return dx > 0 ? "right" : "left";
+	if (Math.abs(dy) > 0) return dy > 0 ? "bottom" : "top";
+	return getDefaultSelfLoopSide(rankdir);
+}, "getSelfLoopSide");
+var getSelfLoopPoints = /* @__PURE__ */ __name((node, side = "top", yOffset = 0, labelWidth = 0) => {
+	const x = node.x;
+	const y = node.y - yOffset;
+	const halfWidth = node.width / 2;
+	const halfHeight = node.height / 2;
+	const maxSpan = Math.max(36, Math.min(100, node.width * .8));
+	const span = clamp(Math.max(labelWidth, node.width * .35), 36, maxSpan);
+	const depth = clamp(Math.min(node.width, node.height) * .45, 24, 48);
+	switch (side) {
+		case "bottom": {
+			const bottom = y + halfHeight;
+			return [
+				{
+					x: x - span / 2,
+					y: bottom
+				},
+				{
+					x: x - span / 2,
+					y: bottom + depth
+				},
+				{
+					x: x + span / 2,
+					y: bottom + depth
+				},
+				{
+					x: x + span / 2,
+					y: bottom
+				}
+			];
+		}
+		case "right": {
+			const right = x + halfWidth;
+			return [
+				{
+					x: right,
+					y: y - span / 2
+				},
+				{
+					x: right + depth,
+					y: y - span / 2
+				},
+				{
+					x: right + depth,
+					y: y + span / 2
+				},
+				{
+					x: right,
+					y: y + span / 2
+				}
+			];
+		}
+		case "left": {
+			const left = x - halfWidth;
+			return [
+				{
+					x: left,
+					y: y - span / 2
+				},
+				{
+					x: left - depth,
+					y: y - span / 2
+				},
+				{
+					x: left - depth,
+					y: y + span / 2
+				},
+				{
+					x: left,
+					y: y + span / 2
+				}
+			];
+		}
+		default: {
+			const top = y - halfHeight;
+			return [
+				{
+					x: x - span / 2,
+					y: top
+				},
+				{
+					x: x - span / 2,
+					y: top - depth
+				},
+				{
+					x: x + span / 2,
+					y: top - depth
+				},
+				{
+					x: x + span / 2,
+					y: top
+				}
+			];
+		}
+	}
+}, "getSelfLoopPoints");
+var getSelfLoopLabelPosition = /* @__PURE__ */ __name((node, points, side = "top", yOffset = 0, label = {}) => {
+	const gap = 4;
+	const x = node.x;
+	const y = node.y - yOffset;
+	const labelWidth = label.width ?? 0;
+	const labelHeight = label.height ?? 0;
+	switch (side) {
+		case "bottom": return {
+			x,
+			y: Math.max(...points.map((point) => point.y)) + labelHeight / 2 + gap
+		};
+		case "right": return {
+			x: Math.max(...points.map((point) => point.x)) + labelWidth / 2 + gap,
+			y
+		};
+		case "left": return {
+			x: Math.min(...points.map((point) => point.x)) - labelWidth / 2 - gap,
+			y
+		};
+		default: return {
+			x,
+			y: Math.min(...points.map((point) => point.y)) - labelHeight / 2 - gap
+		};
+	}
+}, "getSelfLoopLabelPosition");
+var getEdgesToRender = /* @__PURE__ */ __name((graph, yOffset = 0, { mergeSelfLoops = true } = {}) => {
+	const selfLoopEdgeGroups = /* @__PURE__ */ new Map();
+	const edgesToRender = [];
+	const rankdir = graph.graph()?.rankdir;
+	graph.edges().forEach((e) => {
+		const edge = graph.edge(e);
+		if (mergeSelfLoops && edge.selfLoop) {
+			const key = edge.selfLoop.id;
+			if (!selfLoopEdgeGroups.has(key)) selfLoopEdgeGroups.set(key, []);
+			selfLoopEdgeGroups.get(key).push({
+				edge,
+				start: e.v,
+				end: e.w
+			});
+		} else edgesToRender.push({
+			edge,
+			start: e.v,
+			end: e.w
+		});
+	});
+	selfLoopEdgeGroups.forEach((segments) => {
+		if (segments.length !== 3) {
+			segments.forEach((segment) => edgesToRender.push(segment));
+			return;
+		}
+		segments.sort((a, b) => a.edge.selfLoop.order - b.edge.selfLoop.order);
+		const [firstSegment, middleSegment, lastSegment] = segments;
+		const originalEdge = firstSegment.edge.originalEdge ?? middleSegment.edge.originalEdge ?? lastSegment.edge.originalEdge ?? middleSegment.edge;
+		const node = graph.node(originalEdge.start);
+		if (!node) {
+			segments.forEach((segment) => edgesToRender.push(segment));
+			return;
+		}
+		const label = {
+			width: middleSegment.edge.width,
+			height: middleSegment.edge.height
+		};
+		const side = getSelfLoopSide(graph, node, segments, originalEdge.start, rankdir);
+		const points = getSelfLoopPoints(node, side, yOffset, label.width ?? 0);
+		const labelPosition = getSelfLoopLabelPosition(node, points, side, yOffset, label);
+		const mergedEdge = {
+			...middleSegment.edge,
+			...originalEdge,
+			id: originalEdge.id,
+			points,
+			start: originalEdge.start,
+			end: originalEdge.end,
+			x: labelPosition.x,
+			y: labelPosition.y,
+			width: label.width,
+			height: label.height,
+			labelStyle: middleSegment.edge.labelStyle,
+			fromCluster: firstSegment.edge.fromCluster ?? middleSegment.edge.fromCluster ?? lastSegment.edge.fromCluster,
+			toCluster: firstSegment.edge.toCluster ?? middleSegment.edge.toCluster ?? lastSegment.edge.toCluster
+		};
+		delete mergedEdge.selfLoop;
+		delete mergedEdge.originalEdge;
+		edgesToRender.push({
+			edge: mergedEdge,
+			start: mergedEdge.start,
+			end: mergedEdge.end
+		});
+	});
+	return edgesToRender;
+}, "getEdgesToRender");
+var measureDagreGraph = /* @__PURE__ */ __name(async ({ element: _elem, graph, diagramType, id, parentCluster, siteConfig }) => {
+	const dir = graph.graph().rankdir;
+	log.trace("Dir in recursive render - dir:", dir);
+	const { clusters, edgePaths, edgeLabels, nodes, rootGroups: elem } = createLayoutElementGroups(_elem, { edgePathsClass: "edgePaths" });
+	if (!graph.nodes()) log.info("No nodes found for", graph);
+	else log.info("Recursive render XXX", graph.nodes());
+	if (graph.edges().length > 0) log.info("Recursive edges", graph.edge(graph.edges()[0]));
+	const mergeSelfLoops = shouldMergeSelfLoopSegments(diagramType);
+	await Promise.all(graph.nodes().map(async function(v) {
+		const node = graph.node(v);
+		if (parentCluster !== void 0) {
+			const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
+			log.trace("Setting data for parent cluster XXX\n Node.id = ", v, "\n data=", data.height, "\nParent cluster", parentCluster.height);
+			graph.setNode(parentCluster.id, data);
+			if (!graph.parent(v)) {
+				log.trace("Setting parent", v, parentCluster.id);
+				graph.setParent(v, parentCluster.id, data);
+			}
+		}
+		log.info("(Insert) Node XXX" + v + ": " + JSON.stringify(graph.node(v)));
+		if (node?.clusterNode) {
+			log.info("Cluster identified XBX", v, node.width, graph.node(v));
+			const { ranksep, nodesep } = graph.graph();
+			node.graph.setGraph({
+				...node.graph.graph(),
+				ranksep: ranksep + 25,
+				nodesep
+			});
+			const o = await renderDagreSubgraph({
+				element: nodes,
+				graph: node.graph,
+				diagramType,
+				id,
+				parentCluster: graph.node(v),
+				siteConfig
+			});
+			const newEl = o.elem;
+			updateNodeBounds(node, newEl);
+			node.diff = o.diff || 0;
+			log.info("New compound node after recursive render XAX", v, "width", node.width, "height", node.height);
+			setNodeElem(newEl, node);
+		} else if (graph.children(v).length > 0) {
+			log.trace("Cluster - the non recursive path XBX", v, node.id, node, node.width, "Graph:", graph);
+			log.trace(findNonClusterChild(node.id, graph));
+			clusterDb.set(node.id, {
+				id: findNonClusterChild(node.id, graph),
+				node
+			});
+		} else {
+			log.trace("Node - the non recursive path XAX", v, nodes, graph.node(v), dir);
+			await insertMeasuredNode(nodes, graph.node(v), {
+				config: siteConfig,
+				dir
+			});
+		}
+	}));
+	await (/* @__PURE__ */ __name(async () => {
+		const edgePromises = graph.edges().map(async function(e) {
+			const edge = graph.edge(e.v, e.w, e.name);
+			log.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e));
+			log.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(graph.edge(e)));
+			log.info("Fix", clusterDb, "ids:", e.v, e.w, "Translating: ", clusterDb.get(e.v), clusterDb.get(e.w));
+			if (mergeSelfLoops && edge.selfLoop) {
+				if (edge.selfLoop.order !== 1) return;
+				const labelEdge = {
+					...edge.originalEdge,
+					...edge,
+					id: edge.selfLoop.id,
+					startLabelLeft: edge.originalEdge?.startLabelLeft ?? edge.startLabelLeft,
+					startLabelRight: edge.originalEdge?.startLabelRight ?? edge.startLabelRight,
+					endLabelLeft: edge.originalEdge?.endLabelLeft ?? edge.endLabelLeft,
+					endLabelRight: edge.originalEdge?.endLabelRight ?? edge.endLabelRight
+				};
+				await insertEdgeLabel(edgeLabels, labelEdge);
+				edge.width = labelEdge.width;
+				edge.height = labelEdge.height;
+				edge.labelStyle = labelEdge.labelStyle;
+				return;
+			}
+			await insertEdgeLabel(edgeLabels, edge);
+		});
+		await Promise.all(edgePromises);
+	}, "processEdges"))();
+	const { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig);
+	return {
+		elem,
+		graph,
+		groups: {
+			clusters,
+			edgePaths,
+			edgeLabels,
+			nodes,
+			rootGroups: elem
+		},
+		diagramType,
+		id,
+		mergeSelfLoops,
+		subGraphTitleTotalMargin
+	};
+}, "measureDagreGraph");
+var runDagreGraphLayout = /* @__PURE__ */ __name((graph) => {
+	log.info("############################################# XXX");
+	log.info("###                Layout                 ### XXX");
+	log.info("############################################# XXX");
+	layout(graph);
+}, "runDagreGraphLayout");
+var normalizeDagreNode = /* @__PURE__ */ __name((graph, nodeId, subGraphTitleTotalMargin) => {
+	const node = graph.node(nodeId);
+	if (!node) return;
+	const normalizedNode = { ...node };
+	if (node?.clusterNode) normalizedNode.y = (node.y ?? 0) + subGraphTitleTotalMargin;
+	else if (graph.children(nodeId).length > 0) normalizedNode.height = (node.height ?? 0) + subGraphTitleTotalMargin;
+	else normalizedNode.y = (node.y ?? 0) + subGraphTitleTotalMargin / 2;
+	return normalizedNode;
+}, "normalizeDagreNode");
+var applyDagreNodeLayout = /* @__PURE__ */ __name((targetNode, dagreNode) => {
+	DAGRE_NODE_LAYOUT_PROPERTIES.forEach((property) => {
+		if (dagreNode[property] !== void 0) targetNode[property] = dagreNode[property];
+	});
+}, "applyDagreNodeLayout");
+var normalizeDagreEdge = /* @__PURE__ */ __name((edge, start, end, edgeOffsetY) => ({
+	...edge,
+	start: edge.start ?? start,
+	end: edge.end ?? end,
+	points: (edge.points ?? []).map((point) => ({
+		...point,
+		y: typeof point.y === "number" ? point.y + edgeOffsetY : point.y
+	}))
+}), "normalizeDagreEdge");
+var applyDagreLayoutResult = /* @__PURE__ */ __name((data4Layout, measuredLayout) => {
+	const { graph, mergeSelfLoops, subGraphTitleTotalMargin = 0 } = measuredLayout;
+	const nodeById = new Map(data4Layout.nodes.map((node) => [node.id, node]));
+	sortNodesByHierarchy(graph).forEach((nodeId) => {
+		const dagreNode = normalizeDagreNode(graph, nodeId, subGraphTitleTotalMargin);
+		if (!dagreNode) return;
+		applyDagreNodeLayout(graph.node(nodeId), dagreNode);
+		const targetNode = nodeById.get(nodeId);
+		if (targetNode) applyDagreNodeLayout(targetNode, dagreNode);
+	});
+	const edgeOffsetY = subGraphTitleTotalMargin / 2;
+	data4Layout.edges = getEdgesToRender(graph, edgeOffsetY, { mergeSelfLoops }).map(({ edge, start, end }) => normalizeDagreEdge(edge, start, end, edgeOffsetY));
+	return data4Layout;
+}, "applyDagreLayoutResult");
+var paintDagreLayoutCore = /* @__PURE__ */ __name(async ({ elem, graph, groups: { clusters, edgePaths }, diagramType, id, mergeSelfLoops, subGraphTitleTotalMargin }) => {
+	let diff = 0;
+	await Promise.all(sortNodesByHierarchy(graph).map(async function(v) {
+		const node = graph.node(v);
+		log.info("Position XBX => " + v + ": (" + node.x, "," + node.y, ") width: ", node.width, " height: ", node.height);
+		if (node?.clusterNode) {
+			node.y += subGraphTitleTotalMargin;
+			log.info("A tainted cluster node XBX1", v, node.id, node.width, node.height, node.x, node.y, graph.parent(v));
+			clusterDb.get(node.id).node = node;
+			positionNode(node);
+		} else if (graph.children(v).length > 0) {
+			log.info("A pure cluster node XBX1", v, node.id, node.x, node.y, node.width, node.height, graph.parent(v));
+			node.height += subGraphTitleTotalMargin;
+			graph.node(node.parentId);
+			const halfPadding = node?.padding / 2 || 0;
+			const labelHeight = node?.labelBBox?.height || 0;
+			const offsetY = labelHeight - halfPadding || 0;
+			log.debug("OffsetY", offsetY, "labelHeight", labelHeight, "halfPadding", halfPadding);
+			await insertCluster(clusters, node);
+			clusterDb.get(node.id).node = node;
+		} else {
+			const parent = graph.node(node.parentId);
+			node.y += subGraphTitleTotalMargin / 2;
+			log.info("A regular node XBX1 - using the padding", node.id, "parent", node.parentId, node.width, node.height, node.x, node.y, "offsetY", node.offsetY, "parent", parent, parent?.offsetY, node);
+			positionNode(node);
+		}
+	}));
+	const edgeOffsetY = subGraphTitleTotalMargin / 2;
+	getEdgesToRender(graph, edgeOffsetY, { mergeSelfLoops }).forEach(function({ edge, start, end }) {
+		log.info("Edge " + start + " -> " + end + ": " + JSON.stringify(edge), edge);
+		edge.points.forEach((point) => point.y += edgeOffsetY);
+		positionEdgeLabel(edge, insertEdge(edgePaths, edge, clusterDb, diagramType, graph.node(start), graph.node(end), id));
+	});
+	graph.nodes().forEach(function(v) {
+		const n = graph.node(v);
+		log.info(v, n.type, n.diff);
+		if (n.isGroup) diff = n.diff;
+	});
+	log.warn("Returning from recursive render XAX", elem, diff);
+	return {
+		elem,
+		diff
+	};
+}, "paintDagreLayoutCore");
+var renderDagreSubgraph = /* @__PURE__ */ __name(async (options) => {
+	const measuredLayout = await measureDagreGraph(options);
+	runDagreGraphLayout(measuredLayout.graph);
+	return await paintDagreLayoutCore(measuredLayout);
+}, "renderDagreSubgraph");
+var prepareLayoutForDagre = /* @__PURE__ */ __name((data4Layout) => {
+	const graph = new Graph({
+		multigraph: true,
+		compound: true
+	}).setGraph({
+		rankdir: data4Layout.direction,
+		nodesep: data4Layout.config?.nodeSpacing || data4Layout.nodeSpacing || data4Layout.config?.flowchart?.nodeSpacing,
+		ranksep: data4Layout.config?.rankSpacing || data4Layout.rankSpacing || data4Layout.config?.flowchart?.rankSpacing,
+		marginx: 8,
+		marginy: 8
+	}).setDefaultEdgeLabel(function() {
+		return {};
+	});
+	data4Layout.nodes.forEach((node) => {
+		graph.setNode(node.id, { ...node });
+		if (node.parentId) graph.setParent(node.id, node.parentId);
+	});
+	log.debug("Edges:", data4Layout.edges);
+	data4Layout.edges.forEach((edge) => {
+		if (edge.start === edge.end) {
+			const nodeId = edge.start;
+			const specialId1 = nodeId + "---" + nodeId + "---1";
+			const specialId2 = nodeId + "---" + nodeId + "---2";
+			const node = graph.node(nodeId);
+			graph.setNode(specialId1, {
+				domId: specialId1,
+				id: specialId1,
+				parentId: node.parentId,
+				labelStyle: "",
+				label: "",
+				padding: 0,
+				shape: "labelRect",
+				style: "",
+				width: 10,
+				height: 10
+			});
+			graph.setParent(specialId1, node.parentId);
+			graph.setNode(specialId2, {
+				domId: specialId2,
+				id: specialId2,
+				parentId: node.parentId,
+				labelStyle: "",
+				padding: 0,
+				shape: "labelRect",
+				label: "",
+				style: "",
+				width: 10,
+				height: 10
+			});
+			graph.setParent(specialId2, node.parentId);
+			const originalEdge = structuredClone(edge);
+			const edge1 = structuredClone(edge);
+			const edgeMid = structuredClone(edge);
+			const edge2 = structuredClone(edge);
+			edge1.originalEdge = originalEdge;
+			edge1.selfLoop = {
+				id: originalEdge.id,
+				order: 0
+			};
+			edgeMid.originalEdge = originalEdge;
+			edgeMid.selfLoop = {
+				id: originalEdge.id,
+				order: 1
+			};
+			edge2.originalEdge = originalEdge;
+			edge2.selfLoop = {
+				id: originalEdge.id,
+				order: 2
+			};
+			edge1.label = "";
+			edge1.arrowTypeEnd = "none";
+			edge1.endLabelLeft = "";
+			edge1.endLabelRight = "";
+			edge1.startLabelLeft = "";
+			edge1.id = nodeId + "-cyclic-special-1";
+			edgeMid.startLabelRight = "";
+			edgeMid.startLabelLeft = "";
+			edgeMid.endLabelLeft = "";
+			edgeMid.endLabelRight = "";
+			edgeMid.arrowTypeStart = "none";
+			edgeMid.arrowTypeEnd = "none";
+			edgeMid.id = nodeId + "-cyclic-special-mid";
+			edge2.label = "";
+			edge2.startLabelRight = "";
+			edge2.startLabelLeft = "";
+			edge2.arrowTypeStart = "none";
+			if (node.isGroup) {
+				edge1.fromCluster = nodeId;
+				edge2.toCluster = nodeId;
+			}
+			edge2.id = nodeId + "-cyclic-special-2";
+			edge2.arrowTypeStart = "none";
+			graph.setEdge(nodeId, specialId1, edge1, nodeId + "-cyclic-special-0");
+			graph.setEdge(specialId1, specialId2, edgeMid, nodeId + "-cyclic-special-1");
+			graph.setEdge(specialId2, nodeId, edge2, nodeId + "-cyclic-special-2");
+		} else graph.setEdge(edge.start, edge.end, { ...edge }, edge.id);
+	});
+	adjustClustersAndEdges(graph);
+	return { graph };
+}, "prepareLayoutForDagre");
+var measureDagreLayout = /* @__PURE__ */ __name(async (data4Layout, { element, preparedLayout }) => {
+	const prepared = preparedLayout ?? prepareLayoutForDagre(data4Layout);
+	const siteConfig = getConfig2();
+	const measuredLayout = await measureDagreGraph({
+		element,
+		graph: prepared.graph,
+		diagramType: data4Layout.type,
+		id: data4Layout.diagramId,
+		parentCluster: void 0,
+		siteConfig
+	});
+	prepared.measuredLayout = measuredLayout;
+	return measuredLayout;
+}, "measureDagreLayout");
+var runDagreLayoutCore = /* @__PURE__ */ __name((data4Layout, context) => {
+	const measuredLayout = context.preparedLayout?.measuredLayout;
+	if (!measuredLayout) throw new Error("runDagreLayoutCore requires measureDagreLayout to run first");
+	runDagreGraphLayout(measuredLayout.graph);
+	applyDagreLayoutResult(data4Layout, measuredLayout);
+	return measuredLayout;
+}, "runDagreLayoutCore");
+var render = createCommonLayoutRenderer({
+	prepareLayout: prepareLayoutForDagre,
+	measureLayout: measureDagreLayout,
+	runLayoutCore: runDagreLayoutCore,
+	paintOptions: {
+		clusterDb,
+		getNodes: /* @__PURE__ */ __name((_data4Layout, { measure }) => sortNodesByHierarchy(measure.graph).map((nodeId) => measure.graph.node(nodeId)).filter(Boolean), "getDagrePaintNodes"),
+		getEdgeNode: /* @__PURE__ */ __name((nodeId, _edge, { measure }) => nodeId ? measure.graph.node(nodeId) : void 0, "getDagreEdgeNode"),
+		skipNode: /* @__PURE__ */ __name((node, { measure }) => !measure.graph.hasNode(node.id), "skipNode"),
+		isCluster: /* @__PURE__ */ __name((node, { measure }) => measure.graph.hasNode(node.id) && (measure.graph.children(node.id) ?? []).length > 0, "isCluster")
+	}
+});
+
+//#endregion
+export { applyDagreLayoutResult, getEdgesToRender, measureDagreLayout, prepareLayoutForDagre, render, runDagreLayoutCore };