n8n-editor-ui 1.81.2 → 1.82.0

package/dist/assets/{useCanvasMapping-B2Rx4tNy.js → useCanvasMapping-Hz5gCELZ.js}

@@ -1,7 +1,7 @@
-import { f4 as effectScope, I as watch, d as defineComponent, br as toRef, c as openBlock, h as createElementBlock, e as createBlock, v as renderSlot, f5 as Teleport, f6 as useSlots, b4 as onUnmounted, i as createVNode, w as withCtx, l as unref, r as ref, z as nextTick, q as computed, aw as onBeforeMount, cs as getCurrentInstance, bt as reactive, o as onMounted, n as normalizeClass, j as createBaseVNode, t as toDisplayString, f as createCommentVNode, F as Fragment, B as renderList, C as normalizeStyle, y as onBeforeUnmount, f7 as isMemoSame, bq as provide, aX as isRef, aY as toRefs$1, f8 as customRef, f9 as toValue$1, fa as useAttrs, a$ as mergeProps, aW as inject, fb as getCurrentScope, fc as onScopeDispose, fd as createPropsRestProxy, b0 as resolveDynamicComponent, k as createTextVNode, m as resolveComponent, ap as h, fe as readonly, ff as markRaw, bs as KeyboardShortcutTooltip, g as useI18n, bh as NodeConnectionType, fg as CanvasKey, ab as useCssModule, _ as _export_sfc$1, bn as watchEffect, aZ as normalizeProps, fh as refThrottled, fi as CanvasNodeKey, bK as CanvasConnectionMode, bN as CanvasNodeRenderType, fj as mergeModels, fk as useModel, bp as useNodeHelpers, fl as TitledList, ad as nodeViewEventBus, J as withModifiers, bJ as NODE_CREATOR_OPEN_SOURCES, fm as CanvasNodeHandleKey, ax as withDirectives, ay as vShow, fn as Transition$2, L as useUIStore, bo as useNodeTypesStore, U as useWorkflowsStore, a1 as useSourceControlStore, am as getResourcePermissions, f3 as isPresent, fo as getMousePosition$1, aB as STICKY_NODE_TYPE, fp as NOT_DUPLICATABLE_NODE_TYPES, b as useRouter, b7 as CHAT_TRIGGER_NODE_TYPE, cB as _sfc_main$y, D as createEventBus, fq as isEqual, bL as isValidNodeConnectionType, fr as onKeyDown, fs as onKeyUp, ft as useActiveElement, fu as useDeviceSupport, fv as useEventListener$1, G as onClickOutside, fw as N8nActionDropdown, aS as createSlots, eU as GRID_SIZE, fx as useThrottleFn, a_ as guardReactiveProps, bD as Suspense, eO as CUSTOM_API_CALL_KEY, be as getNodeInputs, bg as getNodeOutputs, dd as getTriggerNodeServiceName, bY as sanitizeHtml, fy as nodeIssuesToString, fz as WAIT_NODE_TYPE, dY as SEND_AND_WAIT_OPERATION, fA as FORM_NODE_TYPE, fB as WAIT_INDEFINITELY } from "./index-C06tkpld.js";
-import { p as parseCanvasConnectionHandleString, u as useNodeCreatorStore, a as useCanvasOperations, c as createCanvasConnectionHandleString, i as insertSpacersBetweenEndpoints, m as mapLegacyEndpointsToCanvasConnectionPort, b as checkOverlap, d as mapLegacyConnectionsToCanvasConnections } from "./useCanvasOperations-C-zV2Jxd.js";
-import { u as usePinnedData } from "./usePinnedData-Hq06xPoo.js";
-import { u as useRunWorkflow } from "./useRunWorkflow-BJon34Vp.js";
+import { f8 as effectScope, I as watch, d as defineComponent, bs as toRef, c as openBlock, h as createElementBlock, e as createBlock, v as renderSlot, f9 as Teleport, fa as useSlots, b5 as onUnmounted, i as createVNode, w as withCtx, l as unref, r as ref, z as nextTick, q as computed, aw as onBeforeMount, cu as getCurrentInstance, bu as reactive, o as onMounted, n as normalizeClass, j as createBaseVNode, t as toDisplayString, f as createCommentVNode, F as Fragment, B as renderList, C as normalizeStyle, y as onBeforeUnmount, fb as isMemoSame, br as provide, aY as isRef, aZ as toRefs$1, fc as customRef, fd as toValue$1, fe as useAttrs, b0 as mergeProps, aX as inject, ff as getCurrentScope, fg as onScopeDispose, fh as createPropsRestProxy, b1 as resolveDynamicComponent, k as createTextVNode, m as resolveComponent, ap as h, fi as readonly, fj as markRaw, _ as _export_sfc$1, bt as KeyboardShortcutTooltip, g as useI18n, bi as NodeConnectionType, fk as CanvasKey, ab as useCssModule, bo as watchEffect, a_ as normalizeProps, fl as refThrottled, fm as CanvasNodeKey, bL as CanvasConnectionMode, bO as CanvasNodeRenderType, fn as mergeModels, fo as useModel, bq as useNodeHelpers, fp as TitledList, aQ as N8nTooltip, dq as CanvasNodeDirtiness, J as withModifiers, ad as nodeViewEventBus, bK as NODE_CREATOR_OPEN_SOURCES, fq as CanvasNodeHandleKey, ax as withDirectives, ay as vShow, fr as Transition$2, L as useUIStore, bp as useNodeTypesStore, U as useWorkflowsStore, a1 as useSourceControlStore, am as getResourcePermissions, f7 as isPresent, fs as getMousePosition$1, aC as STICKY_NODE_TYPE, ft as NOT_DUPLICATABLE_NODE_TYPES, b as useRouter, b8 as CHAT_TRIGGER_NODE_TYPE, cD as _sfc_main$z, D as createEventBus, fu as isEqual, bM as isValidNodeConnectionType, fv as onKeyDown, fw as onKeyUp, fx as useActiveElement, fy as useDeviceSupport, fz as useEventListener$1, G as onClickOutside, fA as N8nActionDropdown, aT as createSlots, e_ as GRID_SIZE, fB as useThrottleFn, c1 as getDefaultExportFromCjs, eZ as NODE_SIZE, a$ as guardReactiveProps, bE as Suspense, eW as CUSTOM_API_CALL_KEY, bf as getNodeInputs, bh as getNodeOutputs, df as getTriggerNodeServiceName, bZ as sanitizeHtml, fC as nodeIssuesToString, fD as WAIT_NODE_TYPE, e4 as SEND_AND_WAIT_OPERATION, fE as FORM_NODE_TYPE, fF as WAIT_INDEFINITELY } from "./index-BGYw7Tle.js";
+import { p as parseCanvasConnectionHandleString, u as useNodeCreatorStore, a as useCanvasOperations, c as createCanvasConnectionHandleString, i as insertSpacersBetweenEndpoints, m as mapLegacyEndpointsToCanvasConnectionPort, b as checkOverlap, d as mapLegacyConnectionsToCanvasConnections } from "./useCanvasOperations-DvuQ2UqW.js";
+import { u as usePinnedData } from "./usePinnedData-DEotvVuQ.js";
+import { u as useRunWorkflow, a as useNodeDirtiness } from "./useRunWorkflow-CPV3na7d.js";
 function tryOnScopeDispose(fn) {
   if (getCurrentScope()) {
     onScopeDispose(fn);
@@ -14,8 +14,8 @@ function toValue(r) {
 }
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
 const isDef$1 = (val) => typeof val !== "undefined";
-const toString = Object.prototype.toString;
-const isObject = (val) => toString.call(val) === "[object Object]";
+const toString$1 = Object.prototype.toString;
+const isObject = (val) => toString$1.call(val) === "[object Object]";
 const noop$2 = () => {
 };
 function createFilterWrapper(filter2, fn) {
@@ -943,14 +943,14 @@ ClassList$2.prototype = {
   }
 };
 function classedAdd$2(node2, names) {
-  var list = classList$2(node2), i = -1, n = names.length;
+  var list2 = classList$2(node2), i = -1, n = names.length;
   while (++i < n)
-    list.add(names[i]);
+    list2.add(names[i]);
 }
 function classedRemove$2(node2, names) {
-  var list = classList$2(node2), i = -1, n = names.length;
+  var list2 = classList$2(node2), i = -1, n = names.length;
   while (++i < n)
-    list.remove(names[i]);
+    list2.remove(names[i]);
 }
 function classedTrue$2(names) {
   return function() {
@@ -970,9 +970,9 @@ function classedFunction$2(names, value) {
 function selection_classed$2(name, value) {
   var names = classArray$2(name + "");
   if (arguments.length < 2) {
-    var list = classList$2(this.node()), i = -1, n = names.length;
+    var list2 = classList$2(this.node()), i = -1, n = names.length;
     while (++i < n)
-      if (!list.contains(names[i]))
+      if (!list2.contains(names[i]))
         return false;
     return true;
   }
@@ -4320,15 +4320,15 @@ function isValidHandle(event, {
   fromHandleId,
   fromType,
   doc,
-  lib,
+  lib: lib2,
   flowId,
   isValidConnection = alwaysValid$1
 }, edges, nodes, findNode) {
   const isTarget = fromType === "target";
-  const handleDomNode = handle2 ? doc.querySelector(`.${lib}-flow__handle[data-id="${flowId}-${handle2 == null ? void 0 : handle2.nodeId}-${handle2 == null ? void 0 : handle2.id}-${handle2 == null ? void 0 : handle2.type}"]`) : null;
+  const handleDomNode = handle2 ? doc.querySelector(`.${lib2}-flow__handle[data-id="${flowId}-${handle2 == null ? void 0 : handle2.nodeId}-${handle2 == null ? void 0 : handle2.id}-${handle2 == null ? void 0 : handle2.type}"]`) : null;
   const { x, y } = getEventPosition(event);
   const handleBelow = doc.elementFromPoint(x, y);
-  const handleToCheck = (handleBelow == null ? void 0 : handleBelow.classList.contains(`${lib}-flow__handle`)) ? handleBelow : handleDomNode;
+  const handleToCheck = (handleBelow == null ? void 0 : handleBelow.classList.contains(`${lib2}-flow__handle`)) ? handleBelow : handleDomNode;
   const result = {
     handleDomNode: handleToCheck,
     isValid: false,
@@ -9456,7 +9456,7 @@ function useStylesLoadedWarning() {
     }
   });
 }
-const _hoisted_1$c = /* @__PURE__ */ createBaseVNode("div", { class: "vue-flow__edge-labels" }, null, -1);
+const _hoisted_1$d = /* @__PURE__ */ createBaseVNode("div", { class: "vue-flow__edge-labels" }, null, -1);
 const __default__$1$2 = {
   name: "VueFlow",
   compatConfig: { MODE: 3 }
@@ -9549,7 +9549,7 @@ const _sfc_main$1$4 = /* @__PURE__ */ defineComponent({
         createVNode(_sfc_main$8$1, null, {
           default: withCtx(() => [
             createVNode(_sfc_main$4$1),
-            _hoisted_1$c,
+            _hoisted_1$d,
             createVNode(_sfc_main$2$1),
             renderSlot(_ctx.$slots, "zoom-pane")
           ]),
@@ -9565,7 +9565,7 @@ const __default__$g = {
   name: "Panel",
   compatConfig: { MODE: 3 }
 };
-const _sfc_main$x = /* @__PURE__ */ defineComponent({
+const _sfc_main$y = /* @__PURE__ */ defineComponent({
   ...__default__$g,
   props: {
     position: {}
@@ -9596,12 +9596,12 @@ const _export_sfc = (sfc, props) => {
   return target2;
 };
 const _hoisted_1$5$1 = { class: "vue-flow__controls-button" };
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
   return openBlock(), createElementBlock("button", _hoisted_1$5$1, [
     renderSlot(_ctx.$slots, "default")
   ]);
 }
-const ControlButton = /* @__PURE__ */ _export_sfc(_sfc_main$1$3, [["render", _sfc_render]]);
+const ControlButton = /* @__PURE__ */ _export_sfc(_sfc_main$1$3, [["render", _sfc_render$1]]);
 const _hoisted_1$4$1 = {
   xmlns: "http://www.w3.org/2000/svg",
   viewBox: "0 0 32 32"
@@ -9650,7 +9650,7 @@ function render$1(_ctx, _cache) {
   return openBlock(), createElementBlock("svg", _hoisted_1$1$2, _hoisted_3$1$1);
 }
 const Lock = { render: render$1 };
-const _hoisted_1$b = {
+const _hoisted_1$c = {
   xmlns: "http://www.w3.org/2000/svg",
   viewBox: "0 0 25 32"
 };
@@ -9659,14 +9659,14 @@ const _hoisted_3$5 = [
   _hoisted_2$7
 ];
 function render(_ctx, _cache) {
-  return openBlock(), createElementBlock("svg", _hoisted_1$b, _hoisted_3$5);
+  return openBlock(), createElementBlock("svg", _hoisted_1$c, _hoisted_3$5);
 }
 const Unlock = { render };
 const __default__$4 = {
   name: "Controls",
   compatConfig: { MODE: 3 }
 };
-const _sfc_main$w = /* @__PURE__ */ defineComponent({
+const _sfc_main$x = /* @__PURE__ */ defineComponent({
   ...__default__$4,
   props: {
     showZoom: { type: Boolean, default: true },
@@ -9709,7 +9709,7 @@ const _sfc_main$w = /* @__PURE__ */ defineComponent({
       emit("interactionChange", !isInteractive.value);
     }
     return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(_sfc_main$x), {
+      return openBlock(), createBlock(unref(_sfc_main$y), {
         class: "vue-flow__controls",
         position: _ctx.position
       }, {
@@ -9782,12 +9782,26 @@ const _sfc_main$w = /* @__PURE__ */ defineComponent({
     };
   }
 });
+const _sfc_main$w = {};
+const _hoisted_1$b = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 16 16"
+};
+function _sfc_render(_ctx, _cache) {
+  return openBlock(), createElementBlock("svg", _hoisted_1$b, _cache[0] || (_cache[0] = [
+    createBaseVNode("path", {
+      fill: "currentColor",
+      d: "M1.6.13c-.18-.17-.47-.18-.62 0L.56.57.14.98c-.2.15-.18.44 0 .62l3.63 3.6c.1.1.1.27 0 .37-.2.2-.53.52-.93.94-.56.57-.12 1.62.22 2.11.05.07.12.1.2.1.05-.01.1-.04.15-.08l5.23-5.22c.1-.1.1-.26-.02-.34-.5-.34-1.55-.78-2.12-.22-.42.4-.75.73-.94.93-.1.1-.27.1-.37 0L1.6.13ZM9.5 3.9c.07-.09.2-.1.3-.04l6.07 3.44c.15.08.18.29.05.4l-1.21 1.22a.26.26 0 0 1-.26.07l-2.18-.64a.26.26 0 0 0-.32.33l.76 2.02c.04.1.01.2-.06.27L7.7 15.92a.26.26 0 0 1-.41-.05L3.83 9.8a.26.26 0 0 1 .04-.3l5.62-5.6Z"
+    }, null, -1)
+  ]));
+}
+const TidyUpIcon = /* @__PURE__ */ _export_sfc$1(_sfc_main$w, [["render", _sfc_render]]);
 const _sfc_main$v = /* @__PURE__ */ defineComponent({
   __name: "CanvasControlButtons",
   props: {
     zoom: { default: 1 }
   },
-  emits: ["reset-zoom", "zoom-in", "zoom-out", "zoom-to-fit"],
+  emits: ["reset-zoom", "zoom-in", "zoom-out", "zoom-to-fit", "tidy-up"],
   setup(__props, { emit: __emit }) {
     const props = __props;
     const emit = __emit;
@@ -9805,9 +9819,13 @@ const _sfc_main$v = /* @__PURE__ */ defineComponent({
     function onZoomToFit() {
       emit("zoom-to-fit");
     }
+    function onTidyUp() {
+      emit("tidy-up");
+    }
     return (_ctx, _cache) => {
       const _component_N8nIconButton = resolveComponent("N8nIconButton");
-      return openBlock(), createBlock(unref(_sfc_main$w), {
+      const _component_N8nButton = resolveComponent("N8nButton");
+      return openBlock(), createBlock(unref(_sfc_main$x), {
         "show-zoom": false,
         "show-fit-view": false
       }, {
@@ -9872,13 +9890,42 @@ const _sfc_main$v = /* @__PURE__ */ defineComponent({
               })
             ]),
             _: 1
-          }, 8, ["label"])) : createCommentVNode("", true)
+          }, 8, ["label"])) : createCommentVNode("", true),
+          createVNode(KeyboardShortcutTooltip, {
+            label: unref(i18n).baseText("nodeView.tidyUp"),
+            shortcut: { shiftKey: true, altKey: true, keys: ["T"] }
+          }, {
+            default: withCtx(() => [
+              createVNode(_component_N8nButton, {
+                square: "",
+                type: "tertiary",
+                size: "large",
+                "data-test-id": "tidy-up-button",
+                class: normalizeClass(_ctx.$style.iconButton),
+                onClick: onTidyUp
+              }, {
+                default: withCtx(() => [
+                  createVNode(TidyUpIcon)
+                ]),
+                _: 1
+              }, 8, ["class"])
+            ]),
+            _: 1
+          }, 8, ["label"])
         ]),
         _: 1
       });
     };
   }
 });
+const iconButton = "_iconButton_kehsi_123";
+const style0$o = {
+  iconButton
+};
+const cssModules$o = {
+  "$style": style0$o
+};
+const __unplugin_components_1$1 = /* @__PURE__ */ _export_sfc$1(_sfc_main$v, [["__cssModules", cssModules$o]]);
 const EDGE_PADDING_BOTTOM = 130;
 const EDGE_PADDING_X = 40;
 const EDGE_BORDER_RADIUS = 16;
@@ -10515,12 +10562,12 @@ ClassList$1.prototype = {
   }
 };
 function classedAdd$1(node2, names) {
-  var list = classList$1(node2), i = -1, n = names.length;
-  while (++i < n) list.add(names[i]);
+  var list2 = classList$1(node2), i = -1, n = names.length;
+  while (++i < n) list2.add(names[i]);
 }
 function classedRemove$1(node2, names) {
-  var list = classList$1(node2), i = -1, n = names.length;
-  while (++i < n) list.remove(names[i]);
+  var list2 = classList$1(node2), i = -1, n = names.length;
+  while (++i < n) list2.remove(names[i]);
 }
 function classedTrue$1(names) {
   return function() {
@@ -10540,8 +10587,8 @@ function classedFunction$1(names, value) {
 function selection_classed$1(name, value) {
   var names = classArray$1(name + "");
   if (arguments.length < 2) {
-    var list = classList$1(this.node()), i = -1, n = names.length;
-    while (++i < n) if (!list.contains(names[i])) return false;
+    var list2 = classList$1(this.node()), i = -1, n = names.length;
+    while (++i < n) if (!list2.contains(names[i])) return false;
     return true;
   }
   return this.each((typeof value === "function" ? classedFunction$1 : value ? classedTrue$1 : classedFalse$1)(names, value));
@@ -12721,7 +12768,7 @@ const _sfc_main$t = /* @__PURE__ */ defineComponent({
       emit("nodeMouseleave", param);
     }
     return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(_sfc_main$x), {
+      return openBlock(), createBlock(unref(_sfc_main$y), {
         position: _ctx.position,
         class: normalizeClass(["vue-flow__minimap", { pannable: _ctx.pannable, zoomable: _ctx.zoomable }])
       }, {
@@ -13102,11 +13149,12 @@ const _sfc_main$q = /* @__PURE__ */ defineComponent({
   __name: "CanvasNodeDisabledStrikeThrough",
   setup(__props) {
     const $style = useCssModule();
-    const { hasRunData } = useCanvasNode();
+    const { hasRunData, render: render2 } = useCanvasNode();
     const classes = computed(() => {
       return {
         [$style.disabledStrikeThrough]: true,
-        [$style.success]: hasRunData.value
+        [$style.success]: hasRunData.value,
+        [$style.warning]: render2.value.type === CanvasNodeRenderType.Default && render2.value.options.dirtiness !== void 0
       };
     });
     return (_ctx, _cache) => {
@@ -13116,11 +13164,13 @@ const _sfc_main$q = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const disabledStrikeThrough = "_disabledStrikeThrough_nt80z_123";
-const success$2 = "_success_nt80z_132";
+const disabledStrikeThrough = "_disabledStrikeThrough_nl2g7_123";
+const success$2 = "_success_nl2g7_132";
+const warning$2 = "_warning_nl2g7_136";
 const style0$k = {
   disabledStrikeThrough,
-  success: success$2
+  success: success$2,
+  warning: warning$2
 };
 const cssModules$k = {
   "$style": style0$k
@@ -13129,6 +13179,7 @@ const __unplugin_components_2 = /* @__PURE__ */ _export_sfc$1(_sfc_main$q, [["__
 const _hoisted_1$8 = { key: 1 };
 const _hoisted_2$4 = ["textContent"];
 const _hoisted_3$2 = { key: 3 };
+const _hoisted_4$1 = { key: 5 };
 const _sfc_main$p = /* @__PURE__ */ defineComponent({
   __name: "CanvasNodeStatusIcons",
   setup(__props) {
@@ -13143,18 +13194,21 @@ const _sfc_main$p = /* @__PURE__ */ defineComponent({
       executionRunningThrottled,
       hasRunData,
       runDataIterations,
-      isDisabled
+      isDisabled,
+      render: render2
     } = useCanvasNode();
     const hideNodeIssues = computed(() => false);
+    const dirtiness = computed(
+      () => render2.value.type === CanvasNodeRenderType.Default ? render2.value.options.dirtiness : void 0
+    );
     return (_ctx, _cache) => {
       const _component_FontAwesomeIcon = resolveComponent("FontAwesomeIcon");
-      const _component_N8nTooltip = resolveComponent("N8nTooltip");
       return unref(hasIssues) && !hideNodeIssues.value ? (openBlock(), createElementBlock("div", {
         key: 0,
         class: normalizeClass([_ctx.$style.status, _ctx.$style.issues]),
         "data-test-id": "node-issues"
       }, [
-        createVNode(_component_N8nTooltip, {
+        createVNode(unref(N8nTooltip), {
           "show-after": 500,
           placement: "bottom"
         }, {
@@ -13173,7 +13227,7 @@ const _sfc_main$p = /* @__PURE__ */ defineComponent({
         createBaseVNode("div", {
           class: normalizeClass([_ctx.$style.status, _ctx.$style.waiting])
         }, [
-          createVNode(_component_N8nTooltip, { placement: "bottom" }, {
+          createVNode(unref(N8nTooltip), { placement: "bottom" }, {
             content: withCtx(() => [
               createBaseVNode("div", {
                 textContent: toDisplayString(unref(executionWaiting))
@@ -13208,8 +13262,32 @@ const _sfc_main$p = /* @__PURE__ */ defineComponent({
           icon: "sync-alt",
           spin: ""
         })
-      ], 2)) : unref(hasRunData) ? (openBlock(), createElementBlock("div", {
-        key: 5,
+      ], 2)) : dirtiness.value !== void 0 ? (openBlock(), createElementBlock("div", _hoisted_4$1, [
+        createVNode(unref(N8nTooltip), {
+          "show-after": 500,
+          placement: "bottom"
+        }, {
+          content: withCtx(() => [
+            createTextVNode(toDisplayString(unref(i18n).baseText(
+              dirtiness.value === unref(CanvasNodeDirtiness).PARAMETERS_UPDATED ? "node.dirty" : "node.subjectToChange"
+            )), 1)
+          ]),
+          default: withCtx(() => [
+            createBaseVNode("div", {
+              "data-test-id": "canvas-node-status-warning",
+              class: normalizeClass([_ctx.$style.status, _ctx.$style.warning])
+            }, [
+              createVNode(_component_FontAwesomeIcon, { icon: "triangle" }),
+              unref(runDataIterations) > 1 ? (openBlock(), createElementBlock("span", {
+                key: 0,
+                class: normalizeClass(_ctx.$style.count)
+              }, toDisplayString(unref(runDataIterations)), 3)) : createCommentVNode("", true)
+            ], 2)
+          ]),
+          _: 1
+        })
+      ])) : unref(hasRunData) ? (openBlock(), createElementBlock("div", {
+        key: 6,
         "data-test-id": "canvas-node-status-success",
         class: normalizeClass([_ctx.$style.status, _ctx.$style.runData])
       }, [
@@ -13222,22 +13300,24 @@ const _sfc_main$p = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const status = "_status_f7q46_123";
-const runData = "_runData_f7q46_129";
-const waiting$1 = "_waiting_f7q46_134";
-const pinnedData = "_pinnedData_f7q46_138";
-const running$1 = "_running_f7q46_142";
-const issues = "_issues_f7q46_165";
-const count = "_count_f7q46_170";
+const status = "_status_1slg1_123";
+const runData = "_runData_1slg1_130";
+const waiting$1 = "_waiting_1slg1_134";
+const pinnedData = "_pinnedData_1slg1_138";
+const running$1 = "_running_1slg1_142";
+const issues = "_issues_1slg1_165";
+const count = "_count_1slg1_170";
+const warning$1 = "_warning_1slg1_174";
 const style0$j = {
   status,
   runData,
   waiting: waiting$1,
   pinnedData,
   running: running$1,
-  "node-waiting-spinner": "_node-waiting-spinner_f7q46_152",
+  "node-waiting-spinner": "_node-waiting-spinner_1slg1_152",
   issues,
-  count
+  count,
+  warning: warning$1
 };
 const cssModules$j = {
   "$style": style0$j
@@ -13341,13 +13421,14 @@ function useNodeConnections({
 const _hoisted_1$7 = ["data-test-id"];
 const _sfc_main$n = /* @__PURE__ */ defineComponent({
   __name: "CanvasNodeDefault",
-  emits: ["open:contextmenu"],
+  emits: ["open:contextmenu", "activate"],
   setup(__props, { emit: __emit }) {
     const $style = useCssModule();
     const i18n = useI18n();
     const emit = __emit;
     const { initialized, viewport } = useCanvas();
     const {
+      id: id2,
       label: label2,
       subtitle: subtitle2,
       inputs: inputs2,
@@ -13388,7 +13469,8 @@ const _sfc_main$n = /* @__PURE__ */ defineComponent({
         [$style.running]: executionRunning.value,
         [$style.configurable]: renderOptions.value.configurable,
         [$style.configuration]: renderOptions.value.configuration,
-        [$style.trigger]: renderOptions.value.trigger
+        [$style.trigger]: renderOptions.value.trigger,
+        [$style.warning]: renderOptions.value.dirtiness !== void 0
       };
     });
     const styles = computed(() => {
@@ -13432,6 +13514,9 @@ const _sfc_main$n = /* @__PURE__ */ defineComponent({
     function openContextMenu(event) {
       emit("open:contextmenu", event);
     }
+    function onActivate() {
+      emit("activate", id2.value);
+    }
     return (_ctx, _cache) => {
       const _component_CanvasNodeTooltip = __unplugin_components_0$4;
       const _component_CanvasNodeStatusIcons = __unplugin_components_1;
@@ -13440,7 +13525,8 @@ const _sfc_main$n = /* @__PURE__ */ defineComponent({
         class: normalizeClass(classes.value),
         style: normalizeStyle(styles.value),
         "data-test-id": dataTestId.value,
-        onContextmenu: openContextMenu
+        onContextmenu: openContextMenu,
+        onDblclick: withModifiers(onActivate, ["stop"])
       }, [
         renderOptions.value.tooltip ? (openBlock(), createBlock(_component_CanvasNodeTooltip, {
           key: 0,
@@ -13472,22 +13558,23 @@ const _sfc_main$n = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const node = "_node_uhfie_123";
-const trigger$1 = "_trigger_uhfie_155";
-const configuration = "_configuration_uhfie_158";
-const statusIcons = "_statusIcons_uhfie_165";
-const configurable = "_configurable_uhfie_168";
-const description = "_description_uhfie_179";
-const label$5 = "_label_uhfie_189";
-const subtitle = "_subtitle_uhfie_192";
-const selected$1 = "_selected_uhfie_202";
-const success$1 = "_success_uhfie_205";
-const error = "_error_uhfie_208";
-const pinned = "_pinned_uhfie_211";
-const disabled = "_disabled_uhfie_214";
-const running = "_running_uhfie_217";
-const waiting = "_waiting_uhfie_221";
-const disabledLabel = "_disabledLabel_uhfie_238";
+const node = "_node_1ektz_123";
+const trigger$1 = "_trigger_1ektz_155";
+const configuration = "_configuration_1ektz_158";
+const statusIcons = "_statusIcons_1ektz_165";
+const configurable = "_configurable_1ektz_168";
+const description = "_description_1ektz_179";
+const label$5 = "_label_1ektz_189";
+const subtitle = "_subtitle_1ektz_192";
+const selected$1 = "_selected_1ektz_202";
+const success$1 = "_success_1ektz_205";
+const warning = "_warning_1ektz_208";
+const error = "_error_1ektz_211";
+const pinned = "_pinned_1ektz_214";
+const disabled = "_disabled_1ektz_217";
+const running = "_running_1ektz_220";
+const waiting = "_waiting_1ektz_224";
+const disabledLabel = "_disabledLabel_1ektz_241";
 const style0$h = {
   node,
   trigger: trigger$1,
@@ -13499,6 +13586,7 @@ const style0$h = {
   subtitle,
   selected: selected$1,
   success: success$1,
+  warning,
   error,
   pinned,
   disabled,
@@ -13975,14 +14063,14 @@ ClassList.prototype = {
   }
 };
 function classedAdd(node2, names) {
-  var list = classList(node2), i = -1, n = names.length;
+  var list2 = classList(node2), i = -1, n = names.length;
   while (++i < n)
-    list.add(names[i]);
+    list2.add(names[i]);
 }
 function classedRemove(node2, names) {
-  var list = classList(node2), i = -1, n = names.length;
+  var list2 = classList(node2), i = -1, n = names.length;
   while (++i < n)
-    list.remove(names[i]);
+    list2.remove(names[i]);
 }
 function classedTrue(names) {
   return function() {
@@ -14002,9 +14090,9 @@ function classedFunction(names, value) {
 function selection_classed(name, value) {
   var names = classArray(name + "");
   if (arguments.length < 2) {
-    var list = classList(this.node()), i = -1, n = names.length;
+    var list2 = classList(this.node()), i = -1, n = names.length;
     while (++i < n)
-      if (!list.contains(names[i]))
+      if (!list2.contains(names[i]))
         return false;
     return true;
   }
@@ -14907,7 +14995,7 @@ const _sfc_main$l = /* @__PURE__ */ defineComponent({
     inheritAttrs: false
   },
   __name: "CanvasNodeStickyNote",
-  emits: ["update", "move", "dblclick", "open:contextmenu"],
+  emits: ["update", "move", "activate", "deactivate", "open:contextmenu"],
   setup(__props, { emit: __emit }) {
     const emit = __emit;
     const $style = useCssModule();
@@ -14935,23 +15023,26 @@ const _sfc_main$l = /* @__PURE__ */ defineComponent({
         content: value
       });
     }
-    function onEdit(edit) {
-      isActive.value = edit;
-    }
-    function onDoubleClick(event) {
-      emit("dblclick", event);
+    function onSetActive(value) {
+      if (isActive.value === value) return;
+      isActive.value = value;
+      if (value) {
+        emit("activate", id2.value);
+      } else {
+        emit("deactivate", id2.value);
+      }
     }
     function onActivate() {
-      onEdit(true);
+      onSetActive(true);
     }
     function openContextMenu(event) {
       emit("open:contextmenu", event);
     }
     onMounted(() => {
-      eventBus.value?.on("update:node:active", onActivate);
+      eventBus.value?.on("update:node:activated", onActivate);
     });
     onBeforeUnmount(() => {
-      eventBus.value?.off("update:node:active", onActivate);
+      eventBus.value?.off("update:node:activated", onActivate);
     });
     return (_ctx, _cache) => {
       const _component_N8nSticky = resolveComponent("N8nSticky");
@@ -14974,8 +15065,8 @@ const _sfc_main$l = /* @__PURE__ */ defineComponent({
           "background-color": renderOptions.value.color,
           "edit-mode": isActive.value,
           "read-only": unref(isReadOnly),
-          onEdit,
-          onDblclick: onDoubleClick,
+          onEdit: onSetActive,
+          onDblclick: withModifiers(onActivate, ["stop"]),
           "onUpdate:modelValue": onInputChange,
           onContextmenu: openContextMenu
         }), null, 16, ["id", "class", "height", "width", "model-value", "background-color", "edit-mode", "read-only"])
@@ -15432,12 +15523,12 @@ const _sfc_main$e = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const handle$3 = "_handle_19arw_123";
-const connected = "_connected_19arw_129";
-const label$2 = "_label_19arw_129";
-const required$2 = "_required_19arw_143";
-const outputLabel = "_outputLabel_19arw_148";
-const runDataLabel = "_runDataLabel_19arw_156";
+const handle$3 = "_handle_1u904_123";
+const connected = "_connected_1u904_129";
+const label$2 = "_label_1u904_129";
+const required$2 = "_required_1u904_143";
+const outputLabel = "_outputLabel_1u904_148";
+const runDataLabel = "_runDataLabel_1u904_156";
 const style0$a = {
   handle: handle$3,
   connected,
@@ -15793,6 +15884,16 @@ const useContextMenu = (onAction = () => {
         disabled: nodes.length === 0
       }
     ];
+    const layoutActions = [
+      {
+        id: "tidy_up",
+        divided: true,
+        label: i18n.baseText(
+          nodes.length < 2 ? "contextMenu.tidyUpWorkflow" : "contextMenu.tidyUpSelection"
+        ),
+        shortcut: { shiftKey: true, altKey: true, keys: ["T"] }
+      }
+    ];
     if (nodes.length === 0) {
       actions.value = [
         {
@@ -15807,6 +15908,7 @@ const useContextMenu = (onAction = () => {
           label: i18n.baseText("contextMenu.addSticky"),
           disabled: isReadOnly.value
         },
+        ...layoutActions,
         ...selectionActions
       ];
     } else {
@@ -15834,6 +15936,7 @@ const useContextMenu = (onAction = () => {
           shortcut: { metaKey: true, keys: ["D"] },
           disabled: isReadOnly.value || !nodes.every(canDuplicateNode)
         },
+        ...layoutActions,
         ...selectionActions,
         {
           id: "delete",
@@ -16011,7 +16114,7 @@ const _sfc_main$8 = /* @__PURE__ */ defineComponent({
     hovered: { type: Boolean },
     nearbyHovered: { type: Boolean }
   },
-  emits: ["add", "delete", "run", "select", "toggle", "activate", "open:contextmenu", "update", "update:inputs", "update:outputs", "move"],
+  emits: ["add", "delete", "run", "select", "toggle", "activate", "deactivate", "open:contextmenu", "update", "update:inputs", "update:outputs", "move"],
   setup(__props, { emit: __emit }) {
     const slots = useSlots();
     const emit = __emit;
@@ -16137,6 +16240,9 @@ const _sfc_main$8 = /* @__PURE__ */ defineComponent({
     function onActivate() {
       emit("activate", props.id);
     }
+    function onDeactivate() {
+      emit("deactivate", props.id);
+    }
     function onOpenContextMenuFromToolbar(event) {
       emit("open:contextmenu", props.id, event, "node-button");
     }
@@ -16247,13 +16353,14 @@ const _sfc_main$8 = /* @__PURE__ */ defineComponent({
           "onOpen:contextmenu": onOpenContextMenuFromToolbar
         }, null, 8, ["read-only", "class"])) : createCommentVNode("", true),
         createVNode(_sfc_main$j, {
-          onDblclick: withModifiers(onActivate, ["stop"]),
+          onActivate,
+          onDeactivate,
           onMove,
           onUpdate,
           "onOpen:contextmenu": onOpenContextMenuFromNode
         }, {
           default: withCtx(() => [
-            createVNode(_sfc_main$y, {
+            createVNode(_sfc_main$z, {
               "node-type": nodeTypeDescription.value,
               size: nodeIconSize.value,
               shrink: false,
@@ -16441,7 +16548,7 @@ const _sfc_main$6 = /* @__PURE__ */ defineComponent({
     }));
     const edgeLabelStyle = computed(() => ({
       transform: `translate(0, ${isConnectorStraight.value ? "-100%" : "0%"})`,
-      color: edgeColor.value
+      color: "var(--color-text-base)"
     }));
     const isConnectorStraight = computed(() => renderData.value.isConnectorStraight);
     const edgeToolbarStyle = computed(() => ({
@@ -17043,194 +17150,4042 @@ function useCanvasNodeHover(nodesRef, store, getHitBox) {
   });
   return { id: id2 };
 }
-const renameKeyCode = " ";
-const defaultZoom = 1;
-const minimapVisibilityDelay = 1e3;
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "Canvas",
-  props: {
-    id: { default: "canvas" },
-    nodes: { default: () => [] },
-    connections: { default: () => [] },
-    controlsPosition: { default: PanelPosition.BottomLeft },
-    eventBus: { default: () => createEventBus() },
-    readOnly: { type: Boolean, default: false },
-    executing: { type: Boolean, default: false },
-    keyBindings: { type: Boolean, default: true },
-    loading: { type: Boolean, default: false }
-  },
-  emits: ["update:modelValue", "update:node:position", "update:nodes:position", "update:node:active", "update:node:enabled", "update:node:selected", "update:node:name", "update:node:parameters", "update:node:inputs", "update:node:outputs", "click:node", "click:node:add", "run:node", "delete:node", "create:node", "create:sticky", "delete:nodes", "update:nodes:enabled", "copy:nodes", "duplicate:nodes", "update:nodes:pin", "cut:nodes", "delete:connection", "create:connection:start", "create:connection", "create:connection:end", "create:connection:cancelled", "click:connection:add", "click:pane", "run:workflow", "save:workflow", "create:workflow", "drag-and-drop"],
-  setup(__props, { emit: __emit }) {
-    const $style = useCssModule();
-    const emit = __emit;
-    const props = __props;
-    const { isMobileDevice, controlKeyCode } = useDeviceSupport();
-    const vueFlow = useVueFlow({ id: props.id, deleteKeyCode: null });
-    const {
-      getSelectedNodes: selectedNodes,
-      addSelectedNodes,
-      removeSelectedNodes,
-      viewportRef,
-      fitView,
-      zoomIn,
-      zoomOut,
-      zoomTo,
-      setInteractive,
-      elementsSelectable,
-      project,
-      nodes: graphNodes,
-      onPaneReady,
-      onNodesInitialized,
-      findNode,
-      viewport,
-      onEdgeMouseLeave,
-      onEdgeMouseEnter,
-      onEdgeMouseMove,
-      onNodeMouseEnter,
-      onNodeMouseLeave
-    } = vueFlow;
-    const {
-      getIncomingNodes,
-      getOutgoingNodes,
-      getSiblingNodes,
-      getDownstreamNodes,
-      getUpstreamNodes
-    } = useCanvasTraversal(vueFlow);
-    const isPaneReady = ref(false);
-    const classes = computed(() => ({
-      [$style.canvas]: true,
-      [$style.ready]: !props.loading && isPaneReady.value
-    }));
-    const panningKeyCode = ref(isMobileDevice ? true : [" ", controlKeyCode]);
-    const panningMouseButton = ref(isMobileDevice ? true : [1]);
-    const selectionKeyCode = ref(isMobileDevice ? "Shift" : true);
-    function switchToPanningMode() {
-      selectionKeyCode.value = null;
-      panningMouseButton.value = [0, 1];
+var graph;
+var hasRequiredGraph;
+function requireGraph() {
+  if (hasRequiredGraph) return graph;
+  hasRequiredGraph = 1;
+  var DEFAULT_EDGE_NAME = "\0";
+  var GRAPH_NODE = "\0";
+  var EDGE_KEY_DELIM = "
";
+  class Graph {
+    _isDirected = true;
+    _isMultigraph = false;
+    _isCompound = false;
+    // Label for the graph itself
+    _label;
+    // Defaults to be set when creating a new node
+    _defaultNodeLabelFn = () => void 0;
+    // Defaults to be set when creating a new edge
+    _defaultEdgeLabelFn = () => void 0;
+    // v -> label
+    _nodes = {};
+    // v -> edgeObj
+    _in = {};
+    // u -> v -> Number
+    _preds = {};
+    // v -> edgeObj
+    _out = {};
+    // v -> w -> Number
+    _sucs = {};
+    // e -> edgeObj
+    _edgeObjs = {};
+    // e -> label
+    _edgeLabels = {};
+    /* Number of nodes in the graph. Should only be changed by the implementation. */
+    _nodeCount = 0;
+    /* Number of edges in the graph. Should only be changed by the implementation. */
+    _edgeCount = 0;
+    _parent;
+    _children;
+    constructor(opts) {
+      if (opts) {
+        this._isDirected = Object.hasOwn(opts, "directed") ? opts.directed : true;
+        this._isMultigraph = Object.hasOwn(opts, "multigraph") ? opts.multigraph : false;
+        this._isCompound = Object.hasOwn(opts, "compound") ? opts.compound : false;
+      }
+      if (this._isCompound) {
+        this._parent = {};
+        this._children = {};
+        this._children[GRAPH_NODE] = {};
+      }
+    }
+    /* === Graph functions ========= */
+    /**
+     * Whether graph was created with 'directed' flag set to true or not.
+     */
+    isDirected() {
+      return this._isDirected;
+    }
+    /**
+     * Whether graph was created with 'multigraph' flag set to true or not.
+     */
+    isMultigraph() {
+      return this._isMultigraph;
+    }
+    /**
+     * Whether graph was created with 'compound' flag set to true or not.
+     */
+    isCompound() {
+      return this._isCompound;
+    }
+    /**
+     * Sets the label of the graph.
+     */
+    setGraph(label2) {
+      this._label = label2;
+      return this;
     }
-    function switchToSelectionMode() {
-      selectionKeyCode.value = true;
-      panningMouseButton.value = [1];
+    /**
+     * Gets the graph label.
+     */
+    graph() {
+      return this._label;
+    }
+    /* === Node functions ========== */
+    /**
+     * Sets the default node label. If newDefault is a function, it will be
+     * invoked ach time when setting a label for a node. Otherwise, this label
+     * will be assigned as default label in case if no label was specified while
+     * setting a node.
+     * Complexity: O(1).
+     */
+    setDefaultNodeLabel(newDefault) {
+      this._defaultNodeLabelFn = newDefault;
+      if (typeof newDefault !== "function") {
+        this._defaultNodeLabelFn = () => newDefault;
+      }
+      return this;
     }
-    onKeyDown(panningKeyCode.value, switchToPanningMode, {
-      dedupe: true
-    });
-    onKeyUp(panningKeyCode.value, switchToSelectionMode);
-    useShortKeyPress(
-      renameKeyCode,
-      () => {
-        if (lastSelectedNode.value) {
-          emit("update:node:name", lastSelectedNode.value.id);
+    /**
+     * Gets the number of nodes in the graph.
+     * Complexity: O(1).
+     */
+    nodeCount() {
+      return this._nodeCount;
+    }
+    /**
+     * Gets all nodes of the graph. Note, the in case of compound graph subnodes are
+     * not included in list.
+     * Complexity: O(1).
+     */
+    nodes() {
+      return Object.keys(this._nodes);
+    }
+    /**
+     * Gets list of nodes without in-edges.
+     * Complexity: O(|V|).
+     */
+    sources() {
+      var self = this;
+      return this.nodes().filter((v) => Object.keys(self._in[v]).length === 0);
+    }
+    /**
+     * Gets list of nodes without out-edges.
+     * Complexity: O(|V|).
+     */
+    sinks() {
+      var self = this;
+      return this.nodes().filter((v) => Object.keys(self._out[v]).length === 0);
+    }
+    /**
+     * Invokes setNode method for each node in names list.
+     * Complexity: O(|names|).
+     */
+    setNodes(vs, value) {
+      var args = arguments;
+      var self = this;
+      vs.forEach(function(v) {
+        if (args.length > 1) {
+          self.setNode(v, value);
+        } else {
+          self.setNode(v);
         }
-      },
-      {
-        disabled: toRef(props, "readOnly")
+      });
+      return this;
+    }
+    /**
+     * Creates or updates the value for the node v in the graph. If label is supplied
+     * it is set as the value for the node. If label is not supplied and the node was
+     * created by this call then the default node label will be assigned.
+     * Complexity: O(1).
+     */
+    setNode(v, value) {
+      if (Object.hasOwn(this._nodes, v)) {
+        if (arguments.length > 1) {
+          this._nodes[v] = value;
+        }
+        return this;
+      }
+      this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
+      if (this._isCompound) {
+        this._parent[v] = GRAPH_NODE;
+        this._children[v] = {};
+        this._children[GRAPH_NODE][v] = true;
+      }
+      this._in[v] = {};
+      this._preds[v] = {};
+      this._out[v] = {};
+      this._sucs[v] = {};
+      ++this._nodeCount;
+      return this;
+    }
+    /**
+     * Gets the label of node with specified name.
+     * Complexity: O(|V|).
+     */
+    node(v) {
+      return this._nodes[v];
+    }
+    /**
+     * Detects whether graph has a node with specified name or not.
+     */
+    hasNode(v) {
+      return Object.hasOwn(this._nodes, v);
+    }
+    /**
+     * Remove the node with the name from the graph or do nothing if the node is not in
+     * the graph. If the node was removed this function also removes any incident
+     * edges.
+     * Complexity: O(1).
+     */
+    removeNode(v) {
+      var self = this;
+      if (Object.hasOwn(this._nodes, v)) {
+        var removeEdge = (e) => self.removeEdge(self._edgeObjs[e]);
+        delete this._nodes[v];
+        if (this._isCompound) {
+          this._removeFromParentsChildList(v);
+          delete this._parent[v];
+          this.children(v).forEach(function(child) {
+            self.setParent(child);
+          });
+          delete this._children[v];
+        }
+        Object.keys(this._in[v]).forEach(removeEdge);
+        delete this._in[v];
+        delete this._preds[v];
+        Object.keys(this._out[v]).forEach(removeEdge);
+        delete this._out[v];
+        delete this._sucs[v];
+        --this._nodeCount;
       }
-    );
-    const disableKeyBindings = computed(() => !props.keyBindings);
-    function selectLeftNode(id2) {
-      const incomingNodes = getIncomingNodes(id2);
-      const previousNode = incomingNodes[0];
-      if (previousNode) {
-        onSelectNodes({ ids: [previousNode.id] });
+      return this;
+    }
+    /**
+     * Sets node p as a parent for node v if it is defined, or removes the
+     * parent for v if p is undefined. Method throws an exception in case of
+     * invoking it in context of noncompound graph.
+     * Average-case complexity: O(1).
+     */
+    setParent(v, parent) {
+      if (!this._isCompound) {
+        throw new Error("Cannot set parent in a non-compound graph");
+      }
+      if (parent === void 0) {
+        parent = GRAPH_NODE;
+      } else {
+        parent += "";
+        for (var ancestor = parent; ancestor !== void 0; ancestor = this.parent(ancestor)) {
+          if (ancestor === v) {
+            throw new Error("Setting " + parent + " as parent of " + v + " would create a cycle");
+          }
+        }
+        this.setNode(parent);
       }
+      this.setNode(v);
+      this._removeFromParentsChildList(v);
+      this._parent[v] = parent;
+      this._children[parent][v] = true;
+      return this;
     }
-    function selectRightNode(id2) {
-      const outgoingNodes = getOutgoingNodes(id2);
-      const nextNode = outgoingNodes[0];
-      if (nextNode) {
-        onSelectNodes({ ids: [nextNode.id] });
+    _removeFromParentsChildList(v) {
+      delete this._children[this._parent[v]][v];
+    }
+    /**
+     * Gets parent node for node v.
+     * Complexity: O(1).
+     */
+    parent(v) {
+      if (this._isCompound) {
+        var parent = this._parent[v];
+        if (parent !== GRAPH_NODE) {
+          return parent;
+        }
       }
     }
-    function selectLowerSiblingNode(id2) {
-      const siblingNodes = getSiblingNodes(id2);
-      const index = siblingNodes.findIndex((n) => n.id === id2);
-      const nextNode = siblingNodes[index + 1] ?? siblingNodes[0];
-      if (nextNode) {
-        onSelectNodes({
-          ids: [nextNode.id]
-        });
+    /**
+     * Gets list of direct children of node v.
+     * Complexity: O(1).
+     */
+    children(v = GRAPH_NODE) {
+      if (this._isCompound) {
+        var children2 = this._children[v];
+        if (children2) {
+          return Object.keys(children2);
+        }
+      } else if (v === GRAPH_NODE) {
+        return this.nodes();
+      } else if (this.hasNode(v)) {
+        return [];
+      }
+    }
+    /**
+     * Return all nodes that are predecessors of the specified node or undefined if node v is not in
+     * the graph. Behavior is undefined for undirected graphs - use neighbors instead.
+     * Complexity: O(|V|).
+     */
+    predecessors(v) {
+      var predsV = this._preds[v];
+      if (predsV) {
+        return Object.keys(predsV);
+      }
+    }
+    /**
+     * Return all nodes that are successors of the specified node or undefined if node v is not in
+     * the graph. Behavior is undefined for undirected graphs - use neighbors instead.
+     * Complexity: O(|V|).
+     */
+    successors(v) {
+      var sucsV = this._sucs[v];
+      if (sucsV) {
+        return Object.keys(sucsV);
+      }
+    }
+    /**
+     * Return all nodes that are predecessors or successors of the specified node or undefined if
+     * node v is not in the graph.
+     * Complexity: O(|V|).
+     */
+    neighbors(v) {
+      var preds = this.predecessors(v);
+      if (preds) {
+        const union = new Set(preds);
+        for (var succ of this.successors(v)) {
+          union.add(succ);
+        }
+        return Array.from(union.values());
       }
     }
-    function selectUpperSiblingNode(id2) {
-      const siblingNodes = getSiblingNodes(id2);
-      const index = siblingNodes.findIndex((n) => n.id === id2);
-      const previousNode = siblingNodes[index - 1] ?? siblingNodes[siblingNodes.length - 1];
-      if (previousNode) {
-        onSelectNodes({
-          ids: [previousNode.id]
-        });
+    isLeaf(v) {
+      var neighbors;
+      if (this.isDirected()) {
+        neighbors = this.successors(v);
+      } else {
+        neighbors = this.neighbors(v);
+      }
+      return neighbors.length === 0;
+    }
+    /**
+     * Creates new graph with nodes filtered via filter. Edges incident to rejected node
+     * are also removed. In case of compound graph, if parent is rejected by filter,
+     * than all its children are rejected too.
+     * Average-case complexity: O(|E|+|V|).
+     */
+    filterNodes(filter2) {
+      var copy = new this.constructor({
+        directed: this._isDirected,
+        multigraph: this._isMultigraph,
+        compound: this._isCompound
+      });
+      copy.setGraph(this.graph());
+      var self = this;
+      Object.entries(this._nodes).forEach(function([v, value]) {
+        if (filter2(v)) {
+          copy.setNode(v, value);
+        }
+      });
+      Object.values(this._edgeObjs).forEach(function(e) {
+        if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
+          copy.setEdge(e, self.edge(e));
+        }
+      });
+      var parents = {};
+      function findParent(v) {
+        var parent = self.parent(v);
+        if (parent === void 0 || copy.hasNode(parent)) {
+          parents[v] = parent;
+          return parent;
+        } else if (parent in parents) {
+          return parents[parent];
+        } else {
+          return findParent(parent);
+        }
+      }
+      if (this._isCompound) {
+        copy.nodes().forEach((v) => copy.setParent(v, findParent(v)));
       }
+      return copy;
     }
-    function selectDownstreamNodes(id2) {
-      const downstreamNodes = getDownstreamNodes(id2);
-      onSelectNodes({ ids: [...downstreamNodes.map((node2) => node2.id), id2] });
+    /* === Edge functions ========== */
+    /**
+     * Sets the default edge label or factory function. This label will be
+     * assigned as default label in case if no label was specified while setting
+     * an edge or this function will be invoked each time when setting an edge
+     * with no label specified and returned value * will be used as a label for edge.
+     * Complexity: O(1).
+     */
+    setDefaultEdgeLabel(newDefault) {
+      this._defaultEdgeLabelFn = newDefault;
+      if (typeof newDefault !== "function") {
+        this._defaultEdgeLabelFn = () => newDefault;
+      }
+      return this;
     }
-    function selectUpstreamNodes(id2) {
-      const upstreamNodes = getUpstreamNodes(id2);
-      onSelectNodes({ ids: [...upstreamNodes.map((node2) => node2.id), id2] });
+    /**
+     * Gets the number of edges in the graph.
+     * Complexity: O(1).
+     */
+    edgeCount() {
+      return this._edgeCount;
+    }
+    /**
+     * Gets edges of the graph. In case of compound graph subgraphs are not considered.
+     * Complexity: O(|E|).
+     */
+    edges() {
+      return Object.values(this._edgeObjs);
+    }
+    /**
+     * Establish an edges path over the nodes in nodes list. If some edge is already
+     * exists, it will update its label, otherwise it will create an edge between pair
+     * of nodes with label provided or default label if no label provided.
+     * Complexity: O(|nodes|).
+     */
+    setPath(vs, value) {
+      var self = this;
+      var args = arguments;
+      vs.reduce(function(v, w) {
+        if (args.length > 1) {
+          self.setEdge(v, w, value);
+        } else {
+          self.setEdge(v, w);
+        }
+        return w;
+      });
+      return this;
     }
-    const keyMap = computed(() => ({
-      ctrl_c: emitWithSelectedNodes((ids) => emit("copy:nodes", ids)),
-      enter: emitWithLastSelectedNode((id2) => onSetNodeActive(id2)),
-      ctrl_a: () => addSelectedNodes(graphNodes.value),
-      // Support both key and code for zooming in and out
-      "shift_+|+|=|shift_Equal|Equal": async () => await onZoomIn(),
-      "shift+_|-|_|shift_Minus|Minus": async () => await onZoomOut(),
-      0: async () => await onResetZoom(),
-      1: async () => await onFitView(),
-      ArrowUp: emitWithLastSelectedNode(selectUpperSiblingNode),
-      ArrowDown: emitWithLastSelectedNode(selectLowerSiblingNode),
-      ArrowLeft: emitWithLastSelectedNode(selectLeftNode),
-      ArrowRight: emitWithLastSelectedNode(selectRightNode),
-      shift_ArrowLeft: emitWithLastSelectedNode(selectUpstreamNodes),
-      shift_ArrowRight: emitWithLastSelectedNode(selectDownstreamNodes),
-      ...props.readOnly ? {} : {
-        ctrl_x: emitWithSelectedNodes((ids) => emit("cut:nodes", ids)),
-        "delete|backspace": emitWithSelectedNodes((ids) => emit("delete:nodes", ids)),
-        ctrl_d: emitWithSelectedNodes((ids) => emit("duplicate:nodes", ids)),
-        d: emitWithSelectedNodes((ids) => emit("update:nodes:enabled", ids)),
-        p: emitWithSelectedNodes((ids) => emit("update:nodes:pin", ids, "keyboard-shortcut")),
-        f2: emitWithLastSelectedNode((id2) => emit("update:node:name", id2)),
-        tab: () => emit("create:node", "tab"),
-        shift_s: () => emit("create:sticky"),
-        ctrl_alt_n: () => emit("create:workflow"),
-        ctrl_enter: () => emit("run:workflow"),
-        ctrl_s: () => emit("save:workflow")
+    /**
+     * Creates or updates the label for the edge (v, w) with the optionally supplied
+     * name. If label is supplied it is set as the value for the edge. If label is not
+     * supplied and the edge was created by this call then the default edge label will
+     * be assigned. The name parameter is only useful with multigraphs.
+     */
+    setEdge() {
+      var v, w, name, value;
+      var valueSpecified = false;
+      var arg0 = arguments[0];
+      if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) {
+        v = arg0.v;
+        w = arg0.w;
+        name = arg0.name;
+        if (arguments.length === 2) {
+          value = arguments[1];
+          valueSpecified = true;
+        }
+      } else {
+        v = arg0;
+        w = arguments[1];
+        name = arguments[3];
+        if (arguments.length > 2) {
+          value = arguments[2];
+          valueSpecified = true;
+        }
       }
-    }));
-    useKeybindings(keyMap, { disabled: disableKeyBindings });
-    const hasSelection = computed(() => selectedNodes.value.length > 0);
-    const selectedNodeIds = computed(() => selectedNodes.value.map((node2) => node2.id));
-    const lastSelectedNode = ref();
-    const triggerNodes = computed(
-      () => props.nodes.filter(
-        (node2) => node2.data?.render.type === CanvasNodeRenderType.Default && node2.data.render.options.trigger
-      )
-    );
-    const hoveredTriggerNode = useCanvasNodeHover(triggerNodes, vueFlow, (nodeRect) => ({
-      x: nodeRect.x - nodeRect.width * 2,
-      // should cover the width of trigger button
-      y: nodeRect.y - nodeRect.height,
-      width: nodeRect.width * 4,
-      height: nodeRect.height * 3
-    }));
-    watch(selectedNodes, (nodes) => {
-      if (!lastSelectedNode.value || !nodes.find((node2) => node2.id === lastSelectedNode.value?.id)) {
-        lastSelectedNode.value = nodes[nodes.length - 1];
+      v = "" + v;
+      w = "" + w;
+      if (name !== void 0) {
+        name = "" + name;
       }
-    });
-    function onClickNodeAdd(id2, handle2) {
-      emit("click:node:add", id2, handle2);
+      var e = edgeArgsToId(this._isDirected, v, w, name);
+      if (Object.hasOwn(this._edgeLabels, e)) {
+        if (valueSpecified) {
+          this._edgeLabels[e] = value;
+        }
+        return this;
+      }
+      if (name !== void 0 && !this._isMultigraph) {
+        throw new Error("Cannot set a named edge when isMultigraph = false");
+      }
+      this.setNode(v);
+      this.setNode(w);
+      this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
+      var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
+      v = edgeObj.v;
+      w = edgeObj.w;
+      Object.freeze(edgeObj);
+      this._edgeObjs[e] = edgeObj;
+      incrementOrInitEntry(this._preds[w], v);
+      incrementOrInitEntry(this._sucs[v], w);
+      this._in[w][e] = edgeObj;
+      this._out[v][e] = edgeObj;
+      this._edgeCount++;
+      return this;
     }
-    function onUpdateNodesPosition(events) {
-      emit("update:nodes:position", events);
+    /**
+     * Gets the label for the specified edge.
+     * Complexity: O(1).
+     */
+    edge(v, w, name) {
+      var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+      return this._edgeLabels[e];
+    }
+    /**
+     * Gets the label for the specified edge and converts it to an object.
+     * Complexity: O(1)
+     */
+    edgeAsObj() {
+      const edge2 = this.edge(...arguments);
+      if (typeof edge2 !== "object") {
+        return { label: edge2 };
+      }
+      return edge2;
+    }
+    /**
+     * Detects whether the graph contains specified edge or not. No subgraphs are considered.
+     * Complexity: O(1).
+     */
+    hasEdge(v, w, name) {
+      var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+      return Object.hasOwn(this._edgeLabels, e);
+    }
+    /**
+     * Removes the specified edge from the graph. No subgraphs are considered.
+     * Complexity: O(1).
+     */
+    removeEdge(v, w, name) {
+      var e = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v, w, name);
+      var edge2 = this._edgeObjs[e];
+      if (edge2) {
+        v = edge2.v;
+        w = edge2.w;
+        delete this._edgeLabels[e];
+        delete this._edgeObjs[e];
+        decrementOrRemoveEntry(this._preds[w], v);
+        decrementOrRemoveEntry(this._sucs[v], w);
+        delete this._in[w][e];
+        delete this._out[v][e];
+        this._edgeCount--;
+      }
+      return this;
     }
-    function onUpdateNodePosition(id2, position2) {
-      emit("update:node:position", id2, position2);
+    /**
+     * Return all edges that point to the node v. Optionally filters those edges down to just those
+     * coming from node u. Behavior is undefined for undirected graphs - use nodeEdges instead.
+     * Complexity: O(|E|).
+     */
+    inEdges(v, u) {
+      var inV = this._in[v];
+      if (inV) {
+        var edges = Object.values(inV);
+        if (!u) {
+          return edges;
+        }
+        return edges.filter((edge2) => edge2.v === u);
+      }
+    }
+    /**
+     * Return all edges that are pointed at by node v. Optionally filters those edges down to just
+     * those point to w. Behavior is undefined for undirected graphs - use nodeEdges instead.
+     * Complexity: O(|E|).
+     */
+    outEdges(v, w) {
+      var outV = this._out[v];
+      if (outV) {
+        var edges = Object.values(outV);
+        if (!w) {
+          return edges;
+        }
+        return edges.filter((edge2) => edge2.w === w);
+      }
     }
-    function onNodeDragStop(event) {
-      onUpdateNodesPosition(event.nodes.map(({ id: id2, position: position2 }) => ({ id: id2, position: position2 })));
+    /**
+     * Returns all edges to or from node v regardless of direction. Optionally filters those edges
+     * down to just those between nodes v and w regardless of direction.
+     * Complexity: O(|E|).
+     */
+    nodeEdges(v, w) {
+      var inEdges = this.inEdges(v, w);
+      if (inEdges) {
+        return inEdges.concat(this.outEdges(v, w));
+      }
+    }
+  }
+  function incrementOrInitEntry(map, k) {
+    if (map[k]) {
+      map[k]++;
+    } else {
+      map[k] = 1;
+    }
+  }
+  function decrementOrRemoveEntry(map, k) {
+    if (!--map[k]) {
+      delete map[k];
+    }
+  }
+  function edgeArgsToId(isDirected, v_, w_, name) {
+    var v = "" + v_;
+    var w = "" + w_;
+    if (!isDirected && v > w) {
+      var tmp = v;
+      v = w;
+      w = tmp;
+    }
+    return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (name === void 0 ? DEFAULT_EDGE_NAME : name);
+  }
+  function edgeArgsToObj(isDirected, v_, w_, name) {
+    var v = "" + v_;
+    var w = "" + w_;
+    if (!isDirected && v > w) {
+      var tmp = v;
+      v = w;
+      w = tmp;
+    }
+    var edgeObj = { v, w };
+    if (name) {
+      edgeObj.name = name;
+    }
+    return edgeObj;
+  }
+  function edgeObjToId(isDirected, edgeObj) {
+    return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
+  }
+  graph = Graph;
+  return graph;
+}
+var version$1;
+var hasRequiredVersion$1;
+function requireVersion$1() {
+  if (hasRequiredVersion$1) return version$1;
+  hasRequiredVersion$1 = 1;
+  version$1 = "2.2.4";
+  return version$1;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  lib = {
+    Graph: requireGraph(),
+    version: requireVersion$1()
+  };
+  return lib;
+}
+var json;
+var hasRequiredJson;
+function requireJson() {
+  if (hasRequiredJson) return json;
+  hasRequiredJson = 1;
+  var Graph = requireGraph();
+  json = {
+    write,
+    read
+  };
+  function write(g) {
+    var json2 = {
+      options: {
+        directed: g.isDirected(),
+        multigraph: g.isMultigraph(),
+        compound: g.isCompound()
+      },
+      nodes: writeNodes(g),
+      edges: writeEdges(g)
+    };
+    if (g.graph() !== void 0) {
+      json2.value = structuredClone(g.graph());
+    }
+    return json2;
+  }
+  function writeNodes(g) {
+    return g.nodes().map(function(v) {
+      var nodeValue = g.node(v);
+      var parent = g.parent(v);
+      var node2 = { v };
+      if (nodeValue !== void 0) {
+        node2.value = nodeValue;
+      }
+      if (parent !== void 0) {
+        node2.parent = parent;
+      }
+      return node2;
+    });
+  }
+  function writeEdges(g) {
+    return g.edges().map(function(e) {
+      var edgeValue = g.edge(e);
+      var edge2 = { v: e.v, w: e.w };
+      if (e.name !== void 0) {
+        edge2.name = e.name;
+      }
+      if (edgeValue !== void 0) {
+        edge2.value = edgeValue;
+      }
+      return edge2;
+    });
+  }
+  function read(json2) {
+    var g = new Graph(json2.options).setGraph(json2.value);
+    json2.nodes.forEach(function(entry) {
+      g.setNode(entry.v, entry.value);
+      if (entry.parent) {
+        g.setParent(entry.v, entry.parent);
+      }
+    });
+    json2.edges.forEach(function(entry) {
+      g.setEdge({ v: entry.v, w: entry.w, name: entry.name }, entry.value);
+    });
+    return g;
+  }
+  return json;
+}
+var components_1;
+var hasRequiredComponents;
+function requireComponents() {
+  if (hasRequiredComponents) return components_1;
+  hasRequiredComponents = 1;
+  components_1 = components;
+  function components(g) {
+    var visited = {};
+    var cmpts = [];
+    var cmpt;
+    function dfs(v) {
+      if (Object.hasOwn(visited, v)) return;
+      visited[v] = true;
+      cmpt.push(v);
+      g.successors(v).forEach(dfs);
+      g.predecessors(v).forEach(dfs);
+    }
+    g.nodes().forEach(function(v) {
+      cmpt = [];
+      dfs(v);
+      if (cmpt.length) {
+        cmpts.push(cmpt);
+      }
+    });
+    return cmpts;
+  }
+  return components_1;
+}
+var priorityQueue;
+var hasRequiredPriorityQueue;
+function requirePriorityQueue() {
+  if (hasRequiredPriorityQueue) return priorityQueue;
+  hasRequiredPriorityQueue = 1;
+  class PriorityQueue {
+    _arr = [];
+    _keyIndices = {};
+    /**
+     * Returns the number of elements in the queue. Takes `O(1)` time.
+     */
+    size() {
+      return this._arr.length;
+    }
+    /**
+     * Returns the keys that are in the queue. Takes `O(n)` time.
+     */
+    keys() {
+      return this._arr.map(function(x) {
+        return x.key;
+      });
+    }
+    /**
+     * Returns `true` if **key** is in the queue and `false` if not.
+     */
+    has(key) {
+      return Object.hasOwn(this._keyIndices, key);
+    }
+    /**
+     * Returns the priority for **key**. If **key** is not present in the queue
+     * then this function returns `undefined`. Takes `O(1)` time.
+     *
+     * @param {Object} key
+     */
+    priority(key) {
+      var index = this._keyIndices[key];
+      if (index !== void 0) {
+        return this._arr[index].priority;
+      }
+    }
+    /**
+     * Returns the key for the minimum element in this queue. If the queue is
+     * empty this function throws an Error. Takes `O(1)` time.
+     */
+    min() {
+      if (this.size() === 0) {
+        throw new Error("Queue underflow");
+      }
+      return this._arr[0].key;
+    }
+    /**
+     * Inserts a new key into the priority queue. If the key already exists in
+     * the queue this function returns `false`; otherwise it will return `true`.
+     * Takes `O(n)` time.
+     *
+     * @param {Object} key the key to add
+     * @param {Number} priority the initial priority for the key
+     */
+    add(key, priority) {
+      var keyIndices = this._keyIndices;
+      key = String(key);
+      if (!Object.hasOwn(keyIndices, key)) {
+        var arr = this._arr;
+        var index = arr.length;
+        keyIndices[key] = index;
+        arr.push({ key, priority });
+        this._decrease(index);
+        return true;
+      }
+      return false;
+    }
+    /**
+     * Removes and returns the smallest key in the queue. Takes `O(log n)` time.
+     */
+    removeMin() {
+      this._swap(0, this._arr.length - 1);
+      var min = this._arr.pop();
+      delete this._keyIndices[min.key];
+      this._heapify(0);
+      return min.key;
+    }
+    /**
+     * Decreases the priority for **key** to **priority**. If the new priority is
+     * greater than the previous priority, this function will throw an Error.
+     *
+     * @param {Object} key the key for which to raise priority
+     * @param {Number} priority the new priority for the key
+     */
+    decrease(key, priority) {
+      var index = this._keyIndices[key];
+      if (priority > this._arr[index].priority) {
+        throw new Error("New priority is greater than current priority. Key: " + key + " Old: " + this._arr[index].priority + " New: " + priority);
+      }
+      this._arr[index].priority = priority;
+      this._decrease(index);
+    }
+    _heapify(i) {
+      var arr = this._arr;
+      var l = 2 * i;
+      var r = l + 1;
+      var largest = i;
+      if (l < arr.length) {
+        largest = arr[l].priority < arr[largest].priority ? l : largest;
+        if (r < arr.length) {
+          largest = arr[r].priority < arr[largest].priority ? r : largest;
+        }
+        if (largest !== i) {
+          this._swap(i, largest);
+          this._heapify(largest);
+        }
+      }
+    }
+    _decrease(index) {
+      var arr = this._arr;
+      var priority = arr[index].priority;
+      var parent;
+      while (index !== 0) {
+        parent = index >> 1;
+        if (arr[parent].priority < priority) {
+          break;
+        }
+        this._swap(index, parent);
+        index = parent;
+      }
+    }
+    _swap(i, j) {
+      var arr = this._arr;
+      var keyIndices = this._keyIndices;
+      var origArrI = arr[i];
+      var origArrJ = arr[j];
+      arr[i] = origArrJ;
+      arr[j] = origArrI;
+      keyIndices[origArrJ.key] = i;
+      keyIndices[origArrI.key] = j;
+    }
+  }
+  priorityQueue = PriorityQueue;
+  return priorityQueue;
+}
+var dijkstra_1;
+var hasRequiredDijkstra;
+function requireDijkstra() {
+  if (hasRequiredDijkstra) return dijkstra_1;
+  hasRequiredDijkstra = 1;
+  var PriorityQueue = requirePriorityQueue();
+  dijkstra_1 = dijkstra;
+  var DEFAULT_WEIGHT_FUNC = () => 1;
+  function dijkstra(g, source, weightFn, edgeFn) {
+    return runDijkstra(
+      g,
+      String(source),
+      weightFn || DEFAULT_WEIGHT_FUNC,
+      edgeFn || function(v) {
+        return g.outEdges(v);
+      }
+    );
+  }
+  function runDijkstra(g, source, weightFn, edgeFn) {
+    var results = {};
+    var pq = new PriorityQueue();
+    var v, vEntry;
+    var updateNeighbors = function(edge2) {
+      var w = edge2.v !== v ? edge2.v : edge2.w;
+      var wEntry = results[w];
+      var weight = weightFn(edge2);
+      var distance2 = vEntry.distance + weight;
+      if (weight < 0) {
+        throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + edge2 + " Weight: " + weight);
+      }
+      if (distance2 < wEntry.distance) {
+        wEntry.distance = distance2;
+        wEntry.predecessor = v;
+        pq.decrease(w, distance2);
+      }
+    };
+    g.nodes().forEach(function(v2) {
+      var distance2 = v2 === source ? 0 : Number.POSITIVE_INFINITY;
+      results[v2] = { distance: distance2 };
+      pq.add(v2, distance2);
+    });
+    while (pq.size() > 0) {
+      v = pq.removeMin();
+      vEntry = results[v];
+      if (vEntry.distance === Number.POSITIVE_INFINITY) {
+        break;
+      }
+      edgeFn(v).forEach(updateNeighbors);
+    }
+    return results;
+  }
+  return dijkstra_1;
+}
+var dijkstraAll_1;
+var hasRequiredDijkstraAll;
+function requireDijkstraAll() {
+  if (hasRequiredDijkstraAll) return dijkstraAll_1;
+  hasRequiredDijkstraAll = 1;
+  var dijkstra = requireDijkstra();
+  dijkstraAll_1 = dijkstraAll;
+  function dijkstraAll(g, weightFunc, edgeFunc) {
+    return g.nodes().reduce(function(acc, v) {
+      acc[v] = dijkstra(g, v, weightFunc, edgeFunc);
+      return acc;
+    }, {});
+  }
+  return dijkstraAll_1;
+}
+var tarjan_1;
+var hasRequiredTarjan;
+function requireTarjan() {
+  if (hasRequiredTarjan) return tarjan_1;
+  hasRequiredTarjan = 1;
+  tarjan_1 = tarjan;
+  function tarjan(g) {
+    var index = 0;
+    var stack = [];
+    var visited = {};
+    var results = [];
+    function dfs(v) {
+      var entry = visited[v] = {
+        onStack: true,
+        lowlink: index,
+        index: index++
+      };
+      stack.push(v);
+      g.successors(v).forEach(function(w2) {
+        if (!Object.hasOwn(visited, w2)) {
+          dfs(w2);
+          entry.lowlink = Math.min(entry.lowlink, visited[w2].lowlink);
+        } else if (visited[w2].onStack) {
+          entry.lowlink = Math.min(entry.lowlink, visited[w2].index);
+        }
+      });
+      if (entry.lowlink === entry.index) {
+        var cmpt = [];
+        var w;
+        do {
+          w = stack.pop();
+          visited[w].onStack = false;
+          cmpt.push(w);
+        } while (v !== w);
+        results.push(cmpt);
+      }
+    }
+    g.nodes().forEach(function(v) {
+      if (!Object.hasOwn(visited, v)) {
+        dfs(v);
+      }
+    });
+    return results;
+  }
+  return tarjan_1;
+}
+var findCycles_1;
+var hasRequiredFindCycles;
+function requireFindCycles() {
+  if (hasRequiredFindCycles) return findCycles_1;
+  hasRequiredFindCycles = 1;
+  var tarjan = requireTarjan();
+  findCycles_1 = findCycles;
+  function findCycles(g) {
+    return tarjan(g).filter(function(cmpt) {
+      return cmpt.length > 1 || cmpt.length === 1 && g.hasEdge(cmpt[0], cmpt[0]);
+    });
+  }
+  return findCycles_1;
+}
+var floydWarshall_1;
+var hasRequiredFloydWarshall;
+function requireFloydWarshall() {
+  if (hasRequiredFloydWarshall) return floydWarshall_1;
+  hasRequiredFloydWarshall = 1;
+  floydWarshall_1 = floydWarshall;
+  var DEFAULT_WEIGHT_FUNC = () => 1;
+  function floydWarshall(g, weightFn, edgeFn) {
+    return runFloydWarshall(
+      g,
+      weightFn || DEFAULT_WEIGHT_FUNC,
+      edgeFn || function(v) {
+        return g.outEdges(v);
+      }
+    );
+  }
+  function runFloydWarshall(g, weightFn, edgeFn) {
+    var results = {};
+    var nodes = g.nodes();
+    nodes.forEach(function(v) {
+      results[v] = {};
+      results[v][v] = { distance: 0 };
+      nodes.forEach(function(w) {
+        if (v !== w) {
+          results[v][w] = { distance: Number.POSITIVE_INFINITY };
+        }
+      });
+      edgeFn(v).forEach(function(edge2) {
+        var w = edge2.v === v ? edge2.w : edge2.v;
+        var d = weightFn(edge2);
+        results[v][w] = { distance: d, predecessor: v };
+      });
+    });
+    nodes.forEach(function(k) {
+      var rowK = results[k];
+      nodes.forEach(function(i) {
+        var rowI = results[i];
+        nodes.forEach(function(j) {
+          var ik = rowI[k];
+          var kj = rowK[j];
+          var ij = rowI[j];
+          var altDistance = ik.distance + kj.distance;
+          if (altDistance < ij.distance) {
+            ij.distance = altDistance;
+            ij.predecessor = kj.predecessor;
+          }
+        });
+      });
+    });
+    return results;
+  }
+  return floydWarshall_1;
+}
+var topsort_1;
+var hasRequiredTopsort;
+function requireTopsort() {
+  if (hasRequiredTopsort) return topsort_1;
+  hasRequiredTopsort = 1;
+  function topsort(g) {
+    var visited = {};
+    var stack = {};
+    var results = [];
+    function visit(node2) {
+      if (Object.hasOwn(stack, node2)) {
+        throw new CycleException();
+      }
+      if (!Object.hasOwn(visited, node2)) {
+        stack[node2] = true;
+        visited[node2] = true;
+        g.predecessors(node2).forEach(visit);
+        delete stack[node2];
+        results.push(node2);
+      }
+    }
+    g.sinks().forEach(visit);
+    if (Object.keys(visited).length !== g.nodeCount()) {
+      throw new CycleException();
+    }
+    return results;
+  }
+  class CycleException extends Error {
+    constructor() {
+      super(...arguments);
+    }
+  }
+  topsort_1 = topsort;
+  topsort.CycleException = CycleException;
+  return topsort_1;
+}
+var isAcyclic_1;
+var hasRequiredIsAcyclic;
+function requireIsAcyclic() {
+  if (hasRequiredIsAcyclic) return isAcyclic_1;
+  hasRequiredIsAcyclic = 1;
+  var topsort = requireTopsort();
+  isAcyclic_1 = isAcyclic;
+  function isAcyclic(g) {
+    try {
+      topsort(g);
+    } catch (e) {
+      if (e instanceof topsort.CycleException) {
+        return false;
+      }
+      throw e;
+    }
+    return true;
+  }
+  return isAcyclic_1;
+}
+var dfs_1;
+var hasRequiredDfs;
+function requireDfs() {
+  if (hasRequiredDfs) return dfs_1;
+  hasRequiredDfs = 1;
+  dfs_1 = dfs;
+  function dfs(g, vs, order) {
+    if (!Array.isArray(vs)) {
+      vs = [vs];
+    }
+    var navigation = g.isDirected() ? (v) => g.successors(v) : (v) => g.neighbors(v);
+    var orderFunc = order === "post" ? postOrderDfs : preOrderDfs;
+    var acc = [];
+    var visited = {};
+    vs.forEach((v) => {
+      if (!g.hasNode(v)) {
+        throw new Error("Graph does not have node: " + v);
+      }
+      orderFunc(v, navigation, visited, acc);
+    });
+    return acc;
+  }
+  function postOrderDfs(v, navigation, visited, acc) {
+    var stack = [[v, false]];
+    while (stack.length > 0) {
+      var curr = stack.pop();
+      if (curr[1]) {
+        acc.push(curr[0]);
+      } else {
+        if (!Object.hasOwn(visited, curr[0])) {
+          visited[curr[0]] = true;
+          stack.push([curr[0], true]);
+          forEachRight(navigation(curr[0]), (w) => stack.push([w, false]));
+        }
+      }
+    }
+  }
+  function preOrderDfs(v, navigation, visited, acc) {
+    var stack = [v];
+    while (stack.length > 0) {
+      var curr = stack.pop();
+      if (!Object.hasOwn(visited, curr)) {
+        visited[curr] = true;
+        acc.push(curr);
+        forEachRight(navigation(curr), (w) => stack.push(w));
+      }
+    }
+  }
+  function forEachRight(array2, iteratee) {
+    var length = array2.length;
+    while (length--) {
+      iteratee(array2[length], length, array2);
+    }
+    return array2;
+  }
+  return dfs_1;
+}
+var postorder_1;
+var hasRequiredPostorder;
+function requirePostorder() {
+  if (hasRequiredPostorder) return postorder_1;
+  hasRequiredPostorder = 1;
+  var dfs = requireDfs();
+  postorder_1 = postorder;
+  function postorder(g, vs) {
+    return dfs(g, vs, "post");
+  }
+  return postorder_1;
+}
+var preorder_1;
+var hasRequiredPreorder;
+function requirePreorder() {
+  if (hasRequiredPreorder) return preorder_1;
+  hasRequiredPreorder = 1;
+  var dfs = requireDfs();
+  preorder_1 = preorder;
+  function preorder(g, vs) {
+    return dfs(g, vs, "pre");
+  }
+  return preorder_1;
+}
+var prim_1;
+var hasRequiredPrim;
+function requirePrim() {
+  if (hasRequiredPrim) return prim_1;
+  hasRequiredPrim = 1;
+  var Graph = requireGraph();
+  var PriorityQueue = requirePriorityQueue();
+  prim_1 = prim;
+  function prim(g, weightFunc) {
+    var result = new Graph();
+    var parents = {};
+    var pq = new PriorityQueue();
+    var v;
+    function updateNeighbors(edge2) {
+      var w = edge2.v === v ? edge2.w : edge2.v;
+      var pri = pq.priority(w);
+      if (pri !== void 0) {
+        var edgeWeight = weightFunc(edge2);
+        if (edgeWeight < pri) {
+          parents[w] = v;
+          pq.decrease(w, edgeWeight);
+        }
+      }
+    }
+    if (g.nodeCount() === 0) {
+      return result;
+    }
+    g.nodes().forEach(function(v2) {
+      pq.add(v2, Number.POSITIVE_INFINITY);
+      result.setNode(v2);
+    });
+    pq.decrease(g.nodes()[0], 0);
+    var init2 = false;
+    while (pq.size() > 0) {
+      v = pq.removeMin();
+      if (Object.hasOwn(parents, v)) {
+        result.setEdge(v, parents[v]);
+      } else if (init2) {
+        throw new Error("Input graph is not connected: " + g);
+      } else {
+        init2 = true;
+      }
+      g.nodeEdges(v).forEach(updateNeighbors);
+    }
+    return result;
+  }
+  return prim_1;
+}
+var alg;
+var hasRequiredAlg;
+function requireAlg() {
+  if (hasRequiredAlg) return alg;
+  hasRequiredAlg = 1;
+  alg = {
+    components: requireComponents(),
+    dijkstra: requireDijkstra(),
+    dijkstraAll: requireDijkstraAll(),
+    findCycles: requireFindCycles(),
+    floydWarshall: requireFloydWarshall(),
+    isAcyclic: requireIsAcyclic(),
+    postorder: requirePostorder(),
+    preorder: requirePreorder(),
+    prim: requirePrim(),
+    tarjan: requireTarjan(),
+    topsort: requireTopsort()
+  };
+  return alg;
+}
+var graphlib;
+var hasRequiredGraphlib;
+function requireGraphlib() {
+  if (hasRequiredGraphlib) return graphlib;
+  hasRequiredGraphlib = 1;
+  var lib2 = requireLib();
+  graphlib = {
+    Graph: lib2.Graph,
+    json: requireJson(),
+    alg: requireAlg(),
+    version: lib2.version
+  };
+  return graphlib;
+}
+var list;
+var hasRequiredList;
+function requireList() {
+  if (hasRequiredList) return list;
+  hasRequiredList = 1;
+  class List {
+    constructor() {
+      let sentinel = {};
+      sentinel._next = sentinel._prev = sentinel;
+      this._sentinel = sentinel;
+    }
+    dequeue() {
+      let sentinel = this._sentinel;
+      let entry = sentinel._prev;
+      if (entry !== sentinel) {
+        unlink(entry);
+        return entry;
+      }
+    }
+    enqueue(entry) {
+      let 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() {
+      let strs = [];
+      let sentinel = this._sentinel;
+      let 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;
+    }
+  }
+  list = List;
+  return list;
+}
+var greedyFas;
+var hasRequiredGreedyFas;
+function requireGreedyFas() {
+  if (hasRequiredGreedyFas) return greedyFas;
+  hasRequiredGreedyFas = 1;
+  let Graph = requireGraphlib().Graph;
+  let List = requireList();
+  greedyFas = greedyFAS;
+  let DEFAULT_WEIGHT_FN = () => 1;
+  function greedyFAS(g, weightFn) {
+    if (g.nodeCount() <= 1) {
+      return [];
+    }
+    let state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+    let results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+    return results.flatMap((e) => g.outEdges(e.v, e.w));
+  }
+  function doGreedyFAS(g, buckets, zeroIdx) {
+    let results = [];
+    let sources = buckets[buckets.length - 1];
+    let sinks = buckets[0];
+    let 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 (let 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) {
+    let results = collectPredecessors ? [] : void 0;
+    g.inEdges(entry.v).forEach((edge2) => {
+      let weight = g.edge(edge2);
+      let uEntry = g.node(edge2.v);
+      if (collectPredecessors) {
+        results.push({ v: edge2.v, w: edge2.w });
+      }
+      uEntry.out -= weight;
+      assignBucket(buckets, zeroIdx, uEntry);
+    });
+    g.outEdges(entry.v).forEach((edge2) => {
+      let weight = g.edge(edge2);
+      let w = edge2.w;
+      let wEntry = g.node(w);
+      wEntry["in"] -= weight;
+      assignBucket(buckets, zeroIdx, wEntry);
+    });
+    g.removeNode(entry.v);
+    return results;
+  }
+  function buildState(g, weightFn) {
+    let fasGraph = new Graph();
+    let maxIn = 0;
+    let maxOut = 0;
+    g.nodes().forEach((v) => {
+      fasGraph.setNode(v, { v, "in": 0, out: 0 });
+    });
+    g.edges().forEach((e) => {
+      let prevWeight = fasGraph.edge(e.v, e.w) || 0;
+      let weight = weightFn(e);
+      let 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);
+    });
+    let buckets = range(maxOut + maxIn + 3).map(() => new List());
+    let zeroIdx = maxIn + 1;
+    fasGraph.nodes().forEach((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);
+    }
+  }
+  function range(limit) {
+    const range2 = [];
+    for (let i = 0; i < limit; i++) {
+      range2.push(i);
+    }
+    return range2;
+  }
+  return greedyFas;
+}
+var util$1;
+var hasRequiredUtil$1;
+function requireUtil$1() {
+  if (hasRequiredUtil$1) return util$1;
+  hasRequiredUtil$1 = 1;
+  let Graph = requireGraphlib().Graph;
+  util$1 = {
+    addBorderNode,
+    addDummyNode,
+    applyWithChunking,
+    asNonCompoundGraph,
+    buildLayerMatrix,
+    intersectRect,
+    mapValues,
+    maxRank,
+    normalizeRanks,
+    notime,
+    partition,
+    pick,
+    predecessorWeights,
+    range,
+    removeEmptyRanks,
+    simplify,
+    successorWeights,
+    time,
+    uniqueId,
+    zipObject
+  };
+  function addDummyNode(g, type, attrs, name) {
+    let v;
+    do {
+      v = uniqueId(name);
+    } while (g.hasNode(v));
+    attrs.dummy = type;
+    g.setNode(v, attrs);
+    return v;
+  }
+  function simplify(g) {
+    let simplified = new Graph().setGraph(g.graph());
+    g.nodes().forEach((v) => simplified.setNode(v, g.node(v)));
+    g.edges().forEach((e) => {
+      let simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
+      let label2 = g.edge(e);
+      simplified.setEdge(e.v, e.w, {
+        weight: simpleLabel.weight + label2.weight,
+        minlen: Math.max(simpleLabel.minlen, label2.minlen)
+      });
+    });
+    return simplified;
+  }
+  function asNonCompoundGraph(g) {
+    let simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+    g.nodes().forEach((v) => {
+      if (!g.children(v).length) {
+        simplified.setNode(v, g.node(v));
+      }
+    });
+    g.edges().forEach((e) => {
+      simplified.setEdge(e, g.edge(e));
+    });
+    return simplified;
+  }
+  function successorWeights(g) {
+    let weightMap = g.nodes().map((v) => {
+      let sucs = {};
+      g.outEdges(v).forEach((e) => {
+        sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
+      });
+      return sucs;
+    });
+    return zipObject(g.nodes(), weightMap);
+  }
+  function predecessorWeights(g) {
+    let weightMap = g.nodes().map((v) => {
+      let preds = {};
+      g.inEdges(v).forEach((e) => {
+        preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
+      });
+      return preds;
+    });
+    return zipObject(g.nodes(), weightMap);
+  }
+  function intersectRect(rect, point) {
+    let x = rect.x;
+    let y = rect.y;
+    let dx = point.x - x;
+    let dy = point.y - y;
+    let w = rect.width / 2;
+    let h2 = rect.height / 2;
+    if (!dx && !dy) {
+      throw new Error("Not possible to find intersection inside of the rectangle");
+    }
+    let sx, sy;
+    if (Math.abs(dy) * w > Math.abs(dx) * h2) {
+      if (dy < 0) {
+        h2 = -h2;
+      }
+      sx = h2 * dx / dy;
+      sy = h2;
+    } else {
+      if (dx < 0) {
+        w = -w;
+      }
+      sx = w;
+      sy = w * dy / dx;
+    }
+    return { x: x + sx, y: y + sy };
+  }
+  function buildLayerMatrix(g) {
+    let layering = range(maxRank(g) + 1).map(() => []);
+    g.nodes().forEach((v) => {
+      let node2 = g.node(v);
+      let rank = node2.rank;
+      if (rank !== void 0) {
+        layering[rank][node2.order] = v;
+      }
+    });
+    return layering;
+  }
+  function normalizeRanks(g) {
+    let nodeRanks = g.nodes().map((v) => {
+      let rank = g.node(v).rank;
+      if (rank === void 0) {
+        return Number.MAX_VALUE;
+      }
+      return rank;
+    });
+    let min = applyWithChunking(Math.min, nodeRanks);
+    g.nodes().forEach((v) => {
+      let node2 = g.node(v);
+      if (Object.hasOwn(node2, "rank")) {
+        node2.rank -= min;
+      }
+    });
+  }
+  function removeEmptyRanks(g) {
+    let nodeRanks = g.nodes().map((v) => g.node(v).rank);
+    let offset = applyWithChunking(Math.min, nodeRanks);
+    let layers = [];
+    g.nodes().forEach((v) => {
+      let rank = g.node(v).rank - offset;
+      if (!layers[rank]) {
+        layers[rank] = [];
+      }
+      layers[rank].push(v);
+    });
+    let delta = 0;
+    let nodeRankFactor = g.graph().nodeRankFactor;
+    Array.from(layers).forEach((vs, i) => {
+      if (vs === void 0 && i % nodeRankFactor !== 0) {
+        --delta;
+      } else if (vs !== void 0 && delta) {
+        vs.forEach((v) => g.node(v).rank += delta);
+      }
+    });
+  }
+  function addBorderNode(g, prefix, rank, order) {
+    let node2 = {
+      width: 0,
+      height: 0
+    };
+    if (arguments.length >= 4) {
+      node2.rank = rank;
+      node2.order = order;
+    }
+    return addDummyNode(g, "border", node2, prefix);
+  }
+  function splitToChunks(array2, chunkSize = CHUNKING_THRESHOLD) {
+    const chunks = [];
+    for (let i = 0; i < array2.length; i += chunkSize) {
+      const chunk = array2.slice(i, i + chunkSize);
+      chunks.push(chunk);
+    }
+    return chunks;
+  }
+  const CHUNKING_THRESHOLD = 65535;
+  function applyWithChunking(fn, argsArray) {
+    if (argsArray.length > CHUNKING_THRESHOLD) {
+      const chunks = splitToChunks(argsArray);
+      return fn.apply(null, chunks.map((chunk) => fn.apply(null, chunk)));
+    } else {
+      return fn.apply(null, argsArray);
+    }
+  }
+  function maxRank(g) {
+    const nodes = g.nodes();
+    const nodeRanks = nodes.map((v) => {
+      let rank = g.node(v).rank;
+      if (rank === void 0) {
+        return Number.MIN_VALUE;
+      }
+      return rank;
+    });
+    return applyWithChunking(Math.max, nodeRanks);
+  }
+  function partition(collection, fn) {
+    let result = { lhs: [], rhs: [] };
+    collection.forEach((value) => {
+      if (fn(value)) {
+        result.lhs.push(value);
+      } else {
+        result.rhs.push(value);
+      }
+    });
+    return result;
+  }
+  function time(name, fn) {
+    let start2 = Date.now();
+    try {
+      return fn();
+    } finally {
+      console.log(name + " time: " + (Date.now() - start2) + "ms");
+    }
+  }
+  function notime(name, fn) {
+    return fn();
+  }
+  let idCounter = 0;
+  function uniqueId(prefix) {
+    var id2 = ++idCounter;
+    return toString(prefix) + id2;
+  }
+  function range(start2, limit, step = 1) {
+    if (limit == null) {
+      limit = start2;
+      start2 = 0;
+    }
+    let endCon = (i) => i < limit;
+    if (step < 0) {
+      endCon = (i) => limit < i;
+    }
+    const range2 = [];
+    for (let i = start2; endCon(i); i += step) {
+      range2.push(i);
+    }
+    return range2;
+  }
+  function pick(source, keys) {
+    const dest = {};
+    for (const key of keys) {
+      if (source[key] !== void 0) {
+        dest[key] = source[key];
+      }
+    }
+    return dest;
+  }
+  function mapValues(obj, funcOrProp) {
+    let func = funcOrProp;
+    if (typeof funcOrProp === "string") {
+      func = (val) => val[funcOrProp];
+    }
+    return Object.entries(obj).reduce((acc, [k, v]) => {
+      acc[k] = func(v, k);
+      return acc;
+    }, {});
+  }
+  function zipObject(props, values) {
+    return props.reduce((acc, key, i) => {
+      acc[key] = values[i];
+      return acc;
+    }, {});
+  }
+  return util$1;
+}
+var acyclic;
+var hasRequiredAcyclic;
+function requireAcyclic() {
+  if (hasRequiredAcyclic) return acyclic;
+  hasRequiredAcyclic = 1;
+  let greedyFAS = requireGreedyFas();
+  let uniqueId = requireUtil$1().uniqueId;
+  acyclic = {
+    run,
+    undo
+  };
+  function run(g) {
+    let fas = g.graph().acyclicer === "greedy" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+    fas.forEach((e) => {
+      let label2 = g.edge(e);
+      g.removeEdge(e);
+      label2.forwardName = e.name;
+      label2.reversed = true;
+      g.setEdge(e.w, e.v, label2, uniqueId("rev"));
+    });
+    function weightFn(g2) {
+      return (e) => {
+        return g2.edge(e).weight;
+      };
+    }
+  }
+  function dfsFAS(g) {
+    let fas = [];
+    let stack = {};
+    let visited = {};
+    function dfs(v) {
+      if (Object.hasOwn(visited, v)) {
+        return;
+      }
+      visited[v] = true;
+      stack[v] = true;
+      g.outEdges(v).forEach((e) => {
+        if (Object.hasOwn(stack, e.w)) {
+          fas.push(e);
+        } else {
+          dfs(e.w);
+        }
+      });
+      delete stack[v];
+    }
+    g.nodes().forEach(dfs);
+    return fas;
+  }
+  function undo(g) {
+    g.edges().forEach((e) => {
+      let label2 = g.edge(e);
+      if (label2.reversed) {
+        g.removeEdge(e);
+        let forwardName = label2.forwardName;
+        delete label2.reversed;
+        delete label2.forwardName;
+        g.setEdge(e.w, e.v, label2, forwardName);
+      }
+    });
+  }
+  return acyclic;
+}
+var normalize;
+var hasRequiredNormalize;
+function requireNormalize() {
+  if (hasRequiredNormalize) return normalize;
+  hasRequiredNormalize = 1;
+  let util2 = requireUtil$1();
+  normalize = {
+    run,
+    undo
+  };
+  function run(g) {
+    g.graph().dummyChains = [];
+    g.edges().forEach((edge2) => normalizeEdge(g, edge2));
+  }
+  function normalizeEdge(g, e) {
+    let v = e.v;
+    let vRank = g.node(v).rank;
+    let w = e.w;
+    let wRank = g.node(w).rank;
+    let name = e.name;
+    let edgeLabel2 = g.edge(e);
+    let labelRank = edgeLabel2.labelRank;
+    if (wRank === vRank + 1) return;
+    g.removeEdge(e);
+    let dummy, attrs, i;
+    for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+      edgeLabel2.points = [];
+      attrs = {
+        width: 0,
+        height: 0,
+        edgeLabel: edgeLabel2,
+        edgeObj: e,
+        rank: vRank
+      };
+      dummy = util2.addDummyNode(g, "edge", attrs, "_d");
+      if (vRank === labelRank) {
+        attrs.width = edgeLabel2.width;
+        attrs.height = edgeLabel2.height;
+        attrs.dummy = "edge-label";
+        attrs.labelpos = edgeLabel2.labelpos;
+      }
+      g.setEdge(v, dummy, { weight: edgeLabel2.weight }, name);
+      if (i === 0) {
+        g.graph().dummyChains.push(dummy);
+      }
+      v = dummy;
+    }
+    g.setEdge(v, w, { weight: edgeLabel2.weight }, name);
+  }
+  function undo(g) {
+    g.graph().dummyChains.forEach((v) => {
+      let node2 = g.node(v);
+      let origLabel = node2.edgeLabel;
+      let w;
+      g.setEdge(node2.edgeObj, origLabel);
+      while (node2.dummy) {
+        w = g.successors(v)[0];
+        g.removeNode(v);
+        origLabel.points.push({ x: node2.x, y: node2.y });
+        if (node2.dummy === "edge-label") {
+          origLabel.x = node2.x;
+          origLabel.y = node2.y;
+          origLabel.width = node2.width;
+          origLabel.height = node2.height;
+        }
+        v = w;
+        node2 = g.node(v);
+      }
+    });
+  }
+  return normalize;
+}
+var util;
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util;
+  hasRequiredUtil = 1;
+  const { applyWithChunking } = requireUtil$1();
+  util = {
+    longestPath,
+    slack
+  };
+  function longestPath(g) {
+    var visited = {};
+    function dfs(v) {
+      var label2 = g.node(v);
+      if (Object.hasOwn(visited, v)) {
+        return label2.rank;
+      }
+      visited[v] = true;
+      let outEdgesMinLens = g.outEdges(v).map((e) => {
+        if (e == null) {
+          return Number.POSITIVE_INFINITY;
+        }
+        return dfs(e.w) - g.edge(e).minlen;
+      });
+      var rank = applyWithChunking(Math.min, outEdgesMinLens);
+      if (rank === Number.POSITIVE_INFINITY) {
+        rank = 0;
+      }
+      return label2.rank = rank;
+    }
+    g.sources().forEach(dfs);
+  }
+  function slack(g, e) {
+    return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+  }
+  return util;
+}
+var feasibleTree_1;
+var hasRequiredFeasibleTree;
+function requireFeasibleTree() {
+  if (hasRequiredFeasibleTree) return feasibleTree_1;
+  hasRequiredFeasibleTree = 1;
+  var Graph = requireGraphlib().Graph;
+  var slack = requireUtil().slack;
+  feasibleTree_1 = feasibleTree;
+  function feasibleTree(g) {
+    var t = new Graph({ directed: false });
+    var start2 = g.nodes()[0];
+    var size = g.nodeCount();
+    t.setNode(start2, {});
+    var edge2, delta;
+    while (tightTree(t, g) < size) {
+      edge2 = findMinSlackEdge(t, g);
+      delta = t.hasNode(edge2.v) ? slack(g, edge2) : -slack(g, edge2);
+      shiftRanks(t, g, delta);
+    }
+    return t;
+  }
+  function tightTree(t, g) {
+    function dfs(v) {
+      g.nodeEdges(v).forEach((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);
+        }
+      });
+    }
+    t.nodes().forEach(dfs);
+    return t.nodeCount();
+  }
+  function findMinSlackEdge(t, g) {
+    const edges = g.edges();
+    return edges.reduce((acc, edge2) => {
+      let edgeSlack = Number.POSITIVE_INFINITY;
+      if (t.hasNode(edge2.v) !== t.hasNode(edge2.w)) {
+        edgeSlack = slack(g, edge2);
+      }
+      if (edgeSlack < acc[0]) {
+        return [edgeSlack, edge2];
+      }
+      return acc;
+    }, [Number.POSITIVE_INFINITY, null])[1];
+  }
+  function shiftRanks(t, g, delta) {
+    t.nodes().forEach((v) => g.node(v).rank += delta);
+  }
+  return feasibleTree_1;
+}
+var networkSimplex_1;
+var hasRequiredNetworkSimplex;
+function requireNetworkSimplex() {
+  if (hasRequiredNetworkSimplex) return networkSimplex_1;
+  hasRequiredNetworkSimplex = 1;
+  var feasibleTree = requireFeasibleTree();
+  var slack = requireUtil().slack;
+  var initRank = requireUtil().longestPath;
+  var preorder = requireGraphlib().alg.preorder;
+  var postorder = requireGraphlib().alg.postorder;
+  var simplify = requireUtil$1().simplify;
+  networkSimplex_1 = networkSimplex;
+  networkSimplex.initLowLimValues = initLowLimValues;
+  networkSimplex.initCutValues = initCutValues;
+  networkSimplex.calcCutValue = calcCutValue;
+  networkSimplex.leaveEdge = leaveEdge;
+  networkSimplex.enterEdge = enterEdge;
+  networkSimplex.exchangeEdges = exchangeEdges;
+  function networkSimplex(g) {
+    g = simplify(g);
+    initRank(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(t, t.nodes());
+    vs = vs.slice(0, vs.length - 1);
+    vs.forEach((v) => assignCutValue(t, g, v));
+  }
+  function assignCutValue(t, g, child) {
+    var childLab = t.node(child);
+    var parent = childLab.parent;
+    t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+  }
+  function calcCutValue(t, g, child) {
+    var childLab = t.node(child);
+    var parent = childLab.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;
+    g.nodeEdges(child).forEach((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, root2) {
+    if (arguments.length < 2) {
+      root2 = tree.nodes()[0];
+    }
+    dfsAssignLowLim(tree, {}, 1, root2);
+  }
+  function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+    var low = nextLim;
+    var label2 = tree.node(v);
+    visited[v] = true;
+    tree.neighbors(v).forEach((w) => {
+      if (!Object.hasOwn(visited, w)) {
+        nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+      }
+    });
+    label2.low = low;
+    label2.lim = nextLim++;
+    if (parent) {
+      label2.parent = parent;
+    } else {
+      delete label2.parent;
+    }
+    return nextLim;
+  }
+  function leaveEdge(tree) {
+    return tree.edges().find((e) => tree.edge(e).cutvalue < 0);
+  }
+  function enterEdge(t, g, edge2) {
+    var v = edge2.v;
+    var w = edge2.w;
+    if (!g.hasEdge(v, w)) {
+      v = edge2.w;
+      w = edge2.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 = g.edges().filter((edge3) => {
+      return flip === isDescendant(t, t.node(edge3.v), tailLabel) && flip !== isDescendant(t, t.node(edge3.w), tailLabel);
+    });
+    return candidates.reduce((acc, edge3) => {
+      if (slack(g, edge3) < slack(g, acc)) {
+        return edge3;
+      }
+      return acc;
+    });
+  }
+  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 root2 = t.nodes().find((v) => !g.node(v).parent);
+    var vs = preorder(t, root2);
+    vs = vs.slice(1);
+    vs.forEach((v) => {
+      var parent = t.node(v).parent, edge2 = g.edge(v, parent), flipped = false;
+      if (!edge2) {
+        edge2 = g.edge(parent, v);
+        flipped = true;
+      }
+      g.node(v).rank = g.node(parent).rank + (flipped ? edge2.minlen : -edge2.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;
+  }
+  return networkSimplex_1;
+}
+var rank_1;
+var hasRequiredRank;
+function requireRank() {
+  if (hasRequiredRank) return rank_1;
+  hasRequiredRank = 1;
+  var rankUtil = requireUtil();
+  var longestPath = rankUtil.longestPath;
+  var feasibleTree = requireFeasibleTree();
+  var networkSimplex = requireNetworkSimplex();
+  rank_1 = rank;
+  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);
+  }
+  return rank_1;
+}
+var parentDummyChains_1;
+var hasRequiredParentDummyChains;
+function requireParentDummyChains() {
+  if (hasRequiredParentDummyChains) return parentDummyChains_1;
+  hasRequiredParentDummyChains = 1;
+  parentDummyChains_1 = parentDummyChains;
+  function parentDummyChains(g) {
+    let postorderNums = postorder(g);
+    g.graph().dummyChains.forEach((v) => {
+      let node2 = g.node(v);
+      let edgeObj = node2.edgeObj;
+      let pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+      let path = pathData.path;
+      let lca = pathData.lca;
+      let pathIdx = 0;
+      let pathV = path[pathIdx];
+      let ascending2 = true;
+      while (v !== edgeObj.w) {
+        node2 = g.node(v);
+        if (ascending2) {
+          while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node2.rank) {
+            pathIdx++;
+          }
+          if (pathV === lca) {
+            ascending2 = false;
+          }
+        }
+        if (!ascending2) {
+          while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node2.rank) {
+            pathIdx++;
+          }
+          pathV = path[pathIdx];
+        }
+        g.setParent(v, pathV);
+        v = g.successors(v)[0];
+      }
+    });
+  }
+  function findPath(g, postorderNums, v, w) {
+    let vPath = [];
+    let wPath = [];
+    let low = Math.min(postorderNums[v].low, postorderNums[w].low);
+    let lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+    let parent;
+    let 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) {
+    let result = {};
+    let lim = 0;
+    function dfs(v) {
+      let low = lim;
+      g.children(v).forEach(dfs);
+      result[v] = { low, lim: lim++ };
+    }
+    g.children().forEach(dfs);
+    return result;
+  }
+  return parentDummyChains_1;
+}
+var nestingGraph;
+var hasRequiredNestingGraph;
+function requireNestingGraph() {
+  if (hasRequiredNestingGraph) return nestingGraph;
+  hasRequiredNestingGraph = 1;
+  let util2 = requireUtil$1();
+  nestingGraph = {
+    run,
+    cleanup
+  };
+  function run(g) {
+    let root2 = util2.addDummyNode(g, "root", {}, "_root");
+    let depths = treeDepths(g);
+    let depthsArr = Object.values(depths);
+    let height = util2.applyWithChunking(Math.max, depthsArr) - 1;
+    let nodeSep = 2 * height + 1;
+    g.graph().nestingRoot = root2;
+    g.edges().forEach((e) => g.edge(e).minlen *= nodeSep);
+    let weight = sumWeights(g) + 1;
+    g.children().forEach((child) => dfs(g, root2, nodeSep, weight, height, depths, child));
+    g.graph().nodeRankFactor = nodeSep;
+  }
+  function dfs(g, root2, nodeSep, weight, height, depths, v) {
+    let children2 = g.children(v);
+    if (!children2.length) {
+      if (v !== root2) {
+        g.setEdge(root2, v, { weight: 0, minlen: nodeSep });
+      }
+      return;
+    }
+    let top2 = util2.addBorderNode(g, "_bt");
+    let bottom2 = util2.addBorderNode(g, "_bb");
+    let label2 = g.node(v);
+    g.setParent(top2, v);
+    label2.borderTop = top2;
+    g.setParent(bottom2, v);
+    label2.borderBottom = bottom2;
+    children2.forEach((child) => {
+      dfs(g, root2, nodeSep, weight, height, depths, child);
+      let childNode = g.node(child);
+      let childTop = childNode.borderTop ? childNode.borderTop : child;
+      let childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+      let thisWeight = childNode.borderTop ? weight : 2 * weight;
+      let minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+      g.setEdge(top2, childTop, {
+        weight: thisWeight,
+        minlen,
+        nestingEdge: true
+      });
+      g.setEdge(childBottom, bottom2, {
+        weight: thisWeight,
+        minlen,
+        nestingEdge: true
+      });
+    });
+    if (!g.parent(v)) {
+      g.setEdge(root2, top2, { weight: 0, minlen: height + depths[v] });
+    }
+  }
+  function treeDepths(g) {
+    var depths = {};
+    function dfs2(v, depth) {
+      var children2 = g.children(v);
+      if (children2 && children2.length) {
+        children2.forEach((child) => dfs2(child, depth + 1));
+      }
+      depths[v] = depth;
+    }
+    g.children().forEach((v) => dfs2(v, 1));
+    return depths;
+  }
+  function sumWeights(g) {
+    return g.edges().reduce((acc, e) => acc + g.edge(e).weight, 0);
+  }
+  function cleanup(g) {
+    var graphLabel = g.graph();
+    g.removeNode(graphLabel.nestingRoot);
+    delete graphLabel.nestingRoot;
+    g.edges().forEach((e) => {
+      var edge2 = g.edge(e);
+      if (edge2.nestingEdge) {
+        g.removeEdge(e);
+      }
+    });
+  }
+  return nestingGraph;
+}
+var addBorderSegments_1;
+var hasRequiredAddBorderSegments;
+function requireAddBorderSegments() {
+  if (hasRequiredAddBorderSegments) return addBorderSegments_1;
+  hasRequiredAddBorderSegments = 1;
+  let util2 = requireUtil$1();
+  addBorderSegments_1 = addBorderSegments;
+  function addBorderSegments(g) {
+    function dfs(v) {
+      let children2 = g.children(v);
+      let node2 = g.node(v);
+      if (children2.length) {
+        children2.forEach(dfs);
+      }
+      if (Object.hasOwn(node2, "minRank")) {
+        node2.borderLeft = [];
+        node2.borderRight = [];
+        for (let rank = node2.minRank, maxRank = node2.maxRank + 1; rank < maxRank; ++rank) {
+          addBorderNode(g, "borderLeft", "_bl", v, node2, rank);
+          addBorderNode(g, "borderRight", "_br", v, node2, rank);
+        }
+      }
+    }
+    g.children().forEach(dfs);
+  }
+  function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
+    let label2 = { width: 0, height: 0, rank, borderType: prop };
+    let prev = sgNode[prop][rank - 1];
+    let curr = util2.addDummyNode(g, "border", label2, prefix);
+    sgNode[prop][rank] = curr;
+    g.setParent(curr, sg);
+    if (prev) {
+      g.setEdge(prev, curr, { weight: 1 });
+    }
+  }
+  return addBorderSegments_1;
+}
+var coordinateSystem;
+var hasRequiredCoordinateSystem;
+function requireCoordinateSystem() {
+  if (hasRequiredCoordinateSystem) return coordinateSystem;
+  hasRequiredCoordinateSystem = 1;
+  coordinateSystem = {
+    adjust,
+    undo
+  };
+  function adjust(g) {
+    let rankDir = g.graph().rankdir.toLowerCase();
+    if (rankDir === "lr" || rankDir === "rl") {
+      swapWidthHeight(g);
+    }
+  }
+  function undo(g) {
+    let rankDir = g.graph().rankdir.toLowerCase();
+    if (rankDir === "bt" || rankDir === "rl") {
+      reverseY(g);
+    }
+    if (rankDir === "lr" || rankDir === "rl") {
+      swapXY(g);
+      swapWidthHeight(g);
+    }
+  }
+  function swapWidthHeight(g) {
+    g.nodes().forEach((v) => swapWidthHeightOne(g.node(v)));
+    g.edges().forEach((e) => swapWidthHeightOne(g.edge(e)));
+  }
+  function swapWidthHeightOne(attrs) {
+    let w = attrs.width;
+    attrs.width = attrs.height;
+    attrs.height = w;
+  }
+  function reverseY(g) {
+    g.nodes().forEach((v) => reverseYOne(g.node(v)));
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      edge2.points.forEach(reverseYOne);
+      if (Object.hasOwn(edge2, "y")) {
+        reverseYOne(edge2);
+      }
+    });
+  }
+  function reverseYOne(attrs) {
+    attrs.y = -attrs.y;
+  }
+  function swapXY(g) {
+    g.nodes().forEach((v) => swapXYOne(g.node(v)));
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      edge2.points.forEach(swapXYOne);
+      if (Object.hasOwn(edge2, "x")) {
+        swapXYOne(edge2);
+      }
+    });
+  }
+  function swapXYOne(attrs) {
+    let x = attrs.x;
+    attrs.x = attrs.y;
+    attrs.y = x;
+  }
+  return coordinateSystem;
+}
+var initOrder_1;
+var hasRequiredInitOrder;
+function requireInitOrder() {
+  if (hasRequiredInitOrder) return initOrder_1;
+  hasRequiredInitOrder = 1;
+  let util2 = requireUtil$1();
+  initOrder_1 = initOrder;
+  function initOrder(g) {
+    let visited = {};
+    let simpleNodes = g.nodes().filter((v) => !g.children(v).length);
+    let simpleNodesRanks = simpleNodes.map((v) => g.node(v).rank);
+    let maxRank = util2.applyWithChunking(Math.max, simpleNodesRanks);
+    let layers = util2.range(maxRank + 1).map(() => []);
+    function dfs(v) {
+      if (visited[v]) return;
+      visited[v] = true;
+      let node2 = g.node(v);
+      layers[node2.rank].push(v);
+      g.successors(v).forEach(dfs);
+    }
+    let orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
+    orderedVs.forEach(dfs);
+    return layers;
+  }
+  return initOrder_1;
+}
+var crossCount_1;
+var hasRequiredCrossCount;
+function requireCrossCount() {
+  if (hasRequiredCrossCount) return crossCount_1;
+  hasRequiredCrossCount = 1;
+  let zipObject = requireUtil$1().zipObject;
+  crossCount_1 = crossCount;
+  function crossCount(g, layering) {
+    let cc = 0;
+    for (let i = 1; i < layering.length; ++i) {
+      cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+    }
+    return cc;
+  }
+  function twoLayerCrossCount(g, northLayer, southLayer) {
+    let southPos = zipObject(southLayer, southLayer.map((v, i) => i));
+    let southEntries = northLayer.flatMap((v) => {
+      return g.outEdges(v).map((e) => {
+        return { pos: southPos[e.w], weight: g.edge(e).weight };
+      }).sort((a, b) => a.pos - b.pos);
+    });
+    let firstIndex = 1;
+    while (firstIndex < southLayer.length) firstIndex <<= 1;
+    let treeSize = 2 * firstIndex - 1;
+    firstIndex -= 1;
+    let tree = new Array(treeSize).fill(0);
+    let cc = 0;
+    southEntries.forEach((entry) => {
+      let index = entry.pos + firstIndex;
+      tree[index] += entry.weight;
+      let 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;
+  }
+  return crossCount_1;
+}
+var barycenter_1;
+var hasRequiredBarycenter;
+function requireBarycenter() {
+  if (hasRequiredBarycenter) return barycenter_1;
+  hasRequiredBarycenter = 1;
+  barycenter_1 = barycenter;
+  function barycenter(g, movable = []) {
+    return movable.map((v) => {
+      let inV = g.inEdges(v);
+      if (!inV.length) {
+        return { v };
+      } else {
+        let result = inV.reduce((acc, e) => {
+          let edge2 = g.edge(e), nodeU = g.node(e.v);
+          return {
+            sum: acc.sum + edge2.weight * nodeU.order,
+            weight: acc.weight + edge2.weight
+          };
+        }, { sum: 0, weight: 0 });
+        return {
+          v,
+          barycenter: result.sum / result.weight,
+          weight: result.weight
+        };
+      }
+    });
+  }
+  return barycenter_1;
+}
+var resolveConflicts_1;
+var hasRequiredResolveConflicts;
+function requireResolveConflicts() {
+  if (hasRequiredResolveConflicts) return resolveConflicts_1;
+  hasRequiredResolveConflicts = 1;
+  let util2 = requireUtil$1();
+  resolveConflicts_1 = resolveConflicts;
+  function resolveConflicts(entries, cg) {
+    let mappedEntries = {};
+    entries.forEach((entry, i) => {
+      let tmp = mappedEntries[entry.v] = {
+        indegree: 0,
+        "in": [],
+        out: [],
+        vs: [entry.v],
+        i
+      };
+      if (entry.barycenter !== void 0) {
+        tmp.barycenter = entry.barycenter;
+        tmp.weight = entry.weight;
+      }
+    });
+    cg.edges().forEach((e) => {
+      let entryV = mappedEntries[e.v];
+      let entryW = mappedEntries[e.w];
+      if (entryV !== void 0 && entryW !== void 0) {
+        entryW.indegree++;
+        entryV.out.push(mappedEntries[e.w]);
+      }
+    });
+    let sourceSet = Object.values(mappedEntries).filter((entry) => !entry.indegree);
+    return doResolveConflicts(sourceSet);
+  }
+  function doResolveConflicts(sourceSet) {
+    let entries = [];
+    function handleIn(vEntry) {
+      return (uEntry) => {
+        if (uEntry.merged) {
+          return;
+        }
+        if (uEntry.barycenter === void 0 || vEntry.barycenter === void 0 || uEntry.barycenter >= vEntry.barycenter) {
+          mergeEntries(vEntry, uEntry);
+        }
+      };
+    }
+    function handleOut(vEntry) {
+      return (wEntry) => {
+        wEntry["in"].push(vEntry);
+        if (--wEntry.indegree === 0) {
+          sourceSet.push(wEntry);
+        }
+      };
+    }
+    while (sourceSet.length) {
+      let entry = sourceSet.pop();
+      entries.push(entry);
+      entry["in"].reverse().forEach(handleIn(entry));
+      entry.out.forEach(handleOut(entry));
+    }
+    return entries.filter((entry) => !entry.merged).map((entry) => {
+      return util2.pick(entry, ["vs", "i", "barycenter", "weight"]);
+    });
+  }
+  function mergeEntries(target2, source) {
+    let sum = 0;
+    let weight = 0;
+    if (target2.weight) {
+      sum += target2.barycenter * target2.weight;
+      weight += target2.weight;
+    }
+    if (source.weight) {
+      sum += source.barycenter * source.weight;
+      weight += source.weight;
+    }
+    target2.vs = source.vs.concat(target2.vs);
+    target2.barycenter = sum / weight;
+    target2.weight = weight;
+    target2.i = Math.min(source.i, target2.i);
+    source.merged = true;
+  }
+  return resolveConflicts_1;
+}
+var sort_1;
+var hasRequiredSort;
+function requireSort() {
+  if (hasRequiredSort) return sort_1;
+  hasRequiredSort = 1;
+  let util2 = requireUtil$1();
+  sort_1 = sort;
+  function sort(entries, biasRight) {
+    let parts = util2.partition(entries, (entry) => {
+      return Object.hasOwn(entry, "barycenter");
+    });
+    let sortable = parts.lhs, unsortable = parts.rhs.sort((a, b) => b.i - a.i), vs = [], sum = 0, weight = 0, vsIndex = 0;
+    sortable.sort(compareWithBias(!!biasRight));
+    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+    sortable.forEach((entry) => {
+      vsIndex += entry.vs.length;
+      vs.push(entry.vs);
+      sum += entry.barycenter * entry.weight;
+      weight += entry.weight;
+      vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+    });
+    let result = { vs: vs.flat(true) };
+    if (weight) {
+      result.barycenter = sum / weight;
+      result.weight = weight;
+    }
+    return result;
+  }
+  function consumeUnsortable(vs, unsortable, index) {
+    let last;
+    while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= index) {
+      unsortable.pop();
+      vs.push(last.vs);
+      index++;
+    }
+    return index;
+  }
+  function compareWithBias(bias) {
+    return (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;
+    };
+  }
+  return sort_1;
+}
+var sortSubgraph_1;
+var hasRequiredSortSubgraph;
+function requireSortSubgraph() {
+  if (hasRequiredSortSubgraph) return sortSubgraph_1;
+  hasRequiredSortSubgraph = 1;
+  let barycenter = requireBarycenter();
+  let resolveConflicts = requireResolveConflicts();
+  let sort = requireSort();
+  sortSubgraph_1 = sortSubgraph;
+  function sortSubgraph(g, v, cg, biasRight) {
+    let movable = g.children(v);
+    let node2 = g.node(v);
+    let bl = node2 ? node2.borderLeft : void 0;
+    let br = node2 ? node2.borderRight : void 0;
+    let subgraphs = {};
+    if (bl) {
+      movable = movable.filter((w) => w !== bl && w !== br);
+    }
+    let barycenters = barycenter(g, movable);
+    barycenters.forEach((entry) => {
+      if (g.children(entry.v).length) {
+        let subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+        subgraphs[entry.v] = subgraphResult;
+        if (Object.hasOwn(subgraphResult, "barycenter")) {
+          mergeBarycenters(entry, subgraphResult);
+        }
+      }
+    });
+    let entries = resolveConflicts(barycenters, cg);
+    expandSubgraphs(entries, subgraphs);
+    let result = sort(entries, biasRight);
+    if (bl) {
+      result.vs = [bl, result.vs, br].flat(true);
+      if (g.predecessors(bl).length) {
+        let blPred = g.node(g.predecessors(bl)[0]), brPred = g.node(g.predecessors(br)[0]);
+        if (!Object.hasOwn(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) {
+    entries.forEach((entry) => {
+      entry.vs = entry.vs.flatMap((v) => {
+        if (subgraphs[v]) {
+          return subgraphs[v].vs;
+        }
+        return v;
+      });
+    });
+  }
+  function mergeBarycenters(target2, other) {
+    if (target2.barycenter !== void 0) {
+      target2.barycenter = (target2.barycenter * target2.weight + other.barycenter * other.weight) / (target2.weight + other.weight);
+      target2.weight += other.weight;
+    } else {
+      target2.barycenter = other.barycenter;
+      target2.weight = other.weight;
+    }
+  }
+  return sortSubgraph_1;
+}
+var buildLayerGraph_1;
+var hasRequiredBuildLayerGraph;
+function requireBuildLayerGraph() {
+  if (hasRequiredBuildLayerGraph) return buildLayerGraph_1;
+  hasRequiredBuildLayerGraph = 1;
+  let Graph = requireGraphlib().Graph;
+  let util2 = requireUtil$1();
+  buildLayerGraph_1 = buildLayerGraph;
+  function buildLayerGraph(g, rank, relationship) {
+    let root2 = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root: root2 }).setDefaultNodeLabel((v) => g.node(v));
+    g.nodes().forEach((v) => {
+      let node2 = g.node(v), parent = g.parent(v);
+      if (node2.rank === rank || node2.minRank <= rank && rank <= node2.maxRank) {
+        result.setNode(v);
+        result.setParent(v, parent || root2);
+        g[relationship](v).forEach((e) => {
+          let u = e.v === v ? e.w : e.v, edge2 = result.edge(u, v), weight = edge2 !== void 0 ? edge2.weight : 0;
+          result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+        });
+        if (Object.hasOwn(node2, "minRank")) {
+          result.setNode(v, {
+            borderLeft: node2.borderLeft[rank],
+            borderRight: node2.borderRight[rank]
+          });
+        }
+      }
+    });
+    return result;
+  }
+  function createRootNode(g) {
+    var v;
+    while (g.hasNode(v = util2.uniqueId("_root"))) ;
+    return v;
+  }
+  return buildLayerGraph_1;
+}
+var addSubgraphConstraints_1;
+var hasRequiredAddSubgraphConstraints;
+function requireAddSubgraphConstraints() {
+  if (hasRequiredAddSubgraphConstraints) return addSubgraphConstraints_1;
+  hasRequiredAddSubgraphConstraints = 1;
+  addSubgraphConstraints_1 = addSubgraphConstraints;
+  function addSubgraphConstraints(g, cg, vs) {
+    let prev = {}, rootPrev;
+    vs.forEach((v) => {
+      let 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;
+      }
+    });
+  }
+  return addSubgraphConstraints_1;
+}
+var order_1;
+var hasRequiredOrder;
+function requireOrder() {
+  if (hasRequiredOrder) return order_1;
+  hasRequiredOrder = 1;
+  let initOrder = requireInitOrder();
+  let crossCount = requireCrossCount();
+  let sortSubgraph = requireSortSubgraph();
+  let buildLayerGraph = requireBuildLayerGraph();
+  let addSubgraphConstraints = requireAddSubgraphConstraints();
+  let Graph = requireGraphlib().Graph;
+  let util2 = requireUtil$1();
+  order_1 = order;
+  function order(g, opts) {
+    if (opts && typeof opts.customOrder === "function") {
+      opts.customOrder(g, order);
+      return;
+    }
+    let maxRank = util2.maxRank(g), downLayerGraphs = buildLayerGraphs(g, util2.range(1, maxRank + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g, util2.range(maxRank - 1, -1, -1), "outEdges");
+    let layering = initOrder(g);
+    assignOrder(g, layering);
+    if (opts && opts.disableOptimalOrderHeuristic) {
+      return;
+    }
+    let bestCC = Number.POSITIVE_INFINITY, best;
+    for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+      sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+      layering = util2.buildLayerMatrix(g);
+      let cc = crossCount(g, layering);
+      if (cc < bestCC) {
+        lastBest = 0;
+        best = Object.assign({}, layering);
+        bestCC = cc;
+      }
+    }
+    assignOrder(g, best);
+  }
+  function buildLayerGraphs(g, ranks, relationship) {
+    return ranks.map(function(rank) {
+      return buildLayerGraph(g, rank, relationship);
+    });
+  }
+  function sweepLayerGraphs(layerGraphs, biasRight) {
+    let cg = new Graph();
+    layerGraphs.forEach(function(lg) {
+      let root2 = lg.graph().root;
+      let sorted = sortSubgraph(lg, root2, cg, biasRight);
+      sorted.vs.forEach((v, i) => lg.node(v).order = i);
+      addSubgraphConstraints(lg, cg, sorted.vs);
+    });
+  }
+  function assignOrder(g, layering) {
+    Object.values(layering).forEach((layer) => layer.forEach((v, i) => g.node(v).order = i));
+  }
+  return order_1;
+}
+var bk;
+var hasRequiredBk;
+function requireBk() {
+  if (hasRequiredBk) return bk;
+  hasRequiredBk = 1;
+  let Graph = requireGraphlib().Graph;
+  let util2 = requireUtil$1();
+  bk = {
+    positionX,
+    findType1Conflicts,
+    findType2Conflicts,
+    addConflict,
+    hasConflict,
+    verticalAlignment,
+    horizontalCompaction,
+    alignCoordinates,
+    findSmallestWidthAlignment,
+    balance
+  };
+  function findType1Conflicts(g, layering) {
+    let conflicts = {};
+    function visitLayer(prevLayer, layer) {
+      let k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = layer[layer.length - 1];
+      layer.forEach((v, i) => {
+        let w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
+        if (w || v === lastNode) {
+          layer.slice(scanPos, i + 1).forEach((scanNode) => {
+            g.predecessors(scanNode).forEach((u) => {
+              let 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;
+    }
+    layering.length && layering.reduce(visitLayer);
+    return conflicts;
+  }
+  function findType2Conflicts(g, layering) {
+    let conflicts = {};
+    function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+      let v;
+      util2.range(southPos, southEnd).forEach((i) => {
+        v = south[i];
+        if (g.node(v).dummy) {
+          g.predecessors(v).forEach((u) => {
+            let uNode = g.node(u);
+            if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+              addConflict(conflicts, u, v);
+            }
+          });
+        }
+      });
+    }
+    function visitLayer(north, south) {
+      let prevNorthPos = -1, nextNorthPos, southPos = 0;
+      south.forEach((v, southLookahead) => {
+        if (g.node(v).dummy === "border") {
+          let 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;
+    }
+    layering.length && layering.reduce(visitLayer);
+    return conflicts;
+  }
+  function findOtherInnerSegmentNode(g, v) {
+    if (g.node(v).dummy) {
+      return g.predecessors(v).find((u) => g.node(u).dummy);
+    }
+  }
+  function addConflict(conflicts, v, w) {
+    if (v > w) {
+      let tmp = v;
+      v = w;
+      w = tmp;
+    }
+    let conflictsV = conflicts[v];
+    if (!conflictsV) {
+      conflicts[v] = conflictsV = {};
+    }
+    conflictsV[w] = true;
+  }
+  function hasConflict(conflicts, v, w) {
+    if (v > w) {
+      let tmp = v;
+      v = w;
+      w = tmp;
+    }
+    return !!conflicts[v] && Object.hasOwn(conflicts[v], w);
+  }
+  function verticalAlignment(g, layering, conflicts, neighborFn) {
+    let root2 = {}, align = {}, pos = {};
+    layering.forEach((layer) => {
+      layer.forEach((v, order) => {
+        root2[v] = v;
+        align[v] = v;
+        pos[v] = order;
+      });
+    });
+    layering.forEach((layer) => {
+      let prevIdx = -1;
+      layer.forEach((v) => {
+        let ws = neighborFn(v);
+        if (ws.length) {
+          ws = ws.sort((a, b) => pos[a] - pos[b]);
+          let mp = (ws.length - 1) / 2;
+          for (let i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+            let w = ws[i];
+            if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+              align[w] = v;
+              align[v] = root2[v] = root2[w];
+              prevIdx = pos[w];
+            }
+          }
+        }
+      });
+    });
+    return { root: root2, align };
+  }
+  function horizontalCompaction(g, layering, root2, align, reverseSep) {
+    let xs = {}, blockG = buildBlockGraph(g, layering, root2, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
+    function iterate(setXsFunc, nextNodesFunc) {
+      let stack = blockG.nodes();
+      let elem = stack.pop();
+      let 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((acc, e) => {
+        return Math.max(acc, xs[e.v] + blockG.edge(e));
+      }, 0);
+    }
+    function pass2(elem) {
+      let min = blockG.outEdges(elem).reduce((acc, e) => {
+        return Math.min(acc, xs[e.w] - blockG.edge(e));
+      }, Number.POSITIVE_INFINITY);
+      let node2 = g.node(elem);
+      if (min !== Number.POSITIVE_INFINITY && node2.borderType !== borderType) {
+        xs[elem] = Math.max(xs[elem], min);
+      }
+    }
+    iterate(pass1, blockG.predecessors.bind(blockG));
+    iterate(pass2, blockG.successors.bind(blockG));
+    Object.keys(align).forEach((v) => xs[v] = xs[root2[v]]);
+    return xs;
+  }
+  function buildBlockGraph(g, layering, root2, reverseSep) {
+    let blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+    layering.forEach((layer) => {
+      let u;
+      layer.forEach((v) => {
+        let vRoot = root2[v];
+        blockGraph.setNode(vRoot);
+        if (u) {
+          var uRoot = root2[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 Object.values(xss).reduce((currentMinAndXs, xs) => {
+      let max = Number.NEGATIVE_INFINITY;
+      let min = Number.POSITIVE_INFINITY;
+      Object.entries(xs).forEach(([v, x]) => {
+        let halfWidth = width(g, v) / 2;
+        max = Math.max(x + halfWidth, max);
+        min = Math.min(x - halfWidth, min);
+      });
+      const newMin = max - min;
+      if (newMin < currentMinAndXs[0]) {
+        currentMinAndXs = [newMin, xs];
+      }
+      return currentMinAndXs;
+    }, [Number.POSITIVE_INFINITY, null])[1];
+  }
+  function alignCoordinates(xss, alignTo) {
+    let alignToVals = Object.values(alignTo), alignToMin = util2.applyWithChunking(Math.min, alignToVals), alignToMax = util2.applyWithChunking(Math.max, alignToVals);
+    ["u", "d"].forEach((vert) => {
+      ["l", "r"].forEach((horiz) => {
+        let alignment = vert + horiz, xs = xss[alignment];
+        if (xs === alignTo) return;
+        let xsVals = Object.values(xs);
+        let delta = alignToMin - util2.applyWithChunking(Math.min, xsVals);
+        if (horiz !== "l") {
+          delta = alignToMax - util2.applyWithChunking(Math.max, xsVals);
+        }
+        if (delta) {
+          xss[alignment] = util2.mapValues(xs, (x) => x + delta);
+        }
+      });
+    });
+  }
+  function balance(xss, align) {
+    return util2.mapValues(xss.ul, (num, v) => {
+      if (align) {
+        return xss[align.toLowerCase()][v];
+      } else {
+        let xs = Object.values(xss).map((xs2) => xs2[v]).sort((a, b) => a - b);
+        return (xs[1] + xs[2]) / 2;
+      }
+    });
+  }
+  function positionX(g) {
+    let layering = util2.buildLayerMatrix(g);
+    let conflicts = Object.assign(
+      findType1Conflicts(g, layering),
+      findType2Conflicts(g, layering)
+    );
+    let xss = {};
+    let adjustedLayering;
+    ["u", "d"].forEach((vert) => {
+      adjustedLayering = vert === "u" ? layering : Object.values(layering).reverse();
+      ["l", "r"].forEach((horiz) => {
+        if (horiz === "r") {
+          adjustedLayering = adjustedLayering.map((inner) => {
+            return Object.values(inner).reverse();
+          });
+        }
+        let neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
+        let align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+        let xs = horizontalCompaction(
+          g,
+          adjustedLayering,
+          align.root,
+          align.align,
+          horiz === "r"
+        );
+        if (horiz === "r") {
+          xs = util2.mapValues(xs, (x) => -x);
+        }
+        xss[vert + horiz] = xs;
+      });
+    });
+    let smallestWidth = findSmallestWidthAlignment(g, xss);
+    alignCoordinates(xss, smallestWidth);
+    return balance(xss, g.graph().align);
+  }
+  function sep(nodeSep, edgeSep, reverseSep) {
+    return (g, v, w) => {
+      let vLabel = g.node(v);
+      let wLabel = g.node(w);
+      let sum = 0;
+      let delta;
+      sum += vLabel.width / 2;
+      if (Object.hasOwn(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.hasOwn(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;
+  }
+  return bk;
+}
+var position_1;
+var hasRequiredPosition;
+function requirePosition() {
+  if (hasRequiredPosition) return position_1;
+  hasRequiredPosition = 1;
+  let util2 = requireUtil$1();
+  let positionX = requireBk().positionX;
+  position_1 = position2;
+  function position2(g) {
+    g = util2.asNonCompoundGraph(g);
+    positionY(g);
+    Object.entries(positionX(g)).forEach(([v, x]) => g.node(v).x = x);
+  }
+  function positionY(g) {
+    let layering = util2.buildLayerMatrix(g);
+    let rankSep = g.graph().ranksep;
+    let prevY = 0;
+    layering.forEach((layer) => {
+      const maxHeight = layer.reduce((acc, v) => {
+        const height = g.node(v).height;
+        if (acc > height) {
+          return acc;
+        } else {
+          return height;
+        }
+      }, 0);
+      layer.forEach((v) => g.node(v).y = prevY + maxHeight / 2);
+      prevY += maxHeight + rankSep;
+    });
+  }
+  return position_1;
+}
+var layout_1;
+var hasRequiredLayout;
+function requireLayout() {
+  if (hasRequiredLayout) return layout_1;
+  hasRequiredLayout = 1;
+  let acyclic2 = requireAcyclic();
+  let normalize2 = requireNormalize();
+  let rank = requireRank();
+  let normalizeRanks = requireUtil$1().normalizeRanks;
+  let parentDummyChains = requireParentDummyChains();
+  let removeEmptyRanks = requireUtil$1().removeEmptyRanks;
+  let nestingGraph2 = requireNestingGraph();
+  let addBorderSegments = requireAddBorderSegments();
+  let coordinateSystem2 = requireCoordinateSystem();
+  let order = requireOrder();
+  let position2 = requirePosition();
+  let util2 = requireUtil$1();
+  let Graph = requireGraphlib().Graph;
+  layout_1 = layout;
+  function layout(g, opts) {
+    let time = opts && opts.debugTiming ? util2.time : util2.notime;
+    time("layout", () => {
+      let layoutGraph = time("  buildLayoutGraph", () => buildLayoutGraph(g));
+      time("  runLayout", () => runLayout(layoutGraph, time, opts));
+      time("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
+    });
+  }
+  function runLayout(g, time, opts) {
+    time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
+    time("    removeSelfEdges", () => removeSelfEdges(g));
+    time("    acyclic", () => acyclic2.run(g));
+    time("    nestingGraph.run", () => nestingGraph2.run(g));
+    time("    rank", () => rank(util2.asNonCompoundGraph(g)));
+    time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
+    time("    removeEmptyRanks", () => removeEmptyRanks(g));
+    time("    nestingGraph.cleanup", () => nestingGraph2.cleanup(g));
+    time("    normalizeRanks", () => normalizeRanks(g));
+    time("    assignRankMinMax", () => assignRankMinMax(g));
+    time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
+    time("    normalize.run", () => normalize2.run(g));
+    time("    parentDummyChains", () => parentDummyChains(g));
+    time("    addBorderSegments", () => addBorderSegments(g));
+    time("    order", () => order(g, opts));
+    time("    insertSelfEdges", () => insertSelfEdges(g));
+    time("    adjustCoordinateSystem", () => coordinateSystem2.adjust(g));
+    time("    position", () => position2(g));
+    time("    positionSelfEdges", () => positionSelfEdges(g));
+    time("    removeBorderNodes", () => removeBorderNodes(g));
+    time("    normalize.undo", () => normalize2.undo(g));
+    time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
+    time("    undoCoordinateSystem", () => coordinateSystem2.undo(g));
+    time("    translateGraph", () => translateGraph(g));
+    time("    assignNodeIntersects", () => assignNodeIntersects(g));
+    time("    reversePoints", () => reversePointsForReversedEdges(g));
+    time("    acyclic.undo", () => acyclic2.undo(g));
+  }
+  function updateInputGraph(inputGraph, layoutGraph) {
+    inputGraph.nodes().forEach((v) => {
+      let inputLabel = inputGraph.node(v);
+      let layoutLabel = layoutGraph.node(v);
+      if (inputLabel) {
+        inputLabel.x = layoutLabel.x;
+        inputLabel.y = layoutLabel.y;
+        inputLabel.rank = layoutLabel.rank;
+        if (layoutGraph.children(v).length) {
+          inputLabel.width = layoutLabel.width;
+          inputLabel.height = layoutLabel.height;
+        }
+      }
+    });
+    inputGraph.edges().forEach((e) => {
+      let inputLabel = inputGraph.edge(e);
+      let layoutLabel = layoutGraph.edge(e);
+      inputLabel.points = layoutLabel.points;
+      if (Object.hasOwn(layoutLabel, "x")) {
+        inputLabel.x = layoutLabel.x;
+        inputLabel.y = layoutLabel.y;
+      }
+    });
+    inputGraph.graph().width = layoutGraph.graph().width;
+    inputGraph.graph().height = layoutGraph.graph().height;
+  }
+  let graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+  let graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
+  let graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
+  let nodeNumAttrs = ["width", "height"];
+  let nodeDefaults = { width: 0, height: 0 };
+  let edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
+  let edgeDefaults = {
+    minlen: 1,
+    weight: 1,
+    width: 0,
+    height: 0,
+    labeloffset: 10,
+    labelpos: "r"
+  };
+  let edgeAttrs = ["labelpos"];
+  function buildLayoutGraph(inputGraph) {
+    let g = new Graph({ multigraph: true, compound: true });
+    let graph2 = canonicalize(inputGraph.graph());
+    g.setGraph(Object.assign(
+      {},
+      graphDefaults,
+      selectNumberAttrs(graph2, graphNumAttrs),
+      util2.pick(graph2, graphAttrs)
+    ));
+    inputGraph.nodes().forEach((v) => {
+      let node2 = canonicalize(inputGraph.node(v));
+      const newNode = selectNumberAttrs(node2, nodeNumAttrs);
+      Object.keys(nodeDefaults).forEach((k) => {
+        if (newNode[k] === void 0) {
+          newNode[k] = nodeDefaults[k];
+        }
+      });
+      g.setNode(v, newNode);
+      g.setParent(v, inputGraph.parent(v));
+    });
+    inputGraph.edges().forEach((e) => {
+      let edge2 = canonicalize(inputGraph.edge(e));
+      g.setEdge(e, Object.assign(
+        {},
+        edgeDefaults,
+        selectNumberAttrs(edge2, edgeNumAttrs),
+        util2.pick(edge2, edgeAttrs)
+      ));
+    });
+    return g;
+  }
+  function makeSpaceForEdgeLabels(g) {
+    let graph2 = g.graph();
+    graph2.ranksep /= 2;
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      edge2.minlen *= 2;
+      if (edge2.labelpos.toLowerCase() !== "c") {
+        if (graph2.rankdir === "TB" || graph2.rankdir === "BT") {
+          edge2.width += edge2.labeloffset;
+        } else {
+          edge2.height += edge2.labeloffset;
+        }
+      }
+    });
+  }
+  function injectEdgeLabelProxies(g) {
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      if (edge2.width && edge2.height) {
+        let v = g.node(e.v);
+        let w = g.node(e.w);
+        let label2 = { rank: (w.rank - v.rank) / 2 + v.rank, e };
+        util2.addDummyNode(g, "edge-proxy", label2, "_ep");
+      }
+    });
+  }
+  function assignRankMinMax(g) {
+    let maxRank = 0;
+    g.nodes().forEach((v) => {
+      let node2 = g.node(v);
+      if (node2.borderTop) {
+        node2.minRank = g.node(node2.borderTop).rank;
+        node2.maxRank = g.node(node2.borderBottom).rank;
+        maxRank = Math.max(maxRank, node2.maxRank);
+      }
+    });
+    g.graph().maxRank = maxRank;
+  }
+  function removeEdgeLabelProxies(g) {
+    g.nodes().forEach((v) => {
+      let node2 = g.node(v);
+      if (node2.dummy === "edge-proxy") {
+        g.edge(node2.e).labelRank = node2.rank;
+        g.removeNode(v);
+      }
+    });
+  }
+  function translateGraph(g) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = 0;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = 0;
+    let graphLabel = g.graph();
+    let marginX = graphLabel.marginx || 0;
+    let marginY = graphLabel.marginy || 0;
+    function getExtremes(attrs) {
+      let x = attrs.x;
+      let y = attrs.y;
+      let w = attrs.width;
+      let h2 = attrs.height;
+      minX = Math.min(minX, x - w / 2);
+      maxX = Math.max(maxX, x + w / 2);
+      minY = Math.min(minY, y - h2 / 2);
+      maxY = Math.max(maxY, y + h2 / 2);
+    }
+    g.nodes().forEach((v) => getExtremes(g.node(v)));
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      if (Object.hasOwn(edge2, "x")) {
+        getExtremes(edge2);
+      }
+    });
+    minX -= marginX;
+    minY -= marginY;
+    g.nodes().forEach((v) => {
+      let node2 = g.node(v);
+      node2.x -= minX;
+      node2.y -= minY;
+    });
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      edge2.points.forEach((p) => {
+        p.x -= minX;
+        p.y -= minY;
+      });
+      if (Object.hasOwn(edge2, "x")) {
+        edge2.x -= minX;
+      }
+      if (Object.hasOwn(edge2, "y")) {
+        edge2.y -= minY;
+      }
+    });
+    graphLabel.width = maxX - minX + marginX;
+    graphLabel.height = maxY - minY + marginY;
+  }
+  function assignNodeIntersects(g) {
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      let nodeV = g.node(e.v);
+      let nodeW = g.node(e.w);
+      let p1, p2;
+      if (!edge2.points) {
+        edge2.points = [];
+        p1 = nodeW;
+        p2 = nodeV;
+      } else {
+        p1 = edge2.points[0];
+        p2 = edge2.points[edge2.points.length - 1];
+      }
+      edge2.points.unshift(util2.intersectRect(nodeV, p1));
+      edge2.points.push(util2.intersectRect(nodeW, p2));
+    });
+  }
+  function fixupEdgeLabelCoords(g) {
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      if (Object.hasOwn(edge2, "x")) {
+        if (edge2.labelpos === "l" || edge2.labelpos === "r") {
+          edge2.width -= edge2.labeloffset;
+        }
+        switch (edge2.labelpos) {
+          case "l":
+            edge2.x -= edge2.width / 2 + edge2.labeloffset;
+            break;
+          case "r":
+            edge2.x += edge2.width / 2 + edge2.labeloffset;
+            break;
+        }
+      }
+    });
+  }
+  function reversePointsForReversedEdges(g) {
+    g.edges().forEach((e) => {
+      let edge2 = g.edge(e);
+      if (edge2.reversed) {
+        edge2.points.reverse();
+      }
+    });
+  }
+  function removeBorderNodes(g) {
+    g.nodes().forEach((v) => {
+      if (g.children(v).length) {
+        let node2 = g.node(v);
+        let t = g.node(node2.borderTop);
+        let b = g.node(node2.borderBottom);
+        let l = g.node(node2.borderLeft[node2.borderLeft.length - 1]);
+        let r = g.node(node2.borderRight[node2.borderRight.length - 1]);
+        node2.width = Math.abs(r.x - l.x);
+        node2.height = Math.abs(b.y - t.y);
+        node2.x = l.x + node2.width / 2;
+        node2.y = t.y + node2.height / 2;
+      }
+    });
+    g.nodes().forEach((v) => {
+      if (g.node(v).dummy === "border") {
+        g.removeNode(v);
+      }
+    });
+  }
+  function removeSelfEdges(g) {
+    g.edges().forEach((e) => {
+      if (e.v === e.w) {
+        var node2 = g.node(e.v);
+        if (!node2.selfEdges) {
+          node2.selfEdges = [];
+        }
+        node2.selfEdges.push({ e, label: g.edge(e) });
+        g.removeEdge(e);
+      }
+    });
+  }
+  function insertSelfEdges(g) {
+    var layers = util2.buildLayerMatrix(g);
+    layers.forEach((layer) => {
+      var orderShift = 0;
+      layer.forEach((v, i) => {
+        var node2 = g.node(v);
+        node2.order = i + orderShift;
+        (node2.selfEdges || []).forEach((selfEdge) => {
+          util2.addDummyNode(g, "selfedge", {
+            width: selfEdge.label.width,
+            height: selfEdge.label.height,
+            rank: node2.rank,
+            order: i + ++orderShift,
+            e: selfEdge.e,
+            label: selfEdge.label
+          }, "_se");
+        });
+        delete node2.selfEdges;
+      });
+    });
+  }
+  function positionSelfEdges(g) {
+    g.nodes().forEach((v) => {
+      var node2 = g.node(v);
+      if (node2.dummy === "selfedge") {
+        var selfNode = g.node(node2.e.v);
+        var x = selfNode.x + selfNode.width / 2;
+        var y = selfNode.y;
+        var dx = node2.x - x;
+        var dy = selfNode.height / 2;
+        g.setEdge(node2.e, node2.label);
+        g.removeNode(v);
+        node2.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 }
+        ];
+        node2.label.x = node2.x;
+        node2.label.y = node2.y;
+      }
+    });
+  }
+  function selectNumberAttrs(obj, attrs) {
+    return util2.mapValues(util2.pick(obj, attrs), Number);
+  }
+  function canonicalize(attrs) {
+    var newAttrs = {};
+    if (attrs) {
+      Object.entries(attrs).forEach(([k, v]) => {
+        if (typeof k === "string") {
+          k = k.toLowerCase();
+        }
+        newAttrs[k] = v;
+      });
+    }
+    return newAttrs;
+  }
+  return layout_1;
+}
+var debug;
+var hasRequiredDebug;
+function requireDebug() {
+  if (hasRequiredDebug) return debug;
+  hasRequiredDebug = 1;
+  let util2 = requireUtil$1();
+  let Graph = requireGraphlib().Graph;
+  debug = {
+    debugOrdering
+  };
+  function debugOrdering(g) {
+    let layerMatrix = util2.buildLayerMatrix(g);
+    let h2 = new Graph({ compound: true, multigraph: true }).setGraph({});
+    g.nodes().forEach((v) => {
+      h2.setNode(v, { label: v });
+      h2.setParent(v, "layer" + g.node(v).rank);
+    });
+    g.edges().forEach((e) => h2.setEdge(e.v, e.w, {}, e.name));
+    layerMatrix.forEach((layer, i) => {
+      let layerV = "layer" + i;
+      h2.setNode(layerV, { rank: "same" });
+      layer.reduce((u, v) => {
+        h2.setEdge(u, v, { style: "invis" });
+        return v;
+      });
+    });
+    return h2;
+  }
+  return debug;
+}
+var version;
+var hasRequiredVersion;
+function requireVersion() {
+  if (hasRequiredVersion) return version;
+  hasRequiredVersion = 1;
+  version = "1.1.4";
+  return version;
+}
+var dagre$1;
+var hasRequiredDagre;
+function requireDagre() {
+  if (hasRequiredDagre) return dagre$1;
+  hasRequiredDagre = 1;
+  dagre$1 = {
+    graphlib: requireGraphlib(),
+    layout: requireLayout(),
+    debug: requireDebug(),
+    util: {
+      time: requireUtil$1().time,
+      notime: requireUtil$1().notime
+    },
+    version: requireVersion()
+  };
+  return dagre$1;
+}
+var dagreExports = requireDagre();
+const dagre = /* @__PURE__ */ getDefaultExportFromCjs(dagreExports);
+const NODE_X_SPACING = GRID_SIZE * 6;
+const NODE_Y_SPACING = GRID_SIZE * 5;
+const SUBGRAPH_SPACING = GRID_SIZE * 8;
+const AI_X_SPACING = GRID_SIZE * 2;
+const AI_Y_SPACING = GRID_SIZE * 6;
+const STICKY_BOTTOM_PADDING = GRID_SIZE * 3;
+function useCanvasLayout({ id: canvasId } = {}) {
+  const {
+    findNode,
+    findEdge,
+    getSelectedNodes,
+    edges: allEdges,
+    nodes: allNodes
+  } = useVueFlow({ id: canvasId });
+  function getTargetData(target2) {
+    if (target2 === "selection") {
+      return { nodes: getSelectedNodes.value, edges: allEdges.value };
+    }
+    return { nodes: allNodes.value, edges: allEdges.value };
+  }
+  function sortByPosition(posA, posB) {
+    const yDiff = posA.y - posB.y;
+    return yDiff === 0 ? posA.x - posB.x : yDiff;
+  }
+  function sortNodesByPosition(nodeA, nodeB) {
+    const hasEdgesA = allEdges.value.some((edge2) => edge2.target === nodeA.id);
+    const hasEdgesB = allEdges.value.some((edge2) => edge2.target === nodeB.id);
+    if (!hasEdgesA && hasEdgesB) return -1;
+    if (hasEdgesA && !hasEdgesB) return 1;
+    return sortByPosition(nodeA.position, nodeB.position);
+  }
+  function sortEdgesByPosition(edgeA, edgeB) {
+    return sortByPosition(positionFromEdge(edgeA), positionFromEdge(edgeB));
+  }
+  function positionFromEdge(edge2) {
+    return { x: edge2.targetX, y: edge2.targetY };
+  }
+  function createDagreGraph({ nodes, edges }) {
+    const graph2 = new dagre.graphlib.Graph();
+    graph2.setDefaultEdgeLabel(() => ({}));
+    const graphNodes = nodes.map((node2) => findNode(node2.id)).filter(isPresent).sort(sortNodesByPosition);
+    const nodeIdSet = new Set(nodes.map((node2) => node2.id));
+    graphNodes.forEach(({ id: nodeId, position: { x, y }, dimensions: { width, height } }) => {
+      graph2.setNode(nodeId, { width, height, x, y });
+    });
+    edges.map((node2) => findEdge(node2.id)).filter(isPresent).filter((edge2) => nodeIdSet.has(edge2.source) && nodeIdSet.has(edge2.target)).sort(sortEdgesByPosition).forEach((edge2) => graph2.setEdge(edge2.source, edge2.target));
+    return graph2;
+  }
+  function createDagreSubGraph({
+    nodeIds,
+    parent
+  }) {
+    const subGraph = new dagre.graphlib.Graph();
+    subGraph.setGraph({
+      rankdir: "LR",
+      edgesep: NODE_Y_SPACING,
+      nodesep: NODE_Y_SPACING,
+      ranksep: NODE_X_SPACING
+    });
+    subGraph.setDefaultEdgeLabel(() => ({}));
+    const nodeIdSet = new Set(nodeIds);
+    parent.nodes().filter((nodeId) => nodeIdSet.has(nodeId)).forEach((nodeId) => {
+      subGraph.setNode(nodeId, parent.node(nodeId));
+    });
+    parent.edges().filter((edge2) => nodeIdSet.has(edge2.v) && nodeIdSet.has(edge2.w)).forEach((edge2) => subGraph.setEdge(edge2.v, edge2.w, parent.edge(edge2)));
+    return subGraph;
+  }
+  function createDagreVerticalGraph({ nodes }) {
+    const subGraph = new dagre.graphlib.Graph();
+    subGraph.setGraph({
+      rankdir: "TB",
+      align: "UL",
+      edgesep: SUBGRAPH_SPACING,
+      nodesep: SUBGRAPH_SPACING,
+      ranksep: SUBGRAPH_SPACING
+    });
+    subGraph.setDefaultEdgeLabel(() => ({}));
+    nodes.forEach(
+      ({ id: id2, box: { x, y, width, height } }) => subGraph.setNode(id2, { x, y, width, height })
+    );
+    nodes.forEach((node2, index) => {
+      if (!nodes[index + 1]) return;
+      subGraph.setEdge(node2.id, nodes[index + 1].id);
+    });
+    return subGraph;
+  }
+  function createAiSubGraph({
+    parent,
+    nodeIds
+  }) {
+    const subGraph = new dagre.graphlib.Graph();
+    subGraph.setGraph({
+      rankdir: "TB",
+      edgesep: AI_X_SPACING,
+      nodesep: AI_X_SPACING,
+      ranksep: AI_Y_SPACING
+    });
+    subGraph.setDefaultEdgeLabel(() => ({}));
+    const nodeIdSet = new Set(nodeIds);
+    parent.nodes().filter((nodeId) => nodeIdSet.has(nodeId)).forEach((nodeId) => {
+      subGraph.setNode(nodeId, parent.node(nodeId));
+    });
+    parent.edges().filter((edge2) => nodeIdSet.has(edge2.v) && nodeIdSet.has(edge2.w)).forEach((edge2) => subGraph.setEdge(edge2.w, edge2.v));
+    return subGraph;
+  }
+  function compositeBoundingBox(boxes) {
+    const { minX, minY, maxX, maxY } = boxes.reduce(
+      (bbox, node2) => {
+        const { x, y, width, height } = node2;
+        return {
+          minX: Math.min(bbox.minX, x),
+          maxX: Math.max(bbox.maxX, x + width),
+          minY: Math.min(bbox.minY, y),
+          maxY: Math.max(bbox.maxY, y + height)
+        };
+      },
+      { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity }
+    );
+    return {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY
+    };
+  }
+  function boundingBoxFromCanvasNode(node2) {
+    return {
+      x: node2.position.x,
+      y: node2.position.y,
+      width: node2.dimensions.width,
+      height: node2.dimensions.height
+    };
+  }
+  function boundingBoxFromDagreNode(node2) {
+    return {
+      x: node2.x - node2.width / 2,
+      y: node2.y - node2.height / 2,
+      width: node2.width,
+      height: node2.height
+    };
+  }
+  function boundingBoxFromGraph(graph2) {
+    return compositeBoundingBox(
+      graph2.nodes().map((nodeId) => boundingBoxFromDagreNode(graph2.node(nodeId)))
+    );
+  }
+  function boundingBoxFromCanvasNodes(nodes) {
+    return compositeBoundingBox(nodes.map(boundingBoxFromCanvasNode));
+  }
+  function isCoveredBy(parent, child) {
+    const childRight = child.x + child.width;
+    const childBottom = child.y + child.height;
+    const parentRight = parent.x + parent.width;
+    const parentBottom = parent.y + parent.height;
+    return child.x >= parent.x && child.y >= parent.y && childRight <= parentRight && childBottom <= parentBottom;
+  }
+  function centerHorizontally(container2, target2) {
+    const containerCenter = container2.x + container2.width / 2;
+    const newX = containerCenter - target2.width / 2;
+    return newX;
+  }
+  function intersects(container2, target2, padding = 0) {
+    const targetWithPadding = {
+      x: target2.x - padding,
+      y: target2.y - padding,
+      width: target2.width + padding * 2,
+      height: target2.height + padding * 2
+    };
+    const noIntersection = targetWithPadding.x + targetWithPadding.width < container2.x || targetWithPadding.x > container2.x + container2.width || targetWithPadding.y + targetWithPadding.height < container2.y || targetWithPadding.y > container2.y + container2.height;
+    return !noIntersection;
+  }
+  function isAiParentNode(node2) {
+    return node2.render.type === CanvasNodeRenderType.Default && node2.render.options.configurable && !node2.render.options.configuration;
+  }
+  function isAiConfigNode(node2) {
+    return node2.render.type === CanvasNodeRenderType.Default && node2.render.options.configuration;
+  }
+  function getAllConnectedAiConfigNodes({
+    graph: graph2,
+    root: root2,
+    nodeById
+  }) {
+    return graph2.predecessors(root2.id).map((successor) => nodeById[successor]).filter((node2) => isAiConfigNode(node2.data)).flatMap((node2) => [
+      node2.id,
+      ...getAllConnectedAiConfigNodes({ graph: graph2, root: node2.data, nodeById })
+    ]);
+  }
+  function layout(target2) {
+    const { nodes, edges } = getTargetData(target2);
+    const nonStickyNodes = nodes.filter((node2) => node2.data.type !== STICKY_NODE_TYPE).map((node2) => findNode(node2.id)).filter(isPresent);
+    const boundingBoxBefore = boundingBoxFromCanvasNodes(nonStickyNodes);
+    const parentGraph = createDagreGraph({ nodes: nonStickyNodes, edges });
+    const nodeById = nonStickyNodes.reduce((acc, node2) => {
+      acc[node2.id] = node2;
+      return acc;
+    }, {});
+    const subgraphs = dagre.graphlib.alg.components(parentGraph).map((nodeIds) => {
+      const subgraph = createDagreSubGraph({ nodeIds, parent: parentGraph });
+      const aiParentNodes = subgraph.nodes().map((nodeId) => nodeById[nodeId].data).filter(isAiParentNode);
+      const aiGraphs = aiParentNodes.map((aiParentNode) => {
+        const configNodeIds = getAllConnectedAiConfigNodes({
+          graph: subgraph,
+          nodeById,
+          root: aiParentNode
+        });
+        const allAiNodeIds = configNodeIds.concat(aiParentNode.id);
+        const aiGraph = createAiSubGraph({
+          parent: subgraph,
+          nodeIds: allAiNodeIds
+        });
+        configNodeIds.forEach((nodeId) => subgraph.removeNode(nodeId));
+        const rootEdges = subgraph.edges().filter((edge2) => edge2.v === aiParentNode.id || edge2.w === aiParentNode.id);
+        dagre.layout(aiGraph, { disableOptimalOrderHeuristic: true });
+        const aiBoundingBox = boundingBoxFromGraph(aiGraph);
+        subgraph.setNode(aiParentNode.id, {
+          width: aiBoundingBox.width,
+          height: aiBoundingBox.height
+        });
+        rootEdges.forEach((edge2) => subgraph.setEdge(edge2));
+        return { graph: aiGraph, boundingBox: aiBoundingBox, aiParentNode };
+      });
+      dagre.layout(subgraph, { disableOptimalOrderHeuristic: true });
+      return { graph: subgraph, aiGraphs, boundingBox: boundingBoxFromGraph(subgraph) };
+    });
+    const compositeGraph = createDagreVerticalGraph({
+      nodes: subgraphs.map(({ boundingBox }, index) => ({
+        box: boundingBox,
+        id: index.toString()
+      }))
+    });
+    dagre.layout(compositeGraph, { disableOptimalOrderHeuristic: true });
+    const boundingBoxByNodeId = subgraphs.flatMap(({ graph: graph2, aiGraphs }, index) => {
+      const subgraphPosition = compositeGraph.node(index.toString());
+      const aiParentNodes = new Set(aiGraphs.map(({ aiParentNode }) => aiParentNode.id));
+      const offset = {
+        x: 0,
+        y: subgraphPosition.y - subgraphPosition.height / 2
+      };
+      return graph2.nodes().flatMap((nodeId) => {
+        const { x, y, width, height } = graph2.node(nodeId);
+        const positionedNode = {
+          id: nodeId,
+          boundingBox: {
+            x: x + offset.x - width / 2,
+            y: y + offset.y - height / 2,
+            width,
+            height
+          }
+        };
+        if (aiParentNodes.has(nodeId)) {
+          const aiGraph = aiGraphs.find(({ aiParentNode }) => aiParentNode.id === nodeId);
+          if (!aiGraph) return [];
+          const aiParentNodeBox = positionedNode.boundingBox;
+          const parentOffset = {
+            x: aiParentNodeBox.x,
+            y: aiParentNodeBox.y
+          };
+          return aiGraph.graph.nodes().map((aiNodeId) => {
+            const aiNode = aiGraph.graph.node(aiNodeId);
+            const aiBoundingBox = {
+              x: aiNode.x + parentOffset.x - aiNode.width / 2,
+              y: aiNode.y + parentOffset.y - aiNode.height / 2,
+              width: aiNode.width,
+              height: aiNode.height
+            };
+            return {
+              id: aiNodeId,
+              boundingBox: aiBoundingBox
+            };
+          });
+        }
+        return positionedNode;
+      });
+    }).reduce(
+      (acc, node2) => {
+        acc[node2.id] = node2.boundingBox;
+        return acc;
+      },
+      {}
+    );
+    subgraphs.flatMap(({ aiGraphs }) => aiGraphs).forEach(({ graph: graph2 }) => {
+      const aiNodes = graph2.nodes();
+      const aiGraphBoundingBox = compositeBoundingBox(
+        aiNodes.map((nodeId) => boundingBoxByNodeId[nodeId]).filter(isPresent)
+      );
+      const aiNodeVerticalCorrection = aiGraphBoundingBox.height / 2 - NODE_SIZE / 2;
+      aiGraphBoundingBox.y += aiNodeVerticalCorrection;
+      const hasConflictingNodes = Object.entries(boundingBoxByNodeId).filter(([id2]) => !graph2.hasNode(id2)).some(
+        ([, nodeBoundingBox]) => intersects(aiGraphBoundingBox, nodeBoundingBox, NODE_Y_SPACING)
+      );
+      if (!hasConflictingNodes) {
+        for (const aiNode of aiNodes) {
+          boundingBoxByNodeId[aiNode].y += aiNodeVerticalCorrection;
+        }
+      }
+    });
+    const positionedNodes = Object.entries(boundingBoxByNodeId).map(([id2, boundingBox]) => ({
+      id: id2,
+      boundingBox
+    }));
+    const boundingBoxAfter = compositeBoundingBox(positionedNodes.map((node2) => node2.boundingBox));
+    const anchor = {
+      x: boundingBoxAfter.x - boundingBoxBefore.x,
+      y: boundingBoxAfter.y - boundingBoxBefore.y
+    };
+    const stickies = nodes.filter((node2) => node2.data.type === STICKY_NODE_TYPE).map((node2) => findNode(node2.id)).filter(isPresent);
+    const positionedStickies = stickies.map((sticky2) => {
+      const stickyBox = boundingBoxFromCanvasNode(sticky2);
+      const coveredNodes = nonStickyNodes.filter(
+        (node2) => isCoveredBy(boundingBoxFromCanvasNode(sticky2), boundingBoxFromCanvasNode(node2))
+      );
+      if (coveredNodes.length === 0) return null;
+      const coveredNodesBoxAfter = compositeBoundingBox(
+        positionedNodes.filter((node2) => coveredNodes.some((covered) => covered.id === node2.id)).map(({ boundingBox }) => boundingBox)
+      );
+      return {
+        id: sticky2.id,
+        boundingBox: {
+          x: centerHorizontally(coveredNodesBoxAfter, stickyBox),
+          y: coveredNodesBoxAfter.y + coveredNodesBoxAfter.height - stickyBox.height + STICKY_BOTTOM_PADDING,
+          height: stickyBox.height,
+          width: stickyBox.width
+        }
+      };
+    }).filter(isPresent);
+    return {
+      boundingBox: boundingBoxAfter,
+      nodes: positionedNodes.concat(positionedStickies).map(({ id: id2, boundingBox }) => {
+        return {
+          id: id2,
+          x: boundingBox.x - anchor.x,
+          y: boundingBox.y - anchor.y
+        };
+      })
+    };
+  }
+  return { layout };
+}
+const renameKeyCode = " ";
+const defaultZoom = 1;
+const minimapVisibilityDelay = 1e3;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Canvas",
+  props: {
+    id: { default: "canvas" },
+    nodes: { default: () => [] },
+    connections: { default: () => [] },
+    controlsPosition: { default: PanelPosition.BottomLeft },
+    eventBus: { default: () => createEventBus() },
+    readOnly: { type: Boolean, default: false },
+    executing: { type: Boolean, default: false },
+    keyBindings: { type: Boolean, default: true },
+    loading: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "update:node:position", "update:nodes:position", "update:node:activated", "update:node:deactivated", "update:node:enabled", "update:node:selected", "update:node:name", "update:node:parameters", "update:node:inputs", "update:node:outputs", "click:node", "click:node:add", "run:node", "delete:node", "create:node", "create:sticky", "delete:nodes", "update:nodes:enabled", "copy:nodes", "duplicate:nodes", "update:nodes:pin", "cut:nodes", "delete:connection", "create:connection:start", "create:connection", "create:connection:end", "create:connection:cancelled", "click:connection:add", "click:pane", "run:workflow", "save:workflow", "create:workflow", "drag-and-drop"],
+  setup(__props, { emit: __emit }) {
+    const $style = useCssModule();
+    const emit = __emit;
+    const props = __props;
+    const { isMobileDevice, controlKeyCode } = useDeviceSupport();
+    const vueFlow = useVueFlow({ id: props.id, deleteKeyCode: null });
+    const {
+      getSelectedNodes: selectedNodes,
+      addSelectedNodes,
+      removeSelectedNodes,
+      viewportRef,
+      fitView,
+      zoomIn,
+      zoomOut,
+      zoomTo,
+      setInteractive,
+      elementsSelectable,
+      project,
+      nodes: graphNodes,
+      onPaneReady,
+      onNodesInitialized,
+      findNode,
+      viewport,
+      onEdgeMouseLeave,
+      onEdgeMouseEnter,
+      onEdgeMouseMove,
+      onNodeMouseEnter,
+      onNodeMouseLeave
+    } = vueFlow;
+    const {
+      getIncomingNodes,
+      getOutgoingNodes,
+      getSiblingNodes,
+      getDownstreamNodes,
+      getUpstreamNodes
+    } = useCanvasTraversal(vueFlow);
+    const { layout } = useCanvasLayout({ id: props.id });
+    const isPaneReady = ref(false);
+    const classes = computed(() => ({
+      [$style.canvas]: true,
+      [$style.ready]: !props.loading && isPaneReady.value
+    }));
+    const panningKeyCode = ref(isMobileDevice ? true : [" ", controlKeyCode]);
+    const panningMouseButton = ref(isMobileDevice ? true : [1]);
+    const selectionKeyCode = ref(isMobileDevice ? "Shift" : true);
+    function switchToPanningMode() {
+      selectionKeyCode.value = null;
+      panningMouseButton.value = [0, 1];
+    }
+    function switchToSelectionMode() {
+      selectionKeyCode.value = true;
+      panningMouseButton.value = [1];
+    }
+    onKeyDown(panningKeyCode.value, switchToPanningMode, {
+      dedupe: true
+    });
+    onKeyUp(panningKeyCode.value, switchToSelectionMode);
+    useShortKeyPress(
+      renameKeyCode,
+      () => {
+        if (lastSelectedNode.value) {
+          emit("update:node:name", lastSelectedNode.value.id);
+        }
+      },
+      {
+        disabled: toRef(props, "readOnly")
+      }
+    );
+    const disableKeyBindings = computed(() => !props.keyBindings);
+    function selectLeftNode(id2) {
+      const incomingNodes = getIncomingNodes(id2);
+      const previousNode = incomingNodes[0];
+      if (previousNode) {
+        onSelectNodes({ ids: [previousNode.id] });
+      }
+    }
+    function selectRightNode(id2) {
+      const outgoingNodes = getOutgoingNodes(id2);
+      const nextNode = outgoingNodes[0];
+      if (nextNode) {
+        onSelectNodes({ ids: [nextNode.id] });
+      }
+    }
+    function selectLowerSiblingNode(id2) {
+      const siblingNodes = getSiblingNodes(id2);
+      const index = siblingNodes.findIndex((n) => n.id === id2);
+      const nextNode = siblingNodes[index + 1] ?? siblingNodes[0];
+      if (nextNode) {
+        onSelectNodes({
+          ids: [nextNode.id]
+        });
+      }
+    }
+    function selectUpperSiblingNode(id2) {
+      const siblingNodes = getSiblingNodes(id2);
+      const index = siblingNodes.findIndex((n) => n.id === id2);
+      const previousNode = siblingNodes[index - 1] ?? siblingNodes[siblingNodes.length - 1];
+      if (previousNode) {
+        onSelectNodes({
+          ids: [previousNode.id]
+        });
+      }
+    }
+    function selectDownstreamNodes(id2) {
+      const downstreamNodes = getDownstreamNodes(id2);
+      onSelectNodes({ ids: [...downstreamNodes.map((node2) => node2.id), id2] });
+    }
+    function selectUpstreamNodes(id2) {
+      const upstreamNodes = getUpstreamNodes(id2);
+      onSelectNodes({ ids: [...upstreamNodes.map((node2) => node2.id), id2] });
+    }
+    const keyMap = computed(() => {
+      const readOnlyKeymap = {
+        ctrl_c: emitWithSelectedNodes((ids) => emit("copy:nodes", ids)),
+        enter: emitWithLastSelectedNode((id2) => onSetNodeActivated(id2)),
+        ctrl_a: () => addSelectedNodes(graphNodes.value),
+        // Support both key and code for zooming in and out
+        "shift_+|+|=|shift_Equal|Equal": async () => await onZoomIn(),
+        "shift+_|-|_|shift_Minus|Minus": async () => await onZoomOut(),
+        0: async () => await onResetZoom(),
+        1: async () => await onFitView(),
+        ArrowUp: emitWithLastSelectedNode(selectUpperSiblingNode),
+        ArrowDown: emitWithLastSelectedNode(selectLowerSiblingNode),
+        ArrowLeft: emitWithLastSelectedNode(selectLeftNode),
+        ArrowRight: emitWithLastSelectedNode(selectRightNode),
+        shift_ArrowLeft: emitWithLastSelectedNode(selectUpstreamNodes),
+        shift_ArrowRight: emitWithLastSelectedNode(selectDownstreamNodes)
+      };
+      if (props.readOnly) return readOnlyKeymap;
+      const fullKeymap = {
+        ...readOnlyKeymap,
+        ctrl_x: emitWithSelectedNodes((ids) => emit("cut:nodes", ids)),
+        "delete|backspace": emitWithSelectedNodes((ids) => emit("delete:nodes", ids)),
+        ctrl_d: emitWithSelectedNodes((ids) => emit("duplicate:nodes", ids)),
+        d: emitWithSelectedNodes((ids) => emit("update:nodes:enabled", ids)),
+        p: emitWithSelectedNodes((ids) => emit("update:nodes:pin", ids, "keyboard-shortcut")),
+        f2: emitWithLastSelectedNode((id2) => emit("update:node:name", id2)),
+        tab: () => emit("create:node", "tab"),
+        shift_s: () => emit("create:sticky"),
+        ctrl_alt_n: () => emit("create:workflow"),
+        ctrl_enter: () => emit("run:workflow"),
+        ctrl_s: () => emit("save:workflow"),
+        shift_alt_t: onTidyUp
+      };
+      return fullKeymap;
+    });
+    useKeybindings(keyMap, { disabled: disableKeyBindings });
+    const hasSelection = computed(() => selectedNodes.value.length > 0);
+    const selectedNodeIds = computed(() => selectedNodes.value.map((node2) => node2.id));
+    const lastSelectedNode = ref();
+    const triggerNodes = computed(
+      () => props.nodes.filter(
+        (node2) => node2.data?.render.type === CanvasNodeRenderType.Default && node2.data.render.options.trigger
+      )
+    );
+    const hoveredTriggerNode = useCanvasNodeHover(triggerNodes, vueFlow, (nodeRect) => ({
+      x: nodeRect.x - nodeRect.width * 2,
+      // should cover the width of trigger button
+      y: nodeRect.y - nodeRect.height,
+      width: nodeRect.width * 4,
+      height: nodeRect.height * 3
+    }));
+    watch(selectedNodes, (nodes) => {
+      if (!lastSelectedNode.value || !nodes.find((node2) => node2.id === lastSelectedNode.value?.id)) {
+        lastSelectedNode.value = nodes[nodes.length - 1];
+      }
+    });
+    function onClickNodeAdd(id2, handle2) {
+      emit("click:node:add", id2, handle2);
+    }
+    function onUpdateNodesPosition(events) {
+      emit("update:nodes:position", events);
+    }
+    function onUpdateNodePosition(id2, position2) {
+      emit("update:node:position", id2, position2);
+    }
+    function onNodeDragStop(event) {
+      onUpdateNodesPosition(event.nodes.map(({ id: id2, position: position2 }) => ({ id: id2, position: position2 })));
     }
     function onNodeClick({ event, node: node2 }) {
       emit("click:node", node2.id);
@@ -17242,9 +21197,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     function onSelectionDragStop(event) {
       onUpdateNodesPosition(event.nodes.map(({ id: id2, position: position2 }) => ({ id: id2, position: position2 })));
     }
-    function onSetNodeActive(id2) {
-      props.eventBus.emit("nodes:action", { ids: [id2], action: "update:node:active" });
-      emit("update:node:active", id2);
+    function onSetNodeActivated(id2) {
+      props.eventBus.emit("nodes:action", { ids: [id2], action: "update:node:activated" });
+      emit("update:node:activated", id2);
+    }
+    function onSetNodeDeactivated(id2) {
+      emit("update:node:deactivated", id2);
     }
     function clearSelectedNodes() {
       removeSelectedNodes(selectedNodes.value);
@@ -17412,7 +21370,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
       contextMenu2.open(event, { source, nodeId: id2 });
     }
-    function onContextMenuAction(action, nodeIds) {
+    async function onContextMenuAction(action, nodeIds) {
       switch (action) {
         case "add_node":
           return emit("create:node", "context_menu");
@@ -17435,11 +21393,22 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         case "toggle_activation":
           return emit("update:nodes:enabled", nodeIds);
         case "open":
-          return onSetNodeActive(nodeIds[0]);
+          return onSetNodeActivated(nodeIds[0]);
         case "rename":
           return emit("update:node:name", nodeIds[0]);
         case "change_color":
           return props.eventBus.emit("nodes:action", { ids: nodeIds, action: "update:sticky:color" });
+        case "tidy_up":
+          return await onTidyUp();
+      }
+    }
+    async function onTidyUp() {
+      const applyOnSelection = selectedNodes.value.length > 1;
+      const { nodes } = layout(applyOnSelection ? "selection" : "all");
+      onUpdateNodesPosition(nodes.map((node2) => ({ id: node2.id, position: { x: node2.x, y: node2.y } })));
+      if (!applyOnSelection) {
+        await nextTick();
+        await onFitView();
       }
     }
     function onDragOver(event) {
@@ -17512,7 +21481,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     });
     return (_ctx, _cache) => {
       const _component_CanvasConnectionLine = __unplugin_components_0$6;
-      const _component_CanvasControlButtons = _sfc_main$v;
+      const _component_CanvasControlButtons = __unplugin_components_1$1;
       return openBlock(), createBlock(unref(_sfc_main$1$4), {
         id: _ctx.id,
         nodes: _ctx.nodes,
@@ -17556,7 +21525,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             onRun: onRunNode,
             onSelect: onSelectNode,
             onToggle: onToggleNodeEnabled,
-            onActivate: onSetNodeActive,
+            onActivate: onSetNodeActivated,
+            onDeactivate: onSetNodeDeactivated,
             "onOpen:contextmenu": onOpenNodeContextMenu,
             onUpdate: onUpdateNodeParameters,
             "onUpdate:inputs": onUpdateNodeInputs,
@@ -17622,7 +21592,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             onZoomToFit: onFitView,
             onZoomIn,
             onZoomOut,
-            onResetZoom
+            onResetZoom,
+            onTidyUp
           }, null, 8, ["class", "position", "zoom"]),
           (openBlock(), createBlock(Suspense, null, {
             default: withCtx(() => [
@@ -17645,7 +21616,7 @@ const style0 = {
 const cssModules = {
   "$style": style0
 };
-const __unplugin_components_0 = /* @__PURE__ */ _export_sfc$1(_sfc_main, [["__cssModules", cssModules], ["__scopeId", "data-v-24a2ded6"]]);
+const __unplugin_components_0 = /* @__PURE__ */ _export_sfc$1(_sfc_main, [["__cssModules", cssModules], ["__scopeId", "data-v-ef2140b6"]]);
 function useCanvasMapping({
   nodes,
   connections,
@@ -17655,6 +21626,7 @@ function useCanvasMapping({
   const workflowsStore = useWorkflowsStore();
   const nodeTypesStore = useNodeTypesStore();
   const nodeHelpers = useNodeHelpers();
+  const { dirtinessByName } = useNodeDirtiness();
   function createStickyNoteRenderType(node2) {
     return {
       type: CanvasNodeRenderType.StickyNote,
@@ -17685,7 +21657,8 @@ function useCanvasMapping({
         outputs: {
           labelSize: nodeOutputLabelSizeById.value[node2.id]
         },
-        tooltip: nodeTooltipById.value[node2.id]
+        tooltip: nodeTooltipById.value[node2.id],
+        dirtiness: dirtinessByName.value[node2.name]
       }
     };
   }