@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/@antv/x6/es/view/edge.js

@@ -0,0 +1,1074 @@
+import { Angle as _ } from "../../../x6-geometry/es/angle.js";
+import { Point as A } from "../../../x6-geometry/es/point.js";
+import { Line as R } from "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as k } from "../../../x6-geometry/es/rectangle.js";
+import { Path as G } from "../../../x6-geometry/es/path/path.js";
+import "../../../x6-geometry/es/util.js";
+import "../../../x6-geometry/es/curve.js";
+import { Polyline as j } from "../../../x6-geometry/es/polyline.js";
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { isPercentage as J } from "../../../x6-common/es/number/number.js";
+import { call as P } from "../../../x6-common/es/function/function.js";
+import "../../../x6-common/es/platform/index.js";
+import { createSvgElement as W, findParentByClass as q } from "../../../x6-common/es/dom/elem.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import "../../../x6-common/es/dom/prefix.js";
+import { Vector as B } from "../../../x6-common/es/vector/index.js";
+import { matrixToTransformString as X, createSVGMatrix as K } from "../../../x6-common/es/dom/matrix.js";
+import "../../../x6-common/es/dom/event/hook.js";
+import "../../../x6-common/es/dom/event/main.js";
+import "../../../x6-common/es/dom/event/object.js";
+import "../../../x6-common/es/size-sensor/index.js";
+import "../../../x6-common/es/algorithm/priorityqueue.js";
+import "../../../x6-common/es/algorithm/dijkstra.js";
+import "../../../x6-common/es/color/index.js";
+import "../../../x6-common/es/modifier/index.js";
+import "../../../x6-common/es/animation/timing.js";
+import "../../../x6-common/es/animation/interp.js";
+import "../registry/grid/index.js";
+import "../registry/background/index.js";
+import "../registry/filter/index.js";
+import "../registry/attr/index.js";
+import "../registry/highlighter/index.js";
+import "../registry/port-layout/index.js";
+import "../registry/port-label-layout/index.js";
+import "../registry/tool/index.js";
+import "../registry/marker/index.js";
+import { NodeAnchor as z } from "../registry/node-anchor/index.js";
+import { EdgeAnchor as F } from "../registry/edge-anchor/index.js";
+import { ConnectionPoint as U } from "../registry/connection-point/index.js";
+import { Router as S } from "../registry/router/index.js";
+import { Connector as x } from "../registry/connector/index.js";
+import "../registry/registry.js";
+import { Edge as Z } from "../model/edge.js";
+import { CellView as H } from "./cell.js";
+import { NodeView as Q } from "./node.js";
+import T from "../../../../lodash-es/has.js";
+import N from "../../../../lodash-es/merge.js";
+import Y from "../../../../lodash-es/clone.js";
+var tt = function(M, t) {
+  var n = {};
+  for (var e in M) Object.prototype.hasOwnProperty.call(M, e) && t.indexOf(e) < 0 && (n[e] = M[e]);
+  if (M != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, e = Object.getOwnPropertySymbols(M); i < e.length; i++)
+      t.indexOf(e[i]) < 0 && Object.prototype.propertyIsEnumerable.call(M, e[i]) && (n[e[i]] = M[e[i]]);
+  return n;
+};
+class E extends H {
+  constructor() {
+    super(...arguments), this.POINT_ROUNDING = 2, this.labelDestroyFn = {};
+  }
+  get [Symbol.toStringTag]() {
+    return E.toStringTag;
+  }
+  getContainerClassName() {
+    return [super.getContainerClassName(), this.prefixClassName("edge")].join(" ");
+  }
+  get sourceBBox() {
+    const t = this.sourceView;
+    if (!t) {
+      const e = this.cell.getSource();
+      return new k(e.x, e.y);
+    }
+    const n = this.sourceMagnet;
+    return t.isEdgeElement(n) ? new k(this.sourceAnchor.x, this.sourceAnchor.y) : t.getBBoxOfElement(n || t.container);
+  }
+  get targetBBox() {
+    const t = this.targetView;
+    if (!t) {
+      const e = this.cell.getTarget();
+      return new k(e.x, e.y);
+    }
+    const n = this.targetMagnet;
+    return t.isEdgeElement(n) ? new k(this.targetAnchor.x, this.targetAnchor.y) : t.getBBoxOfElement(n || t.container);
+  }
+  isEdgeView() {
+    return !0;
+  }
+  confirmUpdate(t, n = {}) {
+    let e = t;
+    if (this.hasAction(e, "source")) {
+      if (!this.updateTerminalProperties("source"))
+        return e;
+      e = this.removeAction(e, "source");
+    }
+    if (this.hasAction(e, "target")) {
+      if (!this.updateTerminalProperties("target"))
+        return e;
+      e = this.removeAction(e, "target");
+    }
+    return this.hasAction(e, "render") ? (this.render(), e = this.removeAction(e, ["render", "update", "labels", "tools"]), e) : (e = this.handleAction(e, "update", () => this.update(n)), e = this.handleAction(e, "labels", () => this.onLabelsChange(n)), e = this.handleAction(e, "tools", () => this.renderTools()), e);
+  }
+  // #region render
+  render() {
+    return this.empty(), this.renderMarkup(), this.labelContainer = null, this.renderLabels(), this.update(), this.renderTools(), this;
+  }
+  renderMarkup() {
+    const t = this.cell.markup;
+    if (t) {
+      if (typeof t == "string")
+        throw new TypeError("Not support string markup.");
+      return this.renderJSONMarkup(t);
+    }
+    throw new TypeError("Invalid edge markup.");
+  }
+  renderJSONMarkup(t) {
+    const n = this.parseJSONMarkup(t, this.container);
+    this.selectors = n.selectors, this.container.append(n.fragment);
+  }
+  customizeLabels() {
+    if (this.labelContainer) {
+      const t = this.cell, n = t.labels;
+      for (let e = 0, i = n.length; e < i; e += 1) {
+        const s = n[e], o = this.labelCache[e], r = this.labelSelectors[e], a = this.graph.options.onEdgeLabelRendered;
+        if (a) {
+          const l = a({
+            edge: t,
+            label: s,
+            container: o,
+            selectors: r
+          });
+          l && (this.labelDestroyFn[e] = l);
+        }
+      }
+    }
+  }
+  destroyCustomizeLabels() {
+    const t = this.cell.labels;
+    if (this.labelCache && this.labelSelectors && this.labelDestroyFn)
+      for (let n = 0, e = t.length; n < e; n += 1) {
+        const i = this.labelDestroyFn[n], s = this.labelCache[n], o = this.labelSelectors[n];
+        i && s && o && i({
+          edge: this.cell,
+          label: t[n],
+          container: s,
+          selectors: o
+        });
+      }
+    this.labelDestroyFn = {};
+  }
+  renderLabels() {
+    const t = this.cell, n = t.getLabels(), e = n.length;
+    let i = this.labelContainer;
+    if (this.labelCache = {}, this.labelSelectors = {}, e <= 0)
+      return i && i.parentNode && i.parentNode.removeChild(i), this;
+    i ? this.empty(i) : (i = W("g"), this.addClass(this.prefixClassName("edge-labels"), i), this.labelContainer = i);
+    for (let s = 0, o = n.length; s < o; s += 1) {
+      const r = n[s], a = this.normalizeLabelMarkup(this.parseLabelMarkup(r.markup));
+      let l, c;
+      if (a)
+        l = a.node, c = a.selectors;
+      else {
+        const h = t.getDefaultLabel(), f = this.normalizeLabelMarkup(this.parseLabelMarkup(h.markup));
+        l = f.node, c = f.selectors;
+      }
+      l.setAttribute("data-index", `${s}`), i.appendChild(l);
+      const g = this.rootSelector;
+      if (c[g])
+        throw new Error("Ambiguous label root selector.");
+      c[g] = l, this.labelCache[s] = l, this.labelSelectors[s] = c;
+    }
+    return i.parentNode == null && this.container.appendChild(i), this.updateLabels(), this.customizeLabels(), this;
+  }
+  onLabelsChange(t = {}) {
+    this.destroyCustomizeLabels(), this.shouldRerenderLabels(t) ? this.renderLabels() : this.updateLabels(), this.updateLabelPositions();
+  }
+  shouldRerenderLabels(t = {}) {
+    const n = this.cell.previous("labels");
+    if (n == null)
+      return !0;
+    if ("propertyPathArray" in t && "propertyValue" in t) {
+      const e = t.propertyPathArray || [], i = e.length;
+      if (i > 1) {
+        const s = e[1];
+        if (n[s]) {
+          if (i === 2)
+            return typeof t.propertyValue == "object" && T(t.propertyValue, "markup");
+          if (e[2] !== "markup")
+            return !1;
+        }
+      }
+    }
+    return !0;
+  }
+  parseLabelMarkup(t) {
+    return t ? typeof t == "string" ? this.parseLabelStringMarkup(t) : this.parseJSONMarkup(t) : null;
+  }
+  parseLabelStringMarkup(t) {
+    const n = B.createVectors(t), e = document.createDocumentFragment();
+    for (let i = 0, s = n.length; i < s; i += 1) {
+      const o = n[i].node;
+      e.appendChild(o);
+    }
+    return { fragment: e, selectors: {} };
+  }
+  normalizeLabelMarkup(t) {
+    if (t == null)
+      return;
+    const n = t.fragment;
+    if (!(n instanceof DocumentFragment) || !n.hasChildNodes())
+      throw new Error("Invalid label markup.");
+    let e;
+    const i = n.childNodes;
+    return i.length > 1 || i[0].nodeName.toUpperCase() !== "G" ? e = B.create("g").append(n) : e = B.create(i[0]), e.addClass(this.prefixClassName("edge-label")), {
+      node: e.node,
+      selectors: t.selectors
+    };
+  }
+  updateLabels() {
+    if (this.labelContainer) {
+      const t = this.cell, n = t.labels, e = this.can("edgeLabelMovable"), i = t.getDefaultLabel();
+      for (let s = 0, o = n.length; s < o; s += 1) {
+        const r = this.labelCache[s], a = this.labelSelectors[s];
+        r.setAttribute("cursor", e ? "move" : "default");
+        const l = n[s], c = N({}, i.attrs, l.attrs);
+        this.updateAttrs(r, c, {
+          selectors: a,
+          rootBBox: l.size ? k.fromSize(l.size) : void 0
+        });
+      }
+    }
+  }
+  renderTools() {
+    const t = this.cell.getTools();
+    return this.addTools(t), this;
+  }
+  // #endregion
+  // #region updating
+  update(t = {}) {
+    this.cleanCache(), this.updateConnection(t);
+    const n = this.cell.getAttrs(), { text: e } = n, i = tt(n, ["text"]);
+    return i != null && this.updateAttrs(this.container, i, {
+      selectors: this.selectors
+    }), this.updateLabelPositions(), this.updateTools(t), this;
+  }
+  removeRedundantLinearVertices(t = {}) {
+    const n = this.cell, e = n.getVertices(), i = [this.sourceAnchor, ...e, this.targetAnchor], s = i.length, o = new j(i);
+    o.simplify({ threshold: 0.01 });
+    const r = o.points.map((l) => l.toJSON()), a = r.length;
+    return s === a ? 0 : (n.setVertices(r.slice(1, a - 1), t), s - a);
+  }
+  getTerminalView(t) {
+    switch (t) {
+      case "source":
+        return this.sourceView || null;
+      case "target":
+        return this.targetView || null;
+      default:
+        throw new Error(`Unknown terminal type '${t}'`);
+    }
+  }
+  getTerminalAnchor(t) {
+    switch (t) {
+      case "source":
+        return A.create(this.sourceAnchor);
+      case "target":
+        return A.create(this.targetAnchor);
+      default:
+        throw new Error(`Unknown terminal type '${t}'`);
+    }
+  }
+  getTerminalConnectionPoint(t) {
+    switch (t) {
+      case "source":
+        return A.create(this.sourcePoint);
+      case "target":
+        return A.create(this.targetPoint);
+      default:
+        throw new Error(`Unknown terminal type '${t}'`);
+    }
+  }
+  getTerminalMagnet(t, n = {}) {
+    switch (t) {
+      case "source": {
+        if (n.raw)
+          return this.sourceMagnet;
+        const e = this.sourceView;
+        return e ? this.sourceMagnet || e.container : null;
+      }
+      case "target": {
+        if (n.raw)
+          return this.targetMagnet;
+        const e = this.targetView;
+        return e ? this.targetMagnet || e.container : null;
+      }
+      default:
+        throw new Error(`Unknown terminal type '${t}'`);
+    }
+  }
+  updateConnection(t = {}) {
+    const n = this.cell;
+    if (t.translateBy && n.isFragmentDescendantOf(t.translateBy)) {
+      const e = t.tx || 0, i = t.ty || 0;
+      this.routePoints = new j(this.routePoints).translate(e, i).points, this.translateConnectionPoints(e, i), this.path.translate(e, i);
+    } else {
+      const e = n.getVertices(), i = this.findAnchors(e);
+      this.sourceAnchor = i.source, this.targetAnchor = i.target, this.routePoints = this.findRoutePoints(e);
+      const s = this.findConnectionPoints(this.routePoints, this.sourceAnchor, this.targetAnchor);
+      this.sourcePoint = s.source, this.targetPoint = s.target;
+      const o = this.findMarkerPoints(this.routePoints, this.sourcePoint, this.targetPoint);
+      this.path = this.findPath(this.routePoints, o.source || this.sourcePoint, o.target || this.targetPoint);
+    }
+    this.cleanCache();
+  }
+  findAnchors(t) {
+    const n = this.cell, e = n.source, i = n.target, s = t[0], o = t[t.length - 1];
+    return i.priority && !e.priority ? this.findAnchorsOrdered("target", o, "source", s) : this.findAnchorsOrdered("source", s, "target", o);
+  }
+  findAnchorsOrdered(t, n, e, i) {
+    let s, o;
+    const r = this.cell, a = r[t], l = r[e], c = this.getTerminalView(t), g = this.getTerminalView(e), h = this.getTerminalMagnet(t), f = this.getTerminalMagnet(e);
+    if (c) {
+      let u;
+      n ? u = A.create(n) : g ? u = f : u = A.create(l), s = this.getAnchor(a.anchor, c, h, u, t);
+    } else
+      s = A.create(a);
+    if (g) {
+      const u = A.create(i || s);
+      o = this.getAnchor(l.anchor, g, f, u, e);
+    } else
+      o = A.isPointLike(l) ? A.create(l) : new A();
+    return {
+      [t]: s,
+      [e]: o
+    };
+  }
+  getAnchor(t, n, e, i, s) {
+    const o = n.isEdgeElement(e), r = this.graph.options.connecting;
+    let a = typeof t == "string" ? { name: t } : t;
+    if (!a) {
+      const g = o ? (s === "source" ? r.sourceEdgeAnchor : r.targetEdgeAnchor) || r.edgeAnchor : (s === "source" ? r.sourceAnchor : r.targetAnchor) || r.anchor;
+      a = typeof g == "string" ? { name: g } : g;
+    }
+    if (!a)
+      throw new Error("Anchor should be specified.");
+    let l;
+    const c = a.name;
+    if (o) {
+      const g = F.registry.get(c);
+      if (typeof g != "function")
+        return F.registry.onNotFound(c);
+      l = P(g, this, n, e, i, a.args || {}, s);
+    } else {
+      const g = z.registry.get(c);
+      if (typeof g != "function")
+        return z.registry.onNotFound(c);
+      l = P(g, this, n, e, i, a.args || {}, s);
+    }
+    return l ? l.round(this.POINT_ROUNDING) : new A();
+  }
+  findRoutePoints(t = []) {
+    const n = this.graph.options.connecting.router || S.presets.normal, e = this.cell.getRouter() || n;
+    let i;
+    if (typeof e == "function")
+      i = P(e, this, t, {}, this);
+    else {
+      const s = typeof e == "string" ? e : e.name, o = typeof e == "string" ? {} : e.args || {}, r = s ? S.registry.get(s) : S.presets.normal;
+      if (typeof r != "function")
+        return S.registry.onNotFound(s);
+      i = P(r, this, t, o, this);
+    }
+    return i == null ? t.map((s) => A.create(s)) : i.map((s) => A.create(s));
+  }
+  findConnectionPoints(t, n, e) {
+    const i = this.cell, s = this.graph.options.connecting, o = i.getSource(), r = i.getTarget(), a = this.sourceView, l = this.targetView, c = t[0], g = t[t.length - 1];
+    let h;
+    if (a && !a.isEdgeElement(this.sourceMagnet)) {
+      const u = this.sourceMagnet || a.container, w = c || e, d = new R(w, n), m = o.connectionPoint || s.sourceConnectionPoint || s.connectionPoint;
+      h = this.getConnectionPoint(m, a, u, d, "source");
+    } else
+      h = n;
+    let f;
+    if (l && !l.isEdgeElement(this.targetMagnet)) {
+      const u = this.targetMagnet || l.container, w = r.connectionPoint || s.targetConnectionPoint || s.connectionPoint, d = g || n, m = new R(d, e);
+      f = this.getConnectionPoint(w, l, u, m, "target");
+    } else
+      f = e;
+    return {
+      source: h,
+      target: f
+    };
+  }
+  getConnectionPoint(t, n, e, i, s) {
+    const o = i.end;
+    if (t == null)
+      return o;
+    const r = typeof t == "string" ? t : t.name, a = typeof t == "string" ? {} : t.args, l = U.registry.get(r);
+    if (typeof l != "function")
+      return U.registry.onNotFound(r);
+    const c = P(l, this, i, n, e, a || {}, s);
+    return c ? c.round(this.POINT_ROUNDING) : o;
+  }
+  findMarkerPoints(t, n, e) {
+    const i = (g) => {
+      const h = this.cell.getAttrs(), f = Object.keys(h);
+      for (let u = 0, w = f.length; u < w; u += 1) {
+        const d = h[f[u]];
+        if (d[`${g}Marker`] || d[`${g}-marker`]) {
+          const m = d.strokeWidth || d["stroke-width"];
+          if (m)
+            return parseFloat(m);
+          break;
+        }
+      }
+      return null;
+    }, s = t[0], o = t[t.length - 1];
+    let r, a;
+    const l = i("source");
+    l && (r = n.clone().move(s || e, -l));
+    const c = i("target");
+    return c && (a = e.clone().move(o || n, -c)), this.sourceMarkerPoint = r || n.clone(), this.targetMarkerPoint = a || e.clone(), {
+      source: r,
+      target: a
+    };
+  }
+  findPath(t, n, e) {
+    const i = this.cell.getConnector() || this.graph.options.connecting.connector;
+    let s, o, r;
+    if (typeof i == "string" ? s = i : (s = i.name, o = i.args), s) {
+      const l = x.registry.get(s);
+      if (typeof l != "function")
+        return x.registry.onNotFound(s);
+      r = l;
+    } else
+      r = x.presets.normal;
+    const a = P(r, this, n, e, t, Object.assign(Object.assign({}, o), { raw: !0 }), this);
+    return typeof a == "string" ? G.parse(a) : a;
+  }
+  translateConnectionPoints(t, n) {
+    this.sourcePoint.translate(t, n), this.targetPoint.translate(t, n), this.sourceAnchor.translate(t, n), this.targetAnchor.translate(t, n), this.sourceMarkerPoint.translate(t, n), this.targetMarkerPoint.translate(t, n);
+  }
+  updateLabelPositions() {
+    if (this.labelContainer == null)
+      return this;
+    if (!this.path)
+      return this;
+    const n = this.cell, e = n.getLabels();
+    if (e.length === 0)
+      return this;
+    const i = n.getDefaultLabel(), s = this.normalizeLabelPosition(i.position);
+    for (let o = 0, r = e.length; o < r; o += 1) {
+      const a = e[o], l = this.labelCache[o];
+      if (!l)
+        continue;
+      const c = this.normalizeLabelPosition(a.position), g = N({}, s, c), h = this.getLabelTransformationMatrix(g);
+      l.setAttribute("transform", X(h));
+    }
+    return this;
+  }
+  updateTerminalProperties(t) {
+    const n = this.cell, e = this.graph, i = n[t], s = i && i.cell, o = `${t}View`;
+    if (!s)
+      return this[o] = null, this.updateTerminalMagnet(t), !0;
+    const r = e.getCellById(s);
+    if (!r)
+      throw new Error(`Edge's ${t} node with id "${s}" not exists`);
+    const a = r.findView(e);
+    return a ? (this[o] = a, this.updateTerminalMagnet(t), !0) : !1;
+  }
+  updateTerminalMagnet(t) {
+    const n = `${t}Magnet`, e = this.getTerminalView(t);
+    if (e) {
+      let i = e.getMagnetFromEdgeTerminal(this.cell[t]);
+      i === e.container && (i = null), this[n] = i;
+    } else
+      this[n] = null;
+  }
+  getLabelPositionAngle(t) {
+    const n = this.cell.getLabelAt(t);
+    return n && n.position && typeof n.position == "object" && n.position.angle || 0;
+  }
+  getLabelPositionArgs(t) {
+    const n = this.cell.getLabelAt(t);
+    if (n && n.position && typeof n.position == "object")
+      return n.position.options;
+  }
+  getDefaultLabelPositionArgs() {
+    const t = this.cell.getDefaultLabel();
+    if (t && t.position && typeof t.position == "object")
+      return t.position.options;
+  }
+  mergeLabelPositionArgs(t, n) {
+    return t === null ? null : t === void 0 ? n === null ? null : n : N({}, n, t);
+  }
+  // #endregion
+  getConnection() {
+    return this.path != null ? this.path.clone() : null;
+  }
+  getConnectionPathData() {
+    if (this.path == null)
+      return "";
+    const t = this.cache.pathCache;
+    return T(t, "data") || (t.data = this.path.serialize()), t.data || "";
+  }
+  getConnectionSubdivisions() {
+    if (this.path == null)
+      return null;
+    const t = this.cache.pathCache;
+    return T(t, "segmentSubdivisions") || (t.segmentSubdivisions = this.path.getSegmentSubdivisions()), t.segmentSubdivisions;
+  }
+  getConnectionLength() {
+    if (this.path == null)
+      return 0;
+    const t = this.cache.pathCache;
+    return T(t, "length") || (t.length = this.path.length({
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    })), t.length;
+  }
+  getPointAtLength(t) {
+    return this.path == null ? null : this.path.pointAtLength(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    });
+  }
+  getPointAtRatio(t) {
+    return this.path == null ? null : (J(t) && (t = parseFloat(t) / 100), this.path.pointAt(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    }));
+  }
+  getTangentAtLength(t) {
+    return this.path == null ? null : this.path.tangentAtLength(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    });
+  }
+  getTangentAtRatio(t) {
+    return this.path == null ? null : this.path.tangentAt(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    });
+  }
+  getClosestPoint(t) {
+    return this.path == null ? null : this.path.closestPoint(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    });
+  }
+  getClosestPointLength(t) {
+    return this.path == null ? null : this.path.closestPointLength(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    });
+  }
+  getClosestPointRatio(t) {
+    return this.path == null ? null : this.path.closestPointNormalizedLength(t, {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    });
+  }
+  getLabelPosition(t, n, e, i) {
+    const s = { distance: 0 };
+    let o = 0, r;
+    typeof e == "number" ? (o = e, r = i) : r = e, r != null && (s.options = r);
+    const a = r && r.absoluteOffset, l = !(r && r.absoluteDistance), c = r && r.absoluteDistance && r.reverseDistance, g = this.path, h = {
+      segmentSubdivisions: this.getConnectionSubdivisions()
+    }, f = new A(t, n), u = g.closestPointT(f, h), w = this.getConnectionLength() || 0;
+    let d = g.lengthAtT(u, h);
+    l && (d = w > 0 ? d / w : 0), c && (d = -1 * (w - d) || 1), s.distance = d;
+    let m;
+    a || (m = g.tangentAtT(u));
+    let p;
+    if (m)
+      p = m.pointOffset(f);
+    else {
+      const C = g.pointAtT(u), b = f.diff(C);
+      p = { x: b.x, y: b.y };
+    }
+    return s.offset = p, s.angle = o, s;
+  }
+  normalizeLabelPosition(t) {
+    return typeof t == "number" ? { distance: t } : t;
+  }
+  getLabelTransformationMatrix(t) {
+    const n = this.normalizeLabelPosition(t), e = n.options || {}, i = n.angle || 0, s = n.distance, o = s > 0 && s <= 1;
+    let r = 0;
+    const a = { x: 0, y: 0 }, l = n.offset;
+    l && (typeof l == "number" ? r = l : (l.x != null && (a.x = l.x), l.y != null && (a.y = l.y)));
+    const c = a.x !== 0 || a.y !== 0 || r === 0, g = e.keepGradient, h = e.ensureLegibility, f = this.path, u = { segmentSubdivisions: this.getConnectionSubdivisions() }, w = o ? s * this.getConnectionLength() : s, d = f.tangentAtLength(w, u);
+    let m, p = i;
+    if (d) {
+      if (c)
+        m = d.start, m.translate(a);
+      else {
+        const C = d.clone();
+        C.rotate(-90, d.start), C.setLength(r), m = C.end;
+      }
+      g && (p = d.angle() + i, h && (p = _.normalize((p + 90) % 180 - 90)));
+    } else
+      m = f.start, c && m.translate(a);
+    return K().translate(m.x, m.y).rotate(p);
+  }
+  getVertexIndex(t, n) {
+    const i = this.cell.getVertices(), s = this.getClosestPointLength(new A(t, n));
+    let o = 0;
+    if (s != null)
+      for (const r = i.length; o < r; o += 1) {
+        const a = i[o], l = this.getClosestPointLength(a);
+        if (l != null && s < l)
+          break;
+      }
+    return o;
+  }
+  getEventArgs(t, n, e) {
+    const i = this, s = i.cell, o = s;
+    return n == null || e == null ? { e: t, view: i, edge: s, cell: o } : { e: t, x: n, y: e, view: i, edge: s, cell: o };
+  }
+  notifyUnhandledMouseDown(t, n, e) {
+    this.notify("edge:unhandled:mousedown", {
+      e: t,
+      x: n,
+      y: e,
+      view: this,
+      cell: this.cell,
+      edge: this.cell
+    });
+  }
+  notifyMouseDown(t, n, e) {
+    super.onMouseDown(t, n, e), this.notify("edge:mousedown", this.getEventArgs(t, n, e));
+  }
+  notifyMouseMove(t, n, e) {
+    super.onMouseMove(t, n, e), this.notify("edge:mousemove", this.getEventArgs(t, n, e));
+  }
+  notifyMouseUp(t, n, e) {
+    super.onMouseUp(t, n, e), this.notify("edge:mouseup", this.getEventArgs(t, n, e));
+  }
+  onClick(t, n, e) {
+    super.onClick(t, n, e), this.notify("edge:click", this.getEventArgs(t, n, e));
+  }
+  onDblClick(t, n, e) {
+    super.onDblClick(t, n, e), this.notify("edge:dblclick", this.getEventArgs(t, n, e));
+  }
+  onContextMenu(t, n, e) {
+    super.onContextMenu(t, n, e), this.notify("edge:contextmenu", this.getEventArgs(t, n, e));
+  }
+  onMouseDown(t, n, e) {
+    this.notifyMouseDown(t, n, e), this.startEdgeDragging(t, n, e);
+  }
+  onMouseMove(t, n, e) {
+    const i = this.getEventData(t);
+    switch (i.action) {
+      case "drag-label": {
+        this.dragLabel(t, n, e);
+        break;
+      }
+      case "drag-arrowhead": {
+        this.dragArrowhead(t, n, e);
+        break;
+      }
+      case "drag-edge": {
+        this.dragEdge(t, n, e);
+        break;
+      }
+    }
+    return this.notifyMouseMove(t, n, e), i;
+  }
+  onMouseUp(t, n, e) {
+    const i = this.getEventData(t);
+    switch (i.action) {
+      case "drag-label": {
+        this.stopLabelDragging(t, n, e);
+        break;
+      }
+      case "drag-arrowhead": {
+        this.stopArrowheadDragging(t, n, e);
+        break;
+      }
+      case "drag-edge": {
+        this.stopEdgeDragging(t, n, e);
+        break;
+      }
+    }
+    return this.notifyMouseUp(t, n, e), this.checkMouseleave(t), i;
+  }
+  onMouseOver(t) {
+    super.onMouseOver(t), this.notify("edge:mouseover", this.getEventArgs(t));
+  }
+  onMouseOut(t) {
+    super.onMouseOut(t), this.notify("edge:mouseout", this.getEventArgs(t));
+  }
+  onMouseEnter(t) {
+    super.onMouseEnter(t), this.notify("edge:mouseenter", this.getEventArgs(t));
+  }
+  onMouseLeave(t) {
+    super.onMouseLeave(t), this.notify("edge:mouseleave", this.getEventArgs(t));
+  }
+  onMouseWheel(t, n, e, i) {
+    super.onMouseWheel(t, n, e, i), this.notify("edge:mousewheel", Object.assign({ delta: i }, this.getEventArgs(t, n, e)));
+  }
+  onCustomEvent(t, n, e, i) {
+    if (q(t.target, "edge-tool", this.container)) {
+      if (t.stopPropagation(), this.can("useEdgeTools")) {
+        if (n === "edge:remove") {
+          this.cell.remove({ ui: !0 });
+          return;
+        }
+        this.notify("edge:customevent", Object.assign({ name: n }, this.getEventArgs(t, e, i)));
+      }
+      this.notifyMouseDown(t, e, i);
+    } else
+      this.notify("edge:customevent", Object.assign({ name: n }, this.getEventArgs(t, e, i))), super.onCustomEvent(t, n, e, i);
+  }
+  onLabelMouseDown(t, n, e) {
+    this.notifyMouseDown(t, n, e), this.startLabelDragging(t, n, e), this.getEventData(t).stopPropagation && t.stopPropagation();
+  }
+  // #region drag edge
+  startEdgeDragging(t, n, e) {
+    if (!this.can("edgeMovable")) {
+      this.notifyUnhandledMouseDown(t, n, e);
+      return;
+    }
+    this.setEventData(t, {
+      x: n,
+      y: e,
+      moving: !1,
+      action: "drag-edge"
+    });
+  }
+  dragEdge(t, n, e) {
+    const i = this.getEventData(t);
+    i.moving || (i.moving = !0, this.addClass("edge-moving"), this.notify("edge:move", {
+      e: t,
+      x: n,
+      y: e,
+      view: this,
+      cell: this.cell,
+      edge: this.cell
+    })), this.cell.translate(n - i.x, e - i.y, { ui: !0 }), this.setEventData(t, { x: n, y: e }), this.notify("edge:moving", {
+      e: t,
+      x: n,
+      y: e,
+      view: this,
+      cell: this.cell,
+      edge: this.cell
+    });
+  }
+  stopEdgeDragging(t, n, e) {
+    const i = this.getEventData(t);
+    i.moving && (this.removeClass("edge-moving"), this.notify("edge:moved", {
+      e: t,
+      x: n,
+      y: e,
+      view: this,
+      cell: this.cell,
+      edge: this.cell
+    })), i.moving = !1;
+  }
+  // #endregion
+  // #region drag arrowhead
+  prepareArrowheadDragging(t, n) {
+    const e = this.getTerminalMagnet(t), i = {
+      action: "drag-arrowhead",
+      x: n.x,
+      y: n.y,
+      isNewEdge: n.isNewEdge === !0,
+      terminalType: t,
+      initialMagnet: e,
+      initialTerminal: Y(this.cell[t]),
+      fallbackAction: n.fallbackAction || "revert",
+      getValidateConnectionArgs: this.createValidateConnectionArgs(t),
+      options: n.options
+    };
+    return this.beforeArrowheadDragging(i), i;
+  }
+  createValidateConnectionArgs(t) {
+    const n = [];
+    n[4] = t, n[5] = this;
+    let e, i = 0, s = 0;
+    t === "source" ? (i = 2, e = "target") : (s = 2, e = "source");
+    const o = this.cell[e], r = o.cell;
+    if (r) {
+      let a;
+      const l = n[i] = this.graph.findViewByCell(r);
+      l && (a = l.getMagnetFromEdgeTerminal(o), a === l.container && (a = void 0)), n[i + 1] = a;
+    }
+    return (a, l) => (n[s] = a, n[s + 1] = a.container === l ? void 0 : l, n);
+  }
+  beforeArrowheadDragging(t) {
+    t.zIndex = this.cell.zIndex, this.cell.toFront();
+    const n = this.container.style;
+    t.pointerEvents = n.pointerEvents, n.pointerEvents = "none", this.graph.options.connecting.highlight && this.highlightAvailableMagnets(t);
+  }
+  afterArrowheadDragging(t) {
+    t.zIndex != null && (this.cell.setZIndex(t.zIndex, { ui: !0 }), t.zIndex = null);
+    const n = this.container;
+    n.style.pointerEvents = t.pointerEvents || "", this.graph.options.connecting.highlight && this.unhighlightAvailableMagnets(t);
+  }
+  validateConnection(t, n, e, i, s, o, r) {
+    const a = this.graph.options.connecting, l = a.allowLoop, c = a.allowNode, g = a.allowEdge, h = a.allowPort, f = a.allowMulti, u = a.validateConnection, w = o ? o.cell : null, d = s === "target" ? e : t, m = s === "target" ? i : n;
+    let p = !0;
+    const C = (b) => {
+      const v = s === "source" ? r ? r.port : null : w ? w.getSourcePortId() : null, y = s === "target" ? r ? r.port : null : w ? w.getTargetPortId() : null;
+      return P(b, this.graph, {
+        edge: w,
+        edgeView: o,
+        sourceView: t,
+        targetView: e,
+        sourcePort: v,
+        targetPort: y,
+        sourceMagnet: n,
+        targetMagnet: i,
+        sourceCell: t ? t.cell : null,
+        targetCell: e ? e.cell : null,
+        type: s
+      });
+    };
+    if (l != null && (typeof l == "boolean" ? !l && t === e && (p = !1) : p = C(l)), p && h != null && (typeof h == "boolean" ? !h && m && (p = !1) : p = C(h)), p && g != null && (typeof g == "boolean" ? !g && E.isEdgeView(d) && (p = !1) : p = C(g)), p && c != null && m == null && (typeof c == "boolean" ? !c && Q.isNodeView(d) && (p = !1) : p = C(c)), p && f != null && o) {
+      const b = o.cell, v = s === "source" ? r : b.getSource(), y = s === "target" ? r : b.getTarget(), I = r ? this.graph.getCellById(r.cell) : null;
+      if (v && y && v.cell && y.cell && I)
+        if (typeof f == "function")
+          p = C(f);
+        else {
+          const O = this.graph.model.getConnectedEdges(I, {
+            outgoing: s === "source",
+            incoming: s === "target"
+          });
+          O.length && (f === "withPort" ? O.some((V) => {
+            const L = V.getSource(), D = V.getTarget();
+            return L && D && L.cell === v.cell && D.cell === y.cell && L.port != null && L.port === v.port && D.port != null && D.port === y.port;
+          }) && (p = !1) : f || O.some((V) => {
+            const L = V.getSource(), D = V.getTarget();
+            return L && D && L.cell === v.cell && D.cell === y.cell;
+          }) && (p = !1));
+        }
+    }
+    return p && u != null && (p = C(u)), p;
+  }
+  allowConnectToBlank(t) {
+    const n = this.graph, i = n.options.connecting.allowBlank;
+    if (typeof i != "function")
+      return !!i;
+    const s = n.findViewByCell(t), o = t.getSourceCell(), r = t.getTargetCell(), a = n.findViewByCell(o), l = n.findViewByCell(r);
+    return P(i, n, {
+      edge: t,
+      edgeView: s,
+      sourceCell: o,
+      targetCell: r,
+      sourceView: a,
+      targetView: l,
+      sourcePort: t.getSourcePortId(),
+      targetPort: t.getTargetPortId(),
+      sourceMagnet: s.sourceMagnet,
+      targetMagnet: s.targetMagnet
+    });
+  }
+  validateEdge(t, n, e) {
+    const i = this.graph;
+    if (!this.allowConnectToBlank(t)) {
+      const o = t.getSourceCellId(), r = t.getTargetCellId();
+      if (!(o && r))
+        return !1;
+    }
+    const s = i.options.connecting.validateEdge;
+    return s ? P(s, i, {
+      edge: t,
+      type: n,
+      previous: e
+    }) : !0;
+  }
+  arrowheadDragging(t, n, e, i) {
+    i.x = n, i.y = e, i.currentTarget !== t && (i.currentMagnet && i.currentView && i.currentView.unhighlight(i.currentMagnet, {
+      type: "magnetAdsorbed"
+    }), i.currentView = this.graph.findViewByElem(t), i.currentView ? (i.currentMagnet = i.currentView.findMagnet(t), i.currentMagnet && this.validateConnection(...i.getValidateConnectionArgs(i.currentView, i.currentMagnet), i.currentView.getEdgeTerminal(i.currentMagnet, n, e, this.cell, i.terminalType)) ? i.currentView.highlight(i.currentMagnet, {
+      type: "magnetAdsorbed"
+    }) : i.currentMagnet = null) : i.currentMagnet = null), i.currentTarget = t, this.cell.prop(i.terminalType, { x: n, y: e }, Object.assign(Object.assign({}, i.options), { ui: !0 }));
+  }
+  arrowheadDragged(t, n, e) {
+    const i = t.currentView, s = t.currentMagnet;
+    if (!s || !i)
+      return;
+    i.unhighlight(s, { type: "magnetAdsorbed" });
+    const o = t.terminalType, r = i.getEdgeTerminal(s, n, e, this.cell, o);
+    this.cell.setTerminal(o, r, { ui: !0 });
+  }
+  snapArrowhead(t, n, e) {
+    const i = this.graph, { snap: s, allowEdge: o } = i.options.connecting, r = typeof s == "object" && s.radius || 50, a = typeof s == "object" && s.anchor || "center", l = i.renderer.findViewsInArea({
+      x: t - r,
+      y: n - r,
+      width: 2 * r,
+      height: 2 * r
+    }, { nodeOnly: !0 });
+    if (o) {
+      const b = i.renderer.findEdgeViewsFromPoint({ x: t, y: n }, r).filter((v) => v !== this);
+      l.push(...b);
+    }
+    const c = e.closestView || null, g = e.closestMagnet || null;
+    e.closestView = null, e.closestMagnet = null;
+    let h, f = Number.MAX_SAFE_INTEGER;
+    const u = new A(t, n);
+    l.forEach((b) => {
+      if (b.container.getAttribute("magnet") !== "false") {
+        if (b.isNodeView())
+          h = a === "center" ? b.cell.getBBox().getCenter().distance(u) : b.cell.getBBox().getNearestPointToPoint(u).distance(u);
+        else if (b.isEdgeView()) {
+          const v = b.getClosestPoint(u);
+          v ? h = v.distance(u) : h = Number.MAX_SAFE_INTEGER;
+        }
+        h < r && h < f && (g === b.container || this.validateConnection(...e.getValidateConnectionArgs(b, null), b.getEdgeTerminal(b.container, t, n, this.cell, e.terminalType))) && (f = h, e.closestView = b, e.closestMagnet = b.container);
+      }
+      b.container.querySelectorAll("[magnet]").forEach((v) => {
+        if (v.getAttribute("magnet") !== "false") {
+          const y = b.getBBoxOfElement(v);
+          h = u.distance(y.getCenter()), h < r && h < f && (g === v || this.validateConnection(...e.getValidateConnectionArgs(b, v), b.getEdgeTerminal(v, t, n, this.cell, e.terminalType))) && (f = h, e.closestView = b, e.closestMagnet = v);
+        }
+      });
+    });
+    let w;
+    const d = e.terminalType, m = e.closestView, p = e.closestMagnet, C = g !== p;
+    if (c && C && c.unhighlight(g, {
+      type: "magnetAdsorbed"
+    }), m) {
+      if (!C)
+        return;
+      m.highlight(p, {
+        type: "magnetAdsorbed"
+      }), w = m.getEdgeTerminal(p, t, n, this.cell, d);
+    } else
+      w = { x: t, y: n };
+    this.cell.setTerminal(d, w, {}, Object.assign(Object.assign({}, e.options), { ui: !0 }));
+  }
+  snapArrowheadEnd(t) {
+    const n = t.closestView, e = t.closestMagnet;
+    n && e && (n.unhighlight(e, {
+      type: "magnetAdsorbed"
+    }), t.currentMagnet = n.findMagnet(e)), t.closestView = null, t.closestMagnet = null;
+  }
+  finishEmbedding(t) {
+    this.graph.options.embedding.enabled && this.cell.updateParent() && (t.zIndex = null);
+  }
+  fallbackConnection(t) {
+    switch (t.fallbackAction) {
+      case "remove":
+        this.cell.remove({ ui: !0 });
+        break;
+      case "revert":
+      default:
+        this.cell.prop(t.terminalType, t.initialTerminal, {
+          ui: !0
+        });
+        break;
+    }
+  }
+  notifyConnectionEvent(t, n) {
+    const e = t.terminalType, i = t.initialTerminal, s = this.cell[e];
+    if (s && !Z.equalTerminals(i, s)) {
+      const r = this.graph, a = i, l = a.cell ? r.getCellById(a.cell) : null, c = a.port, g = l ? r.findViewByCell(l) : null, h = l || t.isNewEdge ? null : A.create(i).toJSON(), f = s, u = f.cell ? r.getCellById(f.cell) : null, w = f.port, d = u ? r.findViewByCell(u) : null, m = u ? null : A.create(s).toJSON();
+      this.notify("edge:connected", {
+        e: n,
+        previousCell: l,
+        previousPort: c,
+        previousView: g,
+        previousPoint: h,
+        currentCell: u,
+        currentView: d,
+        currentPort: w,
+        currentPoint: m,
+        previousMagnet: t.initialMagnet,
+        currentMagnet: t.currentMagnet,
+        edge: this.cell,
+        view: this,
+        type: e,
+        isNew: t.isNewEdge
+      });
+    }
+  }
+  highlightAvailableMagnets(t) {
+    const n = this.graph, e = n.model.getCells();
+    t.marked = {};
+    for (let i = 0, s = e.length; i < s; i += 1) {
+      const o = n.findViewByCell(e[i]);
+      if (!o || o.cell.id === this.cell.id)
+        continue;
+      const r = Array.prototype.slice.call(o.container.querySelectorAll("[magnet]"));
+      o.container.getAttribute("magnet") !== "false" && r.push(o.container);
+      const a = r.filter((l) => this.validateConnection(...t.getValidateConnectionArgs(o, l), o.getEdgeTerminal(l, t.x, t.y, this.cell, t.terminalType)));
+      if (a.length > 0) {
+        for (let l = 0, c = a.length; l < c; l += 1)
+          o.highlight(a[l], { type: "magnetAvailable" });
+        o.highlight(null, { type: "nodeAvailable" }), t.marked[o.cell.id] = a;
+      }
+    }
+  }
+  unhighlightAvailableMagnets(t) {
+    const n = t.marked || {};
+    Object.keys(n).forEach((e) => {
+      const i = this.graph.findViewByCell(e);
+      i && (n[e].forEach((o) => {
+        i.unhighlight(o, { type: "magnetAvailable" });
+      }), i.unhighlight(null, { type: "nodeAvailable" }));
+    }), t.marked = null;
+  }
+  startArrowheadDragging(t, n, e) {
+    if (!this.can("arrowheadMovable")) {
+      this.notifyUnhandledMouseDown(t, n, e);
+      return;
+    }
+    const s = t.target.getAttribute("data-terminal"), o = this.prepareArrowheadDragging(s, { x: n, y: e });
+    this.setEventData(t, o);
+  }
+  dragArrowhead(t, n, e) {
+    const i = this.getEventData(t);
+    this.graph.options.connecting.snap ? this.snapArrowhead(n, e, i) : this.arrowheadDragging(this.getEventTarget(t), n, e, i);
+  }
+  stopArrowheadDragging(t, n, e) {
+    const i = this.graph, s = this.getEventData(t);
+    i.options.connecting.snap ? this.snapArrowheadEnd(s) : this.arrowheadDragged(s, n, e), this.validateEdge(this.cell, s.terminalType, s.initialTerminal) ? (this.finishEmbedding(s), this.notifyConnectionEvent(s, t)) : this.fallbackConnection(s), this.afterArrowheadDragging(s);
+  }
+  // #endregion
+  // #region drag lable
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  startLabelDragging(t, n, e) {
+    if (this.can("edgeLabelMovable")) {
+      const i = t.currentTarget, s = parseInt(i.getAttribute("data-index"), 10), o = this.getLabelPositionAngle(s), r = this.getLabelPositionArgs(s), a = this.getDefaultLabelPositionArgs(), l = this.mergeLabelPositionArgs(r, a);
+      this.setEventData(t, {
+        index: s,
+        positionAngle: o,
+        positionArgs: l,
+        stopPropagation: !0,
+        action: "drag-label"
+      });
+    } else
+      this.setEventData(t, { stopPropagation: !0 });
+    this.graph.view.delegateDragEvents(t, this);
+  }
+  dragLabel(t, n, e) {
+    const i = this.getEventData(t), s = this.cell.getLabelAt(i.index), o = N({}, s, {
+      position: this.getLabelPosition(n, e, i.positionAngle, i.positionArgs)
+    });
+    this.cell.setLabelAt(i.index, o);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  stopLabelDragging(t, n, e) {
+  }
+}
+(function(M) {
+  M.toStringTag = `X6.${M.name}`;
+  function t(n) {
+    if (n == null)
+      return !1;
+    if (n instanceof M)
+      return !0;
+    const e = n[Symbol.toStringTag], i = n;
+    return (e == null || e === M.toStringTag) && typeof i.isNodeView == "function" && typeof i.isEdgeView == "function" && typeof i.confirmUpdate == "function" && typeof i.update == "function" && typeof i.getConnection == "function";
+  }
+  M.isEdgeView = t;
+})(E || (E = {}));
+E.config({
+  isSvgElement: !0,
+  priority: 1,
+  bootstrap: ["render", "source", "target"],
+  actions: {
+    view: ["render"],
+    markup: ["render"],
+    attrs: ["update"],
+    source: ["source", "update"],
+    target: ["target", "update"],
+    router: ["update"],
+    connector: ["update"],
+    labels: ["labels"],
+    defaultLabel: ["labels"],
+    tools: ["tools"],
+    vertices: ["vertices", "update"]
+  }
+});
+E.registry.register("edge", E, !0);
+export {
+  E as EdgeView
+};