@qy_better_lib/hooks 0.1.0 → 0.1.1

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

@@ -0,0 +1,609 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { call as m } from "../../../x6-common/es/function/function.js";
+import "../../../x6-common/es/platform/index.js";
+import { remove as P, before as y, append as C } from "../../../x6-common/es/dom/elem.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import { removeClass as S, addClass as v } from "../../../x6-common/es/dom/class.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import { createSVGMatrix as k } from "../../../x6-common/es/dom/matrix.js";
+import { transform as A } from "../../../x6-common/es/dom/transform.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 "../../../x6-geometry/es/angle.js";
+import { Point as D } from "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as E } from "../../../x6-geometry/es/rectangle.js";
+import "../../../x6-geometry/es/path/path.js";
+import { GeometryUtil as M } from "../../../x6-geometry/es/util.js";
+import "../../../x6-geometry/es/curve.js";
+import "../../../x6-geometry/es/polyline.js";
+import { Cell as T } from "../model/cell.js";
+import { CellView as V } from "./cell.js";
+import { Markup as b } from "./markup.js";
+import w from "../../../../lodash-es/groupBy.js";
+import N from "../../../../lodash-es/max.js";
+class g extends V {
+  constructor() {
+    super(...arguments), this.portsCache = {};
+  }
+  get [Symbol.toStringTag]() {
+    return g.toStringTag;
+  }
+  getContainerClassName() {
+    const t = [
+      super.getContainerClassName(),
+      this.prefixClassName("node")
+    ];
+    return this.can("nodeMovable") || t.push(this.prefixClassName("node-immovable")), t.join(" ");
+  }
+  updateClassName(t) {
+    const e = t.target;
+    if (e.hasAttribute("magnet")) {
+      const o = this.prefixClassName("port-unconnectable");
+      this.can("magnetConnectable") ? S(e, o) : v(e, o);
+    } else {
+      const o = this.prefixClassName("node-immovable");
+      this.can("nodeMovable") ? this.removeClass(o) : this.addClass(o);
+    }
+  }
+  isNodeView() {
+    return !0;
+  }
+  confirmUpdate(t, e = {}) {
+    let o = t;
+    return this.hasAction(o, "ports") && (this.removePorts(), this.cleanPortsCache()), this.hasAction(o, "render") ? (this.render(), o = this.removeAction(o, [
+      "render",
+      "update",
+      "resize",
+      "translate",
+      "rotate",
+      "ports",
+      "tools"
+    ])) : (o = this.handleAction(o, "resize", () => this.resize(), "update"), o = this.handleAction(
+      o,
+      "update",
+      () => this.update(),
+      // `update()` will render ports when useCSSSelectors are enabled
+      "ports"
+    ), o = this.handleAction(o, "translate", () => this.translate()), o = this.handleAction(o, "rotate", () => this.rotate()), o = this.handleAction(o, "ports", () => this.renderPorts()), o = this.handleAction(o, "tools", () => {
+      this.getFlag("tools") === t ? this.renderTools() : this.updateTools(e);
+    })), o;
+  }
+  update(t) {
+    this.cleanCache(), this.removePorts();
+    const e = this.cell, o = e.getSize(), n = e.getAttrs();
+    this.updateAttrs(this.container, n, {
+      attrs: t === n ? null : t,
+      rootBBox: new E(0, 0, o.width, o.height),
+      selectors: this.selectors
+    }), this.renderPorts();
+  }
+  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 node markup.");
+  }
+  renderJSONMarkup(t) {
+    const e = this.parseJSONMarkup(t, this.container);
+    this.selectors = e.selectors, this.container.appendChild(e.fragment);
+  }
+  render() {
+    return this.empty(), this.renderMarkup(), this.resize(), this.updateTransform(), this.renderTools(), this;
+  }
+  resize() {
+    this.cell.getAngle() && this.rotate(), this.update();
+  }
+  translate() {
+    this.updateTransform();
+  }
+  rotate() {
+    this.updateTransform();
+  }
+  getTranslationString() {
+    const t = this.cell.getPosition();
+    return `translate(${t.x},${t.y})`;
+  }
+  getRotationString() {
+    const t = this.cell.getAngle();
+    if (t) {
+      const e = this.cell.getSize();
+      return `rotate(${t},${e.width / 2},${e.height / 2})`;
+    }
+  }
+  updateTransform() {
+    let t = this.getTranslationString();
+    const e = this.getRotationString();
+    e && (t += ` ${e}`), this.container.setAttribute("transform", t);
+  }
+  // #region ports
+  findPortElem(t, e) {
+    const o = t ? this.portsCache[t] : null;
+    if (!o)
+      return null;
+    const n = o.portContentElement, i = o.portContentSelectors || {};
+    return this.findOne(e, n, i);
+  }
+  cleanPortsCache() {
+    this.portsCache = {};
+  }
+  removePorts() {
+    Object.values(this.portsCache).forEach((t) => {
+      P(t.portElement);
+    });
+  }
+  renderPorts() {
+    const t = this.container, e = [];
+    t.childNodes.forEach((s) => {
+      e.push(s);
+    });
+    const o = this.cell.getParsedPorts(), n = w(o, "zIndex"), i = "auto";
+    n[i] && n[i].forEach((s) => {
+      const r = this.getPortElement(s);
+      t.append(r), e.push(r);
+    }), Object.keys(n).forEach((s) => {
+      if (s !== i) {
+        const r = parseInt(s, 10);
+        this.appendPorts(n[s], r, e);
+      }
+    }), this.updatePorts();
+  }
+  appendPorts(t, e, o) {
+    const n = t.map((i) => this.getPortElement(i));
+    o[e] || e < 0 ? y(o[Math.max(e, 0)], n) : C(this.container, n);
+  }
+  getPortElement(t) {
+    const e = this.portsCache[t.id];
+    return e ? e.portElement : this.createPortElement(t);
+  }
+  createPortElement(t) {
+    let e = b.renderMarkup(this.cell.getPortContainerMarkup());
+    const o = e.elem;
+    if (o == null)
+      throw new Error("Invalid port container markup.");
+    e = b.renderMarkup(this.getPortMarkup(t));
+    const n = e.elem, i = e.selectors;
+    if (n == null)
+      throw new Error("Invalid port markup.");
+    this.setAttrs({
+      port: t.id,
+      "port-group": t.group
+    }, n);
+    let s = "x6-port";
+    t.group && (s += ` x6-port-${t.group}`), v(o, s), v(o, "x6-port"), v(n, "x6-port-body"), o.appendChild(n);
+    let r = i, a, l;
+    if (this.existPortLabel(t)) {
+      if (e = b.renderMarkup(this.getPortLabelMarkup(t.label)), a = e.elem, l = e.selectors, a == null)
+        throw new Error("Invalid port label markup.");
+      if (i && l) {
+        for (const c in l)
+          if (i[c] && c !== this.rootSelector)
+            throw new Error("Selectors within port must be unique.");
+        r = Object.assign(Object.assign({}, i), l);
+      }
+      v(a, "x6-port-label"), o.appendChild(a);
+    }
+    return this.portsCache[t.id] = {
+      portElement: o,
+      portSelectors: r,
+      portLabelElement: a,
+      portLabelSelectors: l,
+      portContentElement: n,
+      portContentSelectors: i
+    }, this.graph.options.onPortRendered && this.graph.options.onPortRendered({
+      port: t,
+      node: this.cell,
+      container: o,
+      selectors: r,
+      labelContainer: a,
+      labelSelectors: l,
+      contentContainer: n,
+      contentSelectors: i
+    }), o;
+  }
+  updatePorts() {
+    const t = this.cell.getParsedGroups(), e = Object.keys(t);
+    e.length === 0 ? this.updatePortGroup() : e.forEach((o) => this.updatePortGroup(o));
+  }
+  updatePortGroup(t) {
+    const e = E.fromSize(this.cell.getSize()), o = this.cell.getPortsLayoutByGroup(t, e);
+    for (let n = 0, i = o.length; n < i; n += 1) {
+      const s = o[n], r = s.portId, a = this.portsCache[r] || {}, l = s.portLayout;
+      if (this.applyPortTransform(a.portElement, l), s.portAttrs != null) {
+        const c = {
+          selectors: a.portSelectors || {}
+        };
+        s.portSize && (c.rootBBox = E.fromSize(s.portSize)), this.updateAttrs(a.portElement, s.portAttrs, c);
+      }
+      const d = s.labelLayout;
+      if (d && a.portLabelElement && (this.applyPortTransform(a.portLabelElement, d, -(l.angle || 0)), d.attrs)) {
+        const c = {
+          selectors: a.portLabelSelectors || {}
+        };
+        s.labelSize && (c.rootBBox = E.fromSize(s.labelSize)), this.updateAttrs(a.portLabelElement, d.attrs, c);
+      }
+    }
+  }
+  applyPortTransform(t, e, o = 0) {
+    const n = e.angle, i = e.position, s = k().rotate(o).translate(i.x || 0, i.y || 0).rotate(n || 0);
+    A(t, s, { absolute: !0 });
+  }
+  getPortMarkup(t) {
+    return t.markup || this.cell.portMarkup;
+  }
+  getPortLabelMarkup(t) {
+    return t.markup || this.cell.portLabelMarkup;
+  }
+  existPortLabel(t) {
+    return t.attrs && t.attrs.text;
+  }
+  getEventArgs(t, e, o) {
+    const n = this, i = n.cell, s = i;
+    return e == null || o == null ? { e: t, view: n, node: i, cell: s } : { e: t, x: e, y: o, view: n, node: i, cell: s };
+  }
+  getPortEventArgs(t, e, o) {
+    const n = this, i = n.cell, s = i;
+    return o ? {
+      e: t,
+      x: o.x,
+      y: o.y,
+      view: n,
+      node: i,
+      cell: s,
+      port: e
+    } : { e: t, view: n, node: i, cell: s, port: e };
+  }
+  notifyMouseDown(t, e, o) {
+    super.onMouseDown(t, e, o), this.notify("node:mousedown", this.getEventArgs(t, e, o));
+  }
+  notifyMouseMove(t, e, o) {
+    super.onMouseMove(t, e, o), this.notify("node:mousemove", this.getEventArgs(t, e, o));
+  }
+  notifyMouseUp(t, e, o) {
+    super.onMouseUp(t, e, o), this.notify("node:mouseup", this.getEventArgs(t, e, o));
+  }
+  notifyPortEvent(t, e, o) {
+    const n = this.findAttr("port", e.target);
+    if (n) {
+      const i = e.type;
+      t === "node:port:mouseenter" ? e.type = "mouseenter" : t === "node:port:mouseleave" && (e.type = "mouseleave"), this.notify(t, this.getPortEventArgs(e, n, o)), e.type = i;
+    }
+  }
+  onClick(t, e, o) {
+    super.onClick(t, e, o), this.notify("node:click", this.getEventArgs(t, e, o)), this.notifyPortEvent("node:port:click", t, { x: e, y: o });
+  }
+  onDblClick(t, e, o) {
+    super.onDblClick(t, e, o), this.notify("node:dblclick", this.getEventArgs(t, e, o)), this.notifyPortEvent("node:port:dblclick", t, { x: e, y: o });
+  }
+  onContextMenu(t, e, o) {
+    super.onContextMenu(t, e, o), this.notify("node:contextmenu", this.getEventArgs(t, e, o)), this.notifyPortEvent("node:port:contextmenu", t, { x: e, y: o });
+  }
+  onMouseDown(t, e, o) {
+    this.isPropagationStopped(t) || (this.notifyMouseDown(t, e, o), this.notifyPortEvent("node:port:mousedown", t, { x: e, y: o }), this.startNodeDragging(t, e, o));
+  }
+  onMouseMove(t, e, o) {
+    const n = this.getEventData(t), i = n.action;
+    if (i === "magnet")
+      this.dragMagnet(t, e, o);
+    else {
+      if (i === "move") {
+        const r = n.targetView || this;
+        r.dragNode(t, e, o), r.notify("node:moving", {
+          e: t,
+          x: e,
+          y: o,
+          view: r,
+          cell: r.cell,
+          node: r.cell
+        });
+      }
+      this.notifyMouseMove(t, e, o), this.notifyPortEvent("node:port:mousemove", t, { x: e, y: o });
+    }
+    this.setEventData(t, n);
+  }
+  onMouseUp(t, e, o) {
+    const n = this.getEventData(t), i = n.action;
+    i === "magnet" ? this.stopMagnetDragging(t, e, o) : (this.notifyMouseUp(t, e, o), this.notifyPortEvent("node:port:mouseup", t, { x: e, y: o }), i === "move" && (n.targetView || this).stopNodeDragging(t, e, o));
+    const s = n.targetMagnet;
+    s && this.onMagnetClick(t, s, e, o), this.checkMouseleave(t);
+  }
+  onMouseOver(t) {
+    super.onMouseOver(t), this.notify("node:mouseover", this.getEventArgs(t)), this.notifyPortEvent("node:port:mouseenter", t), this.notifyPortEvent("node:port:mouseover", t);
+  }
+  onMouseOut(t) {
+    super.onMouseOut(t), this.notify("node:mouseout", this.getEventArgs(t)), this.notifyPortEvent("node:port:mouseleave", t), this.notifyPortEvent("node:port:mouseout", t);
+  }
+  onMouseEnter(t) {
+    this.updateClassName(t), super.onMouseEnter(t), this.notify("node:mouseenter", this.getEventArgs(t));
+  }
+  onMouseLeave(t) {
+    super.onMouseLeave(t), this.notify("node:mouseleave", this.getEventArgs(t));
+  }
+  onMouseWheel(t, e, o, n) {
+    super.onMouseWheel(t, e, o, n), this.notify("node:mousewheel", Object.assign({ delta: n }, this.getEventArgs(t, e, o)));
+  }
+  onMagnetClick(t, e, o, n) {
+    const i = this.graph;
+    i.view.getMouseMovedCount(t) > i.options.clickThreshold || this.notify("node:magnet:click", Object.assign({ magnet: e }, this.getEventArgs(t, o, n)));
+  }
+  onMagnetDblClick(t, e, o, n) {
+    this.notify("node:magnet:dblclick", Object.assign({ magnet: e }, this.getEventArgs(t, o, n)));
+  }
+  onMagnetContextMenu(t, e, o, n) {
+    this.notify("node:magnet:contextmenu", Object.assign({ magnet: e }, this.getEventArgs(t, o, n)));
+  }
+  onMagnetMouseDown(t, e, o, n) {
+    this.startMagnetDragging(t, o, n);
+  }
+  onCustomEvent(t, e, o, n) {
+    this.notify("node:customevent", Object.assign({ name: e }, this.getEventArgs(t, o, n))), super.onCustomEvent(t, e, o, n);
+  }
+  prepareEmbedding(t) {
+    const e = this.graph, n = this.getEventData(t).cell || this.cell, i = e.findViewByCell(n), s = e.snapToGrid(t.clientX, t.clientY);
+    this.notify("node:embed", {
+      e: t,
+      node: n,
+      view: i,
+      cell: n,
+      x: s.x,
+      y: s.y,
+      currentParent: n.getParent()
+    });
+  }
+  processEmbedding(t, e) {
+    const o = e.cell || this.cell, n = e.graph || this.graph, i = n.options.embedding, s = i.findParent;
+    let r = typeof s == "function" ? m(s, n, {
+      view: this,
+      node: this.cell
+    }).filter((h) => T.isCell(h) && this.cell.id !== h.id && !h.isDescendantOf(this.cell)) : n.model.getNodesUnderNode(o, {
+      by: s
+    });
+    if (i.frontOnly && r.length > 0) {
+      const h = w(r, "zIndex"), u = N(Object.keys(h).map((f) => parseInt(f, 10)));
+      u && (r = h[u]);
+    }
+    r = r.filter((h) => h.visible);
+    let a = null;
+    const l = e.candidateEmbedView, d = i.validate;
+    for (let h = r.length - 1; h >= 0; h -= 1) {
+      const u = r[h];
+      if (l && l.cell.id === u.id) {
+        a = l;
+        break;
+      } else {
+        const f = u.findView(n);
+        if (d && m(d, n, {
+          child: this.cell,
+          parent: f.cell,
+          childView: this,
+          parentView: f
+        })) {
+          a = f;
+          break;
+        }
+      }
+    }
+    this.clearEmbedding(e), a && a.highlight(null, { type: "embedding" }), e.candidateEmbedView = a;
+    const c = n.snapToGrid(t.clientX, t.clientY);
+    this.notify("node:embedding", {
+      e: t,
+      cell: o,
+      node: o,
+      view: n.findViewByCell(o),
+      x: c.x,
+      y: c.y,
+      currentParent: o.getParent(),
+      candidateParent: a ? a.cell : null
+    });
+  }
+  clearEmbedding(t) {
+    const e = t.candidateEmbedView;
+    e && (e.unhighlight(null, { type: "embedding" }), t.candidateEmbedView = null);
+  }
+  finalizeEmbedding(t, e) {
+    this.graph.startBatch("embedding");
+    const o = e.cell || this.cell, n = e.graph || this.graph, i = n.findViewByCell(o), s = o.getParent(), r = e.candidateEmbedView;
+    if (r ? (r.unhighlight(null, { type: "embedding" }), e.candidateEmbedView = null, (s == null || s.id !== r.cell.id) && r.cell.insertChild(o, void 0, { ui: !0 })) : s && s.unembed(o, { ui: !0 }), n.model.getConnectedEdges(o, { deep: !0 }).forEach((a) => {
+      a.updateParent({ ui: !0 });
+    }), i && r) {
+      const a = n.snapToGrid(t.clientX, t.clientY);
+      i.notify("node:embedded", {
+        e: t,
+        cell: o,
+        x: a.x,
+        y: a.y,
+        node: o,
+        view: n.findViewByCell(o),
+        previousParent: s,
+        currentParent: o.getParent()
+      });
+    }
+    this.graph.stopBatch("embedding");
+  }
+  getDelegatedView() {
+    let t = this.cell, e = this;
+    for (; e && !t.isEdge(); ) {
+      if (!t.hasParent() || e.can("stopDelegateOnDragging"))
+        return e;
+      t = t.getParent(), e = this.graph.findViewByCell(t);
+    }
+    return null;
+  }
+  validateMagnet(t, e, o) {
+    if (e.getAttribute("magnet") !== "passive") {
+      const n = this.graph.options.connecting.validateMagnet;
+      return n ? m(n, this.graph, {
+        e: o,
+        magnet: e,
+        view: t,
+        cell: t.cell
+      }) : !0;
+    }
+    return !1;
+  }
+  startMagnetDragging(t, e, o) {
+    if (!this.can("magnetConnectable"))
+      return;
+    t.stopPropagation();
+    const n = t.currentTarget, i = this.graph;
+    this.setEventData(t, {
+      targetMagnet: n
+    }), this.validateMagnet(this, n, t) ? (i.options.magnetThreshold <= 0 && this.startConnectting(t, n, e, o), this.setEventData(t, {
+      action: "magnet"
+    }), this.stopPropagation(t)) : this.onMouseDown(t, e, o), i.view.delegateDragEvents(t, this);
+  }
+  startConnectting(t, e, o, n) {
+    this.graph.model.startBatch("add-edge");
+    const i = this.createEdgeFromMagnet(e, o, n);
+    i.setEventData(t, i.prepareArrowheadDragging("target", {
+      x: o,
+      y: n,
+      isNewEdge: !0,
+      fallbackAction: "remove"
+    })), this.setEventData(t, { edgeView: i }), i.notifyMouseDown(t, o, n);
+  }
+  getDefaultEdge(t, e) {
+    let o;
+    const n = this.graph.options.connecting.createEdge;
+    return n && (o = m(n, this.graph, {
+      sourceMagnet: e,
+      sourceView: t,
+      sourceCell: t.cell
+    })), o;
+  }
+  createEdgeFromMagnet(t, e, o) {
+    const n = this.graph, i = n.model, s = this.getDefaultEdge(this, t);
+    return s.setSource(Object.assign(Object.assign({}, s.getSource()), this.getEdgeTerminal(t, e, o, s, "source"))), s.setTarget(Object.assign(Object.assign({}, s.getTarget()), { x: e, y: o })), s.addTo(i, { async: !1, ui: !0 }), s.findView(n);
+  }
+  dragMagnet(t, e, o) {
+    const n = this.getEventData(t), i = n.edgeView;
+    if (i)
+      i.onMouseMove(t, e, o), this.autoScrollGraph(t.clientX, t.clientY);
+    else {
+      const s = this.graph, r = s.options.magnetThreshold, a = this.getEventTarget(t), l = n.targetMagnet;
+      if (r === "onleave") {
+        if (l === a || l.contains(a))
+          return;
+      } else if (s.view.getMouseMovedCount(t) <= r)
+        return;
+      this.startConnectting(t, l, e, o);
+    }
+  }
+  stopMagnetDragging(t, e, o) {
+    const i = this.eventData(t).edgeView;
+    i && (i.onMouseUp(t, e, o), this.graph.model.stopBatch("add-edge"));
+  }
+  notifyUnhandledMouseDown(t, e, o) {
+    this.notify("node:unhandled:mousedown", {
+      e: t,
+      x: e,
+      y: o,
+      view: this,
+      cell: this.cell,
+      node: this.cell
+    });
+  }
+  notifyNodeMove(t, e, o, n, i) {
+    let s = [i];
+    const r = this.graph.getPlugin("selection");
+    if (r && r.isSelectionMovable()) {
+      const a = r.getSelectedCells();
+      a.includes(i) && (s = a.filter((l) => l.isNode()));
+    }
+    s.forEach((a) => {
+      this.notify(t, {
+        e,
+        x: o,
+        y: n,
+        cell: a,
+        node: a,
+        view: a.findView(this.graph)
+      });
+    });
+  }
+  getRestrictArea(t) {
+    const e = this.graph.options.translating.restrict, o = typeof e == "function" ? m(e, this.graph, t) : e;
+    return typeof o == "number" ? this.graph.transform.getGraphArea().inflate(o) : o === !0 ? this.graph.transform.getGraphArea() : o || null;
+  }
+  startNodeDragging(t, e, o) {
+    const n = this.getDelegatedView();
+    if (n == null || !n.can("nodeMovable"))
+      return this.notifyUnhandledMouseDown(t, e, o);
+    this.setEventData(t, {
+      targetView: n,
+      action: "move"
+    });
+    const i = D.create(n.cell.getPosition());
+    n.setEventData(t, {
+      moving: !1,
+      offset: i.diff(e, o),
+      restrict: this.getRestrictArea(n)
+    });
+  }
+  dragNode(t, e, o) {
+    const n = this.cell, i = this.graph, s = i.getGridSize(), r = this.getEventData(t), a = r.offset, l = r.restrict;
+    r.moving || (r.moving = !0, this.addClass("node-moving"), this.notifyNodeMove("node:move", t, e, o, this.cell)), this.autoScrollGraph(t.clientX, t.clientY);
+    const d = M.snapToGrid(e + a.x, s), c = M.snapToGrid(o + a.y, s);
+    n.setPosition(d, c, {
+      restrict: l,
+      deep: !0,
+      ui: !0
+    }), i.options.embedding.enabled && (r.embedding || (this.prepareEmbedding(t), r.embedding = !0), this.processEmbedding(t, r));
+  }
+  stopNodeDragging(t, e, o) {
+    const n = this.getEventData(t);
+    n.embedding && this.finalizeEmbedding(t, n), n.moving && (this.removeClass("node-moving"), this.notifyNodeMove("node:moved", t, e, o, this.cell)), n.moving = !1, n.embedding = !1;
+  }
+  // eslint-disable-next-line
+  autoScrollGraph(t, e) {
+    const o = this.graph.getPlugin("scroller");
+    o && o.autoScroll(t, e);
+  }
+}
+(function(p) {
+  p.toStringTag = `X6.${p.name}`;
+  function t(e) {
+    if (e == null)
+      return !1;
+    if (e instanceof p)
+      return !0;
+    const o = e[Symbol.toStringTag], n = e;
+    return (o == null || o === p.toStringTag) && typeof n.isNodeView == "function" && typeof n.isEdgeView == "function" && typeof n.confirmUpdate == "function" && typeof n.update == "function" && typeof n.findPortElem == "function" && typeof n.resize == "function" && typeof n.rotate == "function" && typeof n.translate == "function";
+  }
+  p.isNodeView = t;
+})(g || (g = {}));
+g.config({
+  isSvgElement: !0,
+  priority: 0,
+  bootstrap: ["render"],
+  actions: {
+    view: ["render"],
+    markup: ["render"],
+    attrs: ["update"],
+    size: ["resize", "ports", "tools"],
+    angle: ["rotate", "tools"],
+    position: ["translate", "tools"],
+    ports: ["ports"],
+    tools: ["tools"]
+  }
+});
+g.registry.register("node", g, !0);
+export {
+  g as NodeView
+};