@aiderdesk/aiderdesk 0.62.0 → 0.66.0

package/out/renderer/assets/{layout-DHzrXVin.js → layout-DAkKffy1.js}

@@ -1,7 +1,5 @@
-import { b as baseClone, G as Graph, i as isUndefined, v as values } from "./graph-B5YWEnt0.js";
-import { c as baseIteratee, i as baseFindIndex, j as castFunction, k as baseForOwn, l as hasPath, m as castPath, t as toKey, n as baseGet, d as arrayMap, o as hasIn, b as baseFlatten, p as toString, h as forEach, g as filter, r as reduce } from "./_baseUniq-B7TxjYgy.js";
-import { f as flatten, b as baseExtremum, a as baseLt, c as baseMap, m as map, d as min } from "./min-D6g96v7R.js";
-import { bV as toNumber, bW as setToString, bX as overRest, bC as baseRest, bY as isIterateeCall, bh as keysIn, bZ as eq, aK as isArrayLike, bg as keys, bP as baseFor, b_ as baseAssignValue, aN as identity, bu as isObject, bO as isIndex, bB as assignValue, aM as isSymbol, aL as isArray, bs as baseUnary, bE as constant, b$ as merge } from "./index-D7Xi0GX5.js";
+import { d as defineProperty, b as baseRest, a as baseFlatten, s as setToString, o as overRest, c as arrayEach, e as isArrayLikeObject, f as baseFor, g as baseIteratee, h as baseFindIndex, j as baseEach, k as arrayMap, l as castFunction, m as baseForOwn, n as hasPath, p as identity, q as castPath, t as toKey, r as baseGet, u as hasIn, v as toString, G as Graph, w as forEach, x as constant, i as isUndefined, y as filter, z as values, A as reduce } from "./graph-B_ifajWk.js";
+import { c2 as toNumber, bN as isObject, c3 as eq, bR as isArrayLike, bQ as isIndex, bX as isPrototype, c4 as arrayLikeKeys, c5 as overArg, bS as isObjectLike, c6 as baseGetTag, bO as keys, c7 as root, c8 as getSymbols, c9 as stubArray, bK as arrayPush, ca as baseGetAllKeys, cb as Uint8Array, bG as Symbol$1, bW as getTag, cc as baseUnary, cd as nodeUtil, bU as isBuffer, bL as Stack, bE as isArray, ce as getAllKeys, bV as isTypedArray, bJ as isArguments, c1 as isFunction, bF as isSymbol } from "./index-3bI-dJm8.js";
 var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
 function toFinite(value) {
   if (!value) {
@@ -18,9 +16,329 @@ function toInteger(value) {
   var result = toFinite(value), remainder = result % 1;
   return result === result ? remainder ? result - remainder : result : 0;
 }
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ (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;
+  };
+})();
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$5 = objectProto$5.hasOwnProperty;
+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);
+  }
+}
+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 = void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+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;
+}
+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;
+  });
+}
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
+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;
+}
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+function flatten(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? baseFlatten(array) : [];
+}
 function flatRest(func) {
   return setToString(overRest(func, void 0, flatten), func + "");
 }
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+var objectTag$1 = "[object Object]";
+var funcProto = Function.prototype, objectProto$3 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+var objectCtorString = funcToString.call(Object);
+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;
+}
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+function baseAssignIn(object, source) {
+  return object && copyObject(source, keysIn(source), object);
+}
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+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;
+}
+function copySymbols(source, object) {
+  return copyObject(source, getSymbols(source), object);
+}
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush(result, getSymbols(object));
+    object = getPrototype(object);
+  }
+  return result;
+};
+function copySymbolsIn(source, object) {
+  return copyObject(source, getSymbolsIn(source), object);
+}
+function getAllKeysIn(object) {
+  return baseGetAllKeys(object, keysIn, getSymbolsIn);
+}
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+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;
+}
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+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$2:
+      return new Ctor();
+    case numberTag$1:
+    case stringTag$1:
+      return new Ctor(object);
+    case regexpTag$1:
+      return cloneRegExp(object);
+    case setTag$2:
+      return new Ctor();
+    case symbolTag$1:
+      return cloneSymbol(object);
+  }
+}
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+}
+var mapTag$1 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag$1;
+}
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+var setTag$1 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag$1;
+}
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+var CLONE_DEEP_FLAG$1 = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG$1 = 4;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+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] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+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 (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(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, key2) {
+      result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
 var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
 function cloneDeep(value) {
   return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
@@ -50,6 +368,83 @@ var defaults = baseRest(function(object, sources) {
   }
   return object;
 });
+function assignMergeValue(object, key, value) {
+  if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+function safeGet(object, key) {
+  if (key === "constructor" && typeof object[key] === "function") {
+    return;
+  }
+  if (key == "__proto__") {
+    return;
+  }
+  return object[key];
+}
+function toPlainObject(value) {
+  return copyObject(value, keysIn(value));
+}
+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);
+}
+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);
+}
 function last(array) {
   var length = array == null ? 0 : array.length;
   return length ? array[length - 1] : void 0;
@@ -81,6 +476,17 @@ function findIndex(array, predicate, fromIndex) {
   return baseFindIndex(array, baseIteratee(predicate), index);
 }
 var find = createFind(findIndex);
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+  baseEach(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+function map(collection, iteratee) {
+  var func = isArray(collection) ? arrayMap : baseMap;
+  return func(collection, baseIteratee(iteratee));
+}
 function forIn(object, iteratee) {
   return object == null ? object : baseFor(object, castFunction(iteratee), keysIn);
 }
@@ -98,6 +504,9 @@ function baseHas(object, key) {
 function has(object, path) {
   return object != null && hasPath(object, path, baseHas);
 }
+function baseLt(value, other) {
+  return value < other;
+}
 function mapValues(object, iteratee) {
   var result = {};
   iteratee = baseIteratee(iteratee);
@@ -106,9 +515,25 @@ function mapValues(object, iteratee) {
   });
   return result;
 }
+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;
+}
 function max(array) {
   return array && array.length ? baseExtremum(array, identity, baseGt) : void 0;
 }
+var merge = createAssigner(function(object, source, srcIndex) {
+  baseMerge(object, source, srcIndex);
+});
+function min(array) {
+  return array && array.length ? baseExtremum(array, identity, baseLt) : void 0;
+}
 function minBy(array, iteratee) {
   return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseLt) : void 0;
 }
@@ -910,11 +1335,11 @@ function calcCutValue(t, g, child) {
   });
   return cutValue;
 }
-function initLowLimValues(tree, root) {
+function initLowLimValues(tree, root2) {
   if (arguments.length < 2) {
-    root = tree.nodes()[0];
+    root2 = tree.nodes()[0];
   }
-  dfsAssignLowLim(tree, {}, 1, root);
+  dfsAssignLowLim(tree, {}, 1, root2);
 }
 function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
   var low = nextLim;
@@ -971,10 +1396,10 @@ function exchangeEdges(t, g, e, f) {
   updateRanks(t, g);
 }
 function updateRanks(t, g) {
-  var root = find(t.nodes(), function(v) {
+  var root2 = find(t.nodes(), function(v) {
     return !g.node(v).parent;
   });
-  var vs = preorder(t, root);
+  var vs = preorder(t, root2);
   vs = vs.slice(1);
   forEach(vs, function(v) {
     var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
@@ -1015,25 +1440,25 @@ function networkSimplexRanker(g) {
   networkSimplex(g);
 }
 function run(g) {
-  var root = addDummyNode(g, "root", {}, "_root");
+  var root2 = addDummyNode(g, "root", {}, "_root");
   var depths = treeDepths(g);
   var height = max(values(depths)) - 1;
   var nodeSep = 2 * height + 1;
-  g.graph().nestingRoot = root;
+  g.graph().nestingRoot = root2;
   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);
+    dfs(g, root2, nodeSep, weight, height, depths, child);
   });
   g.graph().nodeRankFactor = nodeSep;
 }
-function dfs(g, root, nodeSep, weight, height, depths, v) {
+function dfs(g, root2, nodeSep, weight, height, depths, v) {
   var children = g.children(v);
   if (!children.length) {
-    if (v !== root) {
-      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
+    if (v !== root2) {
+      g.setEdge(root2, v, { weight: 0, minlen: nodeSep });
     }
     return;
   }
@@ -1045,7 +1470,7 @@ function dfs(g, root, nodeSep, weight, height, depths, v) {
   g.setParent(bottom, v);
   label.borderBottom = bottom;
   forEach(children, function(child) {
-    dfs(g, root, nodeSep, weight, height, depths, child);
+    dfs(g, root2, nodeSep, weight, height, depths, child);
     var childNode = g.node(child);
     var childTop = childNode.borderTop ? childNode.borderTop : child;
     var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
@@ -1063,7 +1488,7 @@ function dfs(g, root, nodeSep, weight, height, depths, v) {
     });
   });
   if (!g.parent(v)) {
-    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+    g.setEdge(root2, top, { weight: 0, minlen: height + depths[v] });
   }
 }
 function treeDepths(g) {
@@ -1124,14 +1549,14 @@ function addSubgraphConstraints(g, cg, vs) {
   });
 }
 function buildLayerGraph(g, rank2, relationship) {
-  var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel(function(v) {
+  var root2 = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root: root2 }).setDefaultNodeLabel(function(v) {
     return g.node(v);
   });
   forEach(g.nodes(), function(v) {
     var node = g.node(v), parent = g.parent(v);
     if (node.rank === rank2 || node.minRank <= rank2 && rank2 <= node.maxRank) {
       result.setNode(v);
-      result.setParent(v, parent || root);
+      result.setParent(v, parent || root2);
       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 });
@@ -1458,8 +1883,8 @@ function buildLayerGraphs(g, ranks, 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);
+    var root2 = lg.graph().root;
+    var sorted = sortSubgraph(lg, root2, cg, biasRight);
     forEach(sorted.vs, function(v, i) {
       lg.node(v).order = i;
     });
@@ -1632,10 +2057,10 @@ function hasConflict(conflicts, v, w) {
   return !!conflicts[v] && Object.prototype.hasOwnProperty.call(conflicts[v], w);
 }
 function verticalAlignment(g, layering, conflicts, neighborFn) {
-  var root = {}, align = {}, pos = {};
+  var root2 = {}, align = {}, pos = {};
   forEach(layering, function(layer) {
     forEach(layer, function(v, order2) {
-      root[v] = v;
+      root2[v] = v;
       align[v] = v;
       pos[v] = order2;
     });
@@ -1653,17 +2078,17 @@ function verticalAlignment(g, layering, conflicts, neighborFn) {
           var w = ws[i];
           if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
             align[w] = v;
-            align[v] = root[v] = root[w];
+            align[v] = root2[v] = root2[w];
             prevIdx = pos[w];
           }
         }
       }
     });
   });
-  return { root, align };
+  return { root: root2, align };
 }
-function horizontalCompaction(g, layering, root, align, reverseSep) {
-  var xs = {}, blockG = buildBlockGraph(g, layering, root, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
+function horizontalCompaction(g, layering, root2, align, reverseSep) {
+  var xs = {}, blockG = buildBlockGraph(g, layering, root2, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
   function iterate(setXsFunc, nextNodesFunc) {
     var stack = blockG.nodes();
     var elem = stack.pop();
@@ -1696,19 +2121,19 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
   iterate(pass1, blockG.predecessors.bind(blockG));
   iterate(pass2, blockG.successors.bind(blockG));
   forEach(align, function(v) {
-    xs[v] = xs[root[v]];
+    xs[v] = xs[root2[v]];
   });
   return xs;
 }
-function buildBlockGraph(g, layering, root, reverseSep) {
+function buildBlockGraph(g, layering, root2, 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];
+      var vRoot = root2[v];
       blockGraph.setNode(vRoot);
       if (u) {
-        var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
+        var uRoot = root2[u], prevMax = blockGraph.edge(uRoot, vRoot);
         blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
       }
       u = v;
@@ -2179,5 +2604,7 @@ function canonicalize(attrs) {
   return newAttrs;
 }
 export {
-  layout as l
+  baseClone as b,
+  layout as l,
+  map as m
 };

package/out/renderer/assets/{mindmap-definition-QFDTVHPH-D9cyK1Gb.js → mindmap-definition-RKZ34NQL-yIrV1m0y.js}

@@ -1,6 +1,6 @@
-import { g as getDiagramElement } from "./chunk-55IACEB6-pFPEMTmI.js";
-import { s as setupViewPortForSVG } from "./chunk-EDXVE4YY-DRk838hn.js";
-import { _ as __name, l as log, o as getRegisteredLayoutAlgorithm, r as render, D as getConfig, G as defaultConfig_default, c as getConfig2, i as sanitizeText, ai as getUserDefinedConfig, aj as v4, Y as isDark, $ as lighten, a0 as darken } from "./index-D7Xi0GX5.js";
+import { g as getDiagramElement } from "./chunk-55IACEB6-DyyQMIZa.js";
+import { s as setupViewPortForSVG } from "./chunk-2J33WTMH-Dzi-idRV.js";
+import { _ as __name, l as log, o as getRegisteredLayoutAlgorithm, r as render, D as getConfig, G as defaultConfig_default, c as getConfig2, i as sanitizeText, ai as getUserDefinedConfig, aj as v4, Y as isDark, $ as lighten, a0 as darken } from "./index-3bI-dJm8.js";
 var parser = (function() {
   var o = /* @__PURE__ */ __name(function(k, v, o2, l) {
     for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v) ;

package/out/renderer/assets/{pieDiagram-DEJITSTG-LUWwVJA5.js → pieDiagram-4H26LBE5-PV9y5rw_.js}

@@ -1,9 +1,7 @@
-import { ae as constant, a6 as tau, aI as array, g as getAccDescription, s as setAccDescription, a as getAccTitle, b as setAccTitle, q as getDiagramTitle, p as setDiagramTitle, _ as __name, l as log, c as getConfig2$1, F as cleanAndMerge, I as selectSvgElement, R as parseFontSize, aJ as ordinal, e as configureSvgSize, z as clear, G as defaultConfig_default } from "./index-D7Xi0GX5.js";
-import { p as populateCommonDb } from "./chunk-4BX2VUAB-DQjg_Naa.js";
-import { p as parse } from "./wardley-RL74JXVD-Kh6mNiRV.js";
-import { d as d3arc } from "./arc-TuVjX2tH.js";
-import "./min-D6g96v7R.js";
-import "./_baseUniq-B7TxjYgy.js";
+import { ae as constant, a6 as tau, b6 as array, g as getAccDescription, s as setAccDescription, a as getAccTitle, b as setAccTitle, q as getDiagramTitle, p as setDiagramTitle, _ as __name, l as log, c as getConfig2$1, F as cleanAndMerge, I as selectSvgElement, R as parseFontSize, b7 as ordinal, e as configureSvgSize, z as clear, G as defaultConfig_default } from "./index-3bI-dJm8.js";
+import { p as populateCommonDb } from "./chunk-4BX2VUAB-DEyFpixF.js";
+import { p as parse } from "./wardley-L42UT6IY-BiqfHMim.js";
+import { d as d3arc } from "./arc-BXuUWHai.js";
 function descending(a, b) {
   return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
 }