@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/@antv/x6/es/graph/transform.js

@@ -0,0 +1,255 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { normalizeSides as T, normalizePercentage as C } from "../../../x6-common/es/number/number.js";
+import "../../../x6-common/es/platform/index.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import { createSVGMatrix as y, matrixToTransformString as z, matrixToScale as v, matrixToRotation as B, matrixToTranslation as P } 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 "../../../x6-geometry/es/angle.js";
+import { Point as R } from "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as w } from "../../../x6-geometry/es/rectangle.js";
+import "../../../x6-geometry/es/path/path.js";
+import "../../../x6-geometry/es/util.js";
+import "../../../x6-geometry/es/curve.js";
+import "../../../x6-geometry/es/polyline.js";
+import { Base as G } from "./base.js";
+import { Util as A } from "../util/index.js";
+import b from "../../../../lodash-es/isNumber.js";
+import M from "../../../../lodash-es/clamp.js";
+class gt extends G {
+  get container() {
+    return this.graph.view.container;
+  }
+  get viewport() {
+    return this.graph.view.viewport;
+  }
+  get stage() {
+    return this.graph.view.stage;
+  }
+  init() {
+    this.resize();
+  }
+  /**
+   * Returns the current transformation matrix of the graph.
+   */
+  getMatrix() {
+    const t = this.viewport.getAttribute("transform");
+    return t !== this.viewportTransformString && (this.viewportMatrix = this.viewport.getCTM(), this.viewportTransformString = t), y(this.viewportMatrix);
+  }
+  /**
+   * Sets new transformation with the given `matrix`
+   */
+  setMatrix(t) {
+    const e = y(t), i = z(e);
+    this.viewport.setAttribute("transform", i), this.viewportMatrix = e, this.viewportTransformString = i;
+  }
+  resize(t, e) {
+    let i = t === void 0 ? this.options.width : t, r = e === void 0 ? this.options.height : e;
+    this.options.width = i, this.options.height = r, typeof i == "number" && (i = Math.round(i)), typeof r == "number" && (r = Math.round(r)), this.container.style.width = i == null ? "" : `${i}px`, this.container.style.height = r == null ? "" : `${r}px`;
+    const n = this.getComputedSize();
+    return this.graph.trigger("resize", Object.assign({}, n)), this;
+  }
+  getComputedSize() {
+    let t = this.options.width, e = this.options.height;
+    return b(t) || (t = this.container.clientWidth), b(e) || (e = this.container.clientHeight), { width: t, height: e };
+  }
+  getScale() {
+    return v(this.getMatrix());
+  }
+  scale(t, e = t, i = 0, r = 0) {
+    if (t = this.clampScale(t), e = this.clampScale(e), i || r) {
+      const s = this.getTranslation(), a = s.tx - i * (t - 1), h = s.ty - r * (e - 1);
+      (a !== s.tx || h !== s.ty) && this.translate(a, h);
+    }
+    const n = this.getMatrix();
+    return n.a = t, n.d = e, this.setMatrix(n), this.graph.trigger("scale", { sx: t, sy: e, ox: i, oy: r }), this;
+  }
+  clampScale(t) {
+    const e = this.graph.options.scaling;
+    return M(t, e.min || 0.01, e.max || 16);
+  }
+  getZoom() {
+    return this.getScale().sx;
+  }
+  zoom(t, e) {
+    e = e || {};
+    let i = t, r = t;
+    const n = this.getScale(), s = this.getComputedSize();
+    let a = s.width / 2, h = s.height / 2;
+    if (e.absolute || (i += n.sx, r += n.sy), e.scaleGrid && (i = Math.round(i / e.scaleGrid) * e.scaleGrid, r = Math.round(r / e.scaleGrid) * e.scaleGrid), e.maxScale && (i = Math.min(e.maxScale, i), r = Math.min(e.maxScale, r)), e.minScale && (i = Math.max(e.minScale, i), r = Math.max(e.minScale, r)), e.center && (a = e.center.x, h = e.center.y), i = this.clampScale(i), r = this.clampScale(r), a || h) {
+      const p = this.getTranslation(), f = a - (a - p.tx) * (i / n.sx), x = h - (h - p.ty) * (r / n.sy);
+      (f !== p.tx || x !== p.ty) && this.translate(f, x);
+    }
+    return this.scale(i, r), this;
+  }
+  getRotation() {
+    return B(this.getMatrix());
+  }
+  rotate(t, e, i) {
+    if (e == null || i == null) {
+      const n = A.getBBox(this.stage);
+      e = n.width / 2, i = n.height / 2;
+    }
+    const r = this.getMatrix().translate(e, i).rotate(t).translate(-e, -i);
+    return this.setMatrix(r), this;
+  }
+  getTranslation() {
+    return P(this.getMatrix());
+  }
+  translate(t, e) {
+    const i = this.getMatrix();
+    i.e = t || 0, i.f = e || 0, this.setMatrix(i);
+    const r = this.getTranslation();
+    return this.options.x = r.tx, this.options.y = r.ty, this.graph.trigger("translate", Object.assign({}, r)), this;
+  }
+  setOrigin(t, e) {
+    return this.translate(t || 0, e || 0);
+  }
+  fitToContent(t, e, i, r) {
+    if (typeof t == "object") {
+      const S = t;
+      t = S.gridWidth || 1, e = S.gridHeight || 1, i = S.padding || 0, r = S;
+    } else
+      t = t || 1, e = e || 1, i = i || 0, r == null && (r = {});
+    const n = T(i), s = r.border || 0, a = r.contentArea ? w.create(r.contentArea) : this.getContentArea(r);
+    s > 0 && a.inflate(s);
+    const h = this.getScale(), p = this.getTranslation(), f = h.sx, x = h.sy;
+    a.x *= f, a.y *= x, a.width *= f, a.height *= x;
+    let o = Math.max(Math.ceil((a.width + a.x) / t), 1) * t, m = Math.max(Math.ceil((a.height + a.y) / e), 1) * e, c = 0, l = 0;
+    (r.allowNewOrigin === "negative" && a.x < 0 || r.allowNewOrigin === "positive" && a.x >= 0 || r.allowNewOrigin === "any") && (c = Math.ceil(-a.x / t) * t, c += n.left, o += c), (r.allowNewOrigin === "negative" && a.y < 0 || r.allowNewOrigin === "positive" && a.y >= 0 || r.allowNewOrigin === "any") && (l = Math.ceil(-a.y / e) * e, l += n.top, m += l), o += n.right, m += n.bottom, o = Math.max(o, r.minWidth || 0), m = Math.max(m, r.minHeight || 0), o = Math.min(o, r.maxWidth || Number.MAX_SAFE_INTEGER), m = Math.min(m, r.maxHeight || Number.MAX_SAFE_INTEGER);
+    const u = this.getComputedSize(), g = o !== u.width || m !== u.height;
+    return (c !== p.tx || l !== p.ty) && this.translate(c, l), g && this.resize(o, m), new w(-c / f, -l / x, o / f, m / x);
+  }
+  scaleContentToFit(t = {}) {
+    this.scaleContentToFitImpl(t);
+  }
+  scaleContentToFitImpl(t = {}, e = !0) {
+    let i, r;
+    if (t.contentArea) {
+      const g = t.contentArea;
+      i = this.graph.localToGraph(g), r = R.create(g);
+    } else
+      i = this.getContentBBox(t), r = this.graph.graphToLocal(i);
+    if (!i.width || !i.height)
+      return;
+    const n = T(t.padding), s = t.minScale || 0, a = t.maxScale || Number.MAX_SAFE_INTEGER, h = t.minScaleX || s, p = t.maxScaleX || a, f = t.minScaleY || s, x = t.maxScaleY || a;
+    let o;
+    if (t.viewportArea)
+      o = t.viewportArea;
+    else {
+      const g = this.getComputedSize(), d = this.getTranslation();
+      o = {
+        x: d.tx,
+        y: d.ty,
+        width: g.width,
+        height: g.height
+      };
+    }
+    o = w.create(o).moveAndExpand({
+      x: n.left,
+      y: n.top,
+      width: -n.left - n.right,
+      height: -n.top - n.bottom
+    });
+    const m = this.getScale();
+    let c = o.width / i.width * m.sx, l = o.height / i.height * m.sy;
+    t.preserveAspectRatio !== !1 && (c = l = Math.min(c, l));
+    const u = t.scaleGrid;
+    if (u && (c = u * Math.floor(c / u), l = u * Math.floor(l / u)), c = M(c, h, p), l = M(l, f, x), this.scale(c, l), e) {
+      const g = this.options, d = o.x - r.x * c - g.x, S = o.y - r.y * l - g.y;
+      this.translate(d, S);
+    }
+  }
+  getContentArea(t = {}) {
+    return t.useCellGeometry !== !1 ? this.model.getAllCellsBBox() || new w() : A.getBBox(this.stage);
+  }
+  getContentBBox(t = {}) {
+    return this.graph.localToGraph(this.getContentArea(t));
+  }
+  getGraphArea() {
+    const t = w.fromSize(this.getComputedSize());
+    return this.graph.graphToLocal(t);
+  }
+  zoomToRect(t, e = {}) {
+    const i = w.create(t), r = this.graph;
+    e.contentArea = i, e.viewportArea == null && (e.viewportArea = {
+      x: r.options.x,
+      y: r.options.y,
+      width: this.options.width,
+      height: this.options.height
+    }), this.scaleContentToFitImpl(e, !1);
+    const n = i.getCenter();
+    return this.centerPoint(n.x, n.y), this;
+  }
+  zoomToFit(t = {}) {
+    return this.zoomToRect(this.getContentArea(t), t);
+  }
+  centerPoint(t, e) {
+    const i = this.getComputedSize(), r = this.getScale(), n = this.getTranslation(), s = i.width / 2, a = i.height / 2;
+    t = typeof t == "number" ? t : s, e = typeof e == "number" ? e : a, t = s - t * r.sx, e = a - e * r.sy, (n.tx !== t || n.ty !== e) && this.translate(t, e);
+  }
+  centerContent(t) {
+    const i = this.graph.getContentArea(t).getCenter();
+    this.centerPoint(i.x, i.y);
+  }
+  centerCell(t) {
+    return this.positionCell(t, "center");
+  }
+  positionPoint(t, e, i) {
+    const r = this.getComputedSize();
+    e = C(e, Math.max(0, r.width)), e < 0 && (e = r.width + e), i = C(i, Math.max(0, r.height)), i < 0 && (i = r.height + i);
+    const n = this.getTranslation(), s = this.getScale(), a = e - t.x * s.sx, h = i - t.y * s.sy;
+    (n.tx !== a || n.ty !== h) && this.translate(a, h);
+  }
+  positionRect(t, e) {
+    const i = w.create(t);
+    switch (e) {
+      case "center":
+        return this.positionPoint(i.getCenter(), "50%", "50%");
+      case "top":
+        return this.positionPoint(i.getTopCenter(), "50%", 0);
+      case "top-right":
+        return this.positionPoint(i.getTopRight(), "100%", 0);
+      case "right":
+        return this.positionPoint(i.getRightMiddle(), "100%", "50%");
+      case "bottom-right":
+        return this.positionPoint(i.getBottomRight(), "100%", "100%");
+      case "bottom":
+        return this.positionPoint(i.getBottomCenter(), "50%", "100%");
+      case "bottom-left":
+        return this.positionPoint(i.getBottomLeft(), 0, "100%");
+      case "left":
+        return this.positionPoint(i.getLeftMiddle(), 0, "50%");
+      case "top-left":
+        return this.positionPoint(i.getTopLeft(), 0, 0);
+      default:
+        return this;
+    }
+  }
+  positionCell(t, e) {
+    const i = t.getBBox();
+    return this.positionRect(i, e);
+  }
+  positionContent(t, e) {
+    const i = this.graph.getContentArea(e);
+    return this.positionRect(i, t);
+  }
+}
+export {
+  gt as TransformManager
+};

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

@@ -0,0 +1,404 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { call as c } from "../../../x6-common/es/function/function.js";
+import "../../../x6-common/es/platform/index.js";
+import { ns as u, append as d, empty as m } from "../../../x6-common/es/dom/elem.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import { addClass as p } from "../../../x6-common/es/dom/class.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import "../../../x6-common/es/dom/event/hook.js";
+import "../../../x6-common/es/dom/event/main.js";
+import { EventObject as v } from "../../../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 { Cell as f } from "../model/cell.js";
+import "../model/node.js";
+import "../model/edge.js";
+import "../model/model.js";
+import "../model/collection.js";
+import { Config as g } from "../config/index.js";
+import { Markup as M } from "../view/markup.js";
+import { View as h } from "../view/view.js";
+import "../view/cell.js";
+import "../view/edge.js";
+import "../view/node.js";
+import "../view/tool.js";
+var w = function(a, e, t, n) {
+  var o = arguments.length, s = o < 3 ? e : n === null ? n = Object.getOwnPropertyDescriptor(e, t) : n, i;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") s = Reflect.decorate(a, e, t, n);
+  else for (var r = a.length - 1; r >= 0; r--) (i = a[r]) && (s = (o < 3 ? i(s) : o > 3 ? i(e, t, s) : i(e, t)) || s);
+  return o > 3 && s && Object.defineProperty(e, t, s), s;
+};
+class l extends h {
+  /** Graph's `this.container` is from outer, should not dispose */
+  get disposeContainer() {
+    return !1;
+  }
+  get options() {
+    return this.graph.options;
+  }
+  constructor(e) {
+    super(), this.graph = e;
+    const { selectors: t, fragment: n } = M.parseJSONMarkup(l.markup);
+    this.background = t.background, this.grid = t.grid, this.svg = t.svg, this.defs = t.defs, this.viewport = t.viewport, this.primer = t.primer, this.stage = t.stage, this.decorator = t.decorator, this.overlay = t.overlay, this.container = this.options.container, this.restore = l.snapshoot(this.container), p(this.container, this.prefixClassName("graph")), d(this.container, n), this.delegateEvents();
+  }
+  delegateEvents() {
+    const e = this.constructor;
+    return super.delegateEvents(e.events), this;
+  }
+  /**
+   * Guard the specified event. If the event is not interesting, it
+   * returns `true`, otherwise returns `false`.
+   */
+  guard(e, t) {
+    return e.type === "mousedown" && e.button === 2 || this.options.guard && this.options.guard(e, t) ? !0 : e.data && e.data.guarded !== void 0 ? e.data.guarded : !(t && t.cell && f.isCell(t.cell) || this.svg === e.target || this.container === e.target || this.svg.contains(e.target));
+  }
+  findView(e) {
+    return this.graph.findViewByElem(e);
+  }
+  onDblClick(e) {
+    this.options.preventDefaultDblClick && e.preventDefault();
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (this.guard(t, n))
+      return;
+    const o = this.graph.snapToGrid(t.clientX, t.clientY);
+    n ? n.onDblClick(t, o.x, o.y) : this.graph.trigger("blank:dblclick", {
+      e: t,
+      x: o.x,
+      y: o.y
+    });
+  }
+  onClick(e) {
+    if (this.getMouseMovedCount(e) <= this.options.clickThreshold) {
+      const t = this.normalizeEvent(e), n = this.findView(t.target);
+      if (this.guard(t, n))
+        return;
+      const o = this.graph.snapToGrid(t.clientX, t.clientY);
+      n ? n.onClick(t, o.x, o.y) : this.graph.trigger("blank:click", {
+        e: t,
+        x: o.x,
+        y: o.y
+      });
+    }
+  }
+  isPreventDefaultContextMenu(e) {
+    let t = this.options.preventDefaultContextMenu;
+    return typeof t == "function" && (t = c(t, this.graph, { view: e })), t;
+  }
+  onContextMenu(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (this.isPreventDefaultContextMenu(n) && e.preventDefault(), this.guard(t, n))
+      return;
+    const o = this.graph.snapToGrid(t.clientX, t.clientY);
+    n ? n.onContextMenu(t, o.x, o.y) : this.graph.trigger("blank:contextmenu", {
+      e: t,
+      x: o.x,
+      y: o.y
+    });
+  }
+  delegateDragEvents(e, t) {
+    e.data == null && (e.data = {}), this.setEventData(e, {
+      currentView: t || null,
+      mouseMovedCount: 0,
+      startPosition: {
+        x: e.clientX,
+        y: e.clientY
+      }
+    });
+    const n = this.constructor;
+    this.delegateDocumentEvents(n.documentEvents, e.data), this.undelegateEvents();
+  }
+  getMouseMovedCount(e) {
+    return this.getEventData(e).mouseMovedCount || 0;
+  }
+  onMouseDown(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (this.guard(t, n))
+      return;
+    this.options.preventDefaultMouseDown && e.preventDefault();
+    const o = this.graph.snapToGrid(t.clientX, t.clientY);
+    n ? n.onMouseDown(t, o.x, o.y) : (this.options.preventDefaultBlankAction && ["touchstart"].includes(t.type) && e.preventDefault(), this.graph.trigger("blank:mousedown", {
+      e: t,
+      x: o.x,
+      y: o.y
+    })), this.delegateDragEvents(t, n);
+  }
+  onMouseMove(e) {
+    const t = this.getEventData(e), n = t.startPosition;
+    if (n && n.x === e.clientX && n.y === e.clientY || (t.mouseMovedCount == null && (t.mouseMovedCount = 0), t.mouseMovedCount += 1, t.mouseMovedCount <= this.options.moveThreshold))
+      return;
+    const s = this.normalizeEvent(e), i = this.graph.snapToGrid(s.clientX, s.clientY), r = t.currentView;
+    r ? r.onMouseMove(s, i.x, i.y) : this.graph.trigger("blank:mousemove", {
+      e: s,
+      x: i.x,
+      y: i.y
+    }), this.setEventData(s, t);
+  }
+  onMouseUp(e) {
+    this.undelegateDocumentEvents();
+    const t = this.normalizeEvent(e), n = this.graph.snapToGrid(t.clientX, t.clientY), s = this.getEventData(e).currentView;
+    if (s ? s.onMouseUp(t, n.x, n.y) : this.graph.trigger("blank:mouseup", {
+      e: t,
+      x: n.x,
+      y: n.y
+    }), !e.isPropagationStopped()) {
+      const i = new v(e, {
+        type: "click",
+        data: e.data
+      });
+      this.onClick(i);
+    }
+    e.stopImmediatePropagation(), this.delegateEvents();
+  }
+  onMouseOver(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (!this.guard(t, n))
+      if (n)
+        n.onMouseOver(t);
+      else {
+        if (this.container === t.target)
+          return;
+        this.graph.trigger("blank:mouseover", { e: t });
+      }
+  }
+  onMouseOut(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (!this.guard(t, n))
+      if (n)
+        n.onMouseOut(t);
+      else {
+        if (this.container === t.target)
+          return;
+        this.graph.trigger("blank:mouseout", { e: t });
+      }
+  }
+  onMouseEnter(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (this.guard(t, n))
+      return;
+    const o = this.graph.findViewByElem(t.relatedTarget);
+    if (n) {
+      if (o === n)
+        return;
+      n.onMouseEnter(t);
+    } else {
+      if (o)
+        return;
+      this.graph.trigger("graph:mouseenter", { e: t });
+    }
+  }
+  onMouseLeave(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (this.guard(t, n))
+      return;
+    const o = this.graph.findViewByElem(t.relatedTarget);
+    if (n) {
+      if (o === n)
+        return;
+      n.onMouseLeave(t);
+    } else {
+      if (o)
+        return;
+      this.graph.trigger("graph:mouseleave", { e: t });
+    }
+  }
+  onMouseWheel(e) {
+    const t = this.normalizeEvent(e), n = this.findView(t.target);
+    if (this.guard(t, n))
+      return;
+    const o = t.originalEvent, s = this.graph.snapToGrid(o.clientX, o.clientY), i = Math.max(-1, Math.min(1, o.wheelDelta || -o.detail));
+    n ? n.onMouseWheel(t, s.x, s.y, i) : this.graph.trigger("blank:mousewheel", {
+      e: t,
+      delta: i,
+      x: s.x,
+      y: s.y
+    });
+  }
+  onCustomEvent(e) {
+    const t = e.currentTarget, n = t.getAttribute("event") || t.getAttribute("data-event");
+    if (n) {
+      const o = this.findView(t);
+      if (o) {
+        const s = this.normalizeEvent(e);
+        if (this.guard(s, o))
+          return;
+        const i = this.graph.snapToGrid(s.clientX, s.clientY);
+        o.onCustomEvent(s, n, i.x, i.y);
+      }
+    }
+  }
+  handleMagnetEvent(e, t) {
+    const n = e.currentTarget, o = n.getAttribute("magnet");
+    if (o && o.toLowerCase() !== "false") {
+      const s = this.findView(n);
+      if (s) {
+        const i = this.normalizeEvent(e);
+        if (this.guard(i, s))
+          return;
+        const r = this.graph.snapToGrid(i.clientX, i.clientY);
+        c(t, this.graph, s, i, n, r.x, r.y);
+      }
+    }
+  }
+  onMagnetMouseDown(e) {
+    this.handleMagnetEvent(e, (t, n, o, s, i) => {
+      t.onMagnetMouseDown(n, o, s, i);
+    });
+  }
+  onMagnetDblClick(e) {
+    this.handleMagnetEvent(e, (t, n, o, s, i) => {
+      t.onMagnetDblClick(n, o, s, i);
+    });
+  }
+  onMagnetContextMenu(e) {
+    const t = this.findView(e.target);
+    this.isPreventDefaultContextMenu(t) && e.preventDefault(), this.handleMagnetEvent(e, (n, o, s, i, r) => {
+      n.onMagnetContextMenu(o, s, i, r);
+    });
+  }
+  onLabelMouseDown(e) {
+    const t = e.currentTarget, n = this.findView(t);
+    if (n) {
+      const o = this.normalizeEvent(e);
+      if (this.guard(o, n))
+        return;
+      const s = this.graph.snapToGrid(o.clientX, o.clientY);
+      n.onLabelMouseDown(o, s.x, s.y);
+    }
+  }
+  onImageDragStart() {
+    return !1;
+  }
+  dispose() {
+    this.undelegateEvents(), this.undelegateDocumentEvents(), this.restore(), this.restore = () => {
+    };
+  }
+}
+w([
+  h.dispose()
+], l.prototype, "dispose", null);
+(function(a) {
+  const e = `${g.prefixCls}-graph`;
+  a.markup = [
+    {
+      ns: u.xhtml,
+      tagName: "div",
+      selector: "background",
+      className: `${e}-background`
+    },
+    {
+      ns: u.xhtml,
+      tagName: "div",
+      selector: "grid",
+      className: `${e}-grid`
+    },
+    {
+      ns: u.svg,
+      tagName: "svg",
+      selector: "svg",
+      className: `${e}-svg`,
+      attrs: {
+        width: "100%",
+        height: "100%",
+        "xmlns:xlink": u.xlink
+      },
+      children: [
+        {
+          tagName: "defs",
+          selector: "defs"
+        },
+        {
+          tagName: "g",
+          selector: "viewport",
+          className: `${e}-svg-viewport`,
+          children: [
+            {
+              tagName: "g",
+              selector: "primer",
+              className: `${e}-svg-primer`
+            },
+            {
+              tagName: "g",
+              selector: "stage",
+              className: `${e}-svg-stage`
+            },
+            {
+              tagName: "g",
+              selector: "decorator",
+              className: `${e}-svg-decorator`
+            },
+            {
+              tagName: "g",
+              selector: "overlay",
+              className: `${e}-svg-overlay`
+            }
+          ]
+        }
+      ]
+    }
+  ];
+  function t(n) {
+    const o = n.cloneNode();
+    return n.childNodes.forEach((s) => o.appendChild(s)), () => {
+      for (m(n); n.attributes.length > 0; )
+        n.removeAttribute(n.attributes[0].name);
+      for (let s = 0, i = o.attributes.length; s < i; s += 1) {
+        const r = o.attributes[s];
+        n.setAttribute(r.name, r.value);
+      }
+      o.childNodes.forEach((s) => n.appendChild(s));
+    };
+  }
+  a.snapshoot = t;
+})(l || (l = {}));
+(function(a) {
+  const e = g.prefixCls;
+  a.events = {
+    dblclick: "onDblClick",
+    contextmenu: "onContextMenu",
+    touchstart: "onMouseDown",
+    mousedown: "onMouseDown",
+    mouseover: "onMouseOver",
+    mouseout: "onMouseOut",
+    mouseenter: "onMouseEnter",
+    mouseleave: "onMouseLeave",
+    mousewheel: "onMouseWheel",
+    DOMMouseScroll: "onMouseWheel",
+    [`mouseenter  .${e}-cell`]: "onMouseEnter",
+    [`mouseleave  .${e}-cell`]: "onMouseLeave",
+    [`mouseenter  .${e}-cell-tools`]: "onMouseEnter",
+    [`mouseleave  .${e}-cell-tools`]: "onMouseLeave",
+    [`mousedown   .${e}-cell [event]`]: "onCustomEvent",
+    [`touchstart  .${e}-cell [event]`]: "onCustomEvent",
+    [`mousedown   .${e}-cell [data-event]`]: "onCustomEvent",
+    [`touchstart  .${e}-cell [data-event]`]: "onCustomEvent",
+    [`dblclick    .${e}-cell [magnet]`]: "onMagnetDblClick",
+    [`contextmenu .${e}-cell [magnet]`]: "onMagnetContextMenu",
+    [`mousedown   .${e}-cell [magnet]`]: "onMagnetMouseDown",
+    [`touchstart  .${e}-cell [magnet]`]: "onMagnetMouseDown",
+    [`dblclick    .${e}-cell [data-magnet]`]: "onMagnetDblClick",
+    [`contextmenu .${e}-cell [data-magnet]`]: "onMagnetContextMenu",
+    [`mousedown   .${e}-cell [data-magnet]`]: "onMagnetMouseDown",
+    [`touchstart  .${e}-cell [data-magnet]`]: "onMagnetMouseDown",
+    [`dragstart   .${e}-cell image`]: "onImageDragStart",
+    [`mousedown   .${e}-edge .${e}-edge-label`]: "onLabelMouseDown",
+    [`touchstart  .${e}-edge .${e}-edge-label`]: "onLabelMouseDown"
+  }, a.documentEvents = {
+    mousemove: "onMouseMove",
+    touchmove: "onMouseMove",
+    mouseup: "onMouseUp",
+    touchend: "onMouseUp",
+    touchcancel: "onMouseUp"
+  };
+})(l || (l = {}));
+export {
+  l as GraphView
+};