@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,640 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import { Basecoat as B } from "../../../x6-common/es/common/basecoat.js";
+import { call as S } from "../../../x6-common/es/function/function.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 "../../../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 { Dijkstra as j } from "../../../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 "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as m } 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 { Cell as C } from "./cell.js";
+import { Edge as b } from "./edge.js";
+import { Node as E } from "./node.js";
+import { Collection as I } from "./collection.js";
+var v = function(u, t, e, s) {
+  var i = arguments.length, n = i < 3 ? t : s === null ? s = Object.getOwnPropertyDescriptor(t, e) : s, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") n = Reflect.decorate(u, t, e, s);
+  else for (var r = u.length - 1; r >= 0; r--) (o = u[r]) && (n = (i < 3 ? o(n) : i > 3 ? o(t, e, n) : o(t, e)) || n);
+  return i > 3 && n && Object.defineProperty(t, e, n), n;
+};
+class a extends B {
+  get [Symbol.toStringTag]() {
+    return a.toStringTag;
+  }
+  constructor(t = []) {
+    super(), this.batches = {}, this.addings = /* @__PURE__ */ new WeakMap(), this.nodes = {}, this.edges = {}, this.outgoings = {}, this.incomings = {}, this.collection = new I(t), this.setup();
+  }
+  notify(t, e) {
+    this.trigger(t, e);
+    const s = this.graph;
+    return s && (t === "sorted" || t === "reseted" || t === "updated" ? s.trigger(`model:${t}`, e) : s.trigger(t, e)), this;
+  }
+  setup() {
+    const t = this.collection;
+    t.on("sorted", () => this.notify("sorted", null)), t.on("updated", (e) => this.notify("updated", e)), t.on("cell:change:zIndex", () => this.sortOnChangeZ()), t.on("added", ({ cell: e }) => {
+      this.onCellAdded(e);
+    }), t.on("removed", (e) => {
+      const s = e.cell;
+      this.onCellRemoved(s, e.options), this.notify("cell:removed", e), s.isNode() ? this.notify("node:removed", Object.assign(Object.assign({}, e), { node: s })) : s.isEdge() && this.notify("edge:removed", Object.assign(Object.assign({}, e), { edge: s }));
+    }), t.on("reseted", (e) => {
+      this.onReset(e.current), this.notify("reseted", e);
+    }), t.on("edge:change:source", ({ edge: e }) => this.onEdgeTerminalChanged(e, "source")), t.on("edge:change:target", ({ edge: e }) => {
+      this.onEdgeTerminalChanged(e, "target");
+    });
+  }
+  sortOnChangeZ() {
+    this.collection.sort();
+  }
+  onCellAdded(t) {
+    const e = t.id;
+    t.isEdge() ? (t.updateParent(), this.edges[e] = !0, this.onEdgeTerminalChanged(t, "source"), this.onEdgeTerminalChanged(t, "target")) : this.nodes[e] = !0;
+  }
+  onCellRemoved(t, e) {
+    const s = t.id;
+    if (t.isEdge()) {
+      delete this.edges[s];
+      const i = t.getSource(), n = t.getTarget();
+      if (i && i.cell) {
+        const o = this.outgoings[i.cell], r = o ? o.indexOf(s) : -1;
+        r >= 0 && (o.splice(r, 1), o.length === 0 && delete this.outgoings[i.cell]);
+      }
+      if (n && n.cell) {
+        const o = this.incomings[n.cell], r = o ? o.indexOf(s) : -1;
+        r >= 0 && (o.splice(r, 1), o.length === 0 && delete this.incomings[n.cell]);
+      }
+    } else
+      delete this.nodes[s];
+    e.clear || (e.disconnectEdges ? this.disconnectConnectedEdges(t, e) : this.removeConnectedEdges(t, e)), t.model === this && (t.model = null);
+  }
+  onReset(t) {
+    this.nodes = {}, this.edges = {}, this.outgoings = {}, this.incomings = {}, t.forEach((e) => this.onCellAdded(e));
+  }
+  onEdgeTerminalChanged(t, e) {
+    const s = e === "source" ? this.outgoings : this.incomings, i = t.previous(e);
+    if (i && i.cell) {
+      const o = C.isCell(i.cell) ? i.cell.id : i.cell, r = s[o], h = r ? r.indexOf(t.id) : -1;
+      h >= 0 && (r.splice(h, 1), r.length === 0 && delete s[o]);
+    }
+    const n = t.getTerminal(e);
+    if (n && n.cell) {
+      const o = C.isCell(n.cell) ? n.cell.id : n.cell, r = s[o] || [];
+      r.indexOf(t.id) === -1 && r.push(t.id), s[o] = r;
+    }
+  }
+  prepareCell(t, e) {
+    return !t.model && (!e || !e.dryrun) && (t.model = this), t.zIndex == null && t.setZIndex(this.getMaxZIndex() + 1, { silent: !0 }), t;
+  }
+  resetCells(t, e = {}) {
+    return t.map((s) => this.prepareCell(s, Object.assign(Object.assign({}, e), { dryrun: !0 }))), this.collection.reset(t, e), t.map((s) => this.prepareCell(s, { options: e })), this;
+  }
+  clear(t = {}) {
+    const e = this.getCells();
+    if (e.length === 0)
+      return this;
+    const s = Object.assign(Object.assign({}, t), { clear: !0 });
+    return this.batchUpdate("clear", () => {
+      const i = e.sort((n, o) => {
+        const r = n.isEdge() ? 1 : 2, h = o.isEdge() ? 1 : 2;
+        return r - h;
+      });
+      for (; i.length > 0; ) {
+        const n = i.shift();
+        n && n.remove(s);
+      }
+    }, s), this;
+  }
+  addNode(t, e = {}) {
+    const s = E.isNode(t) ? t : this.createNode(t);
+    return this.addCell(s, e), s;
+  }
+  updateNode(t, e = {}) {
+    const s = this.createNode(t), i = s.getProp();
+    return s.dispose(), this.updateCell(i, e);
+  }
+  createNode(t) {
+    return E.create(t);
+  }
+  addEdge(t, e = {}) {
+    const s = b.isEdge(t) ? t : this.createEdge(t);
+    return this.addCell(s, e), s;
+  }
+  createEdge(t) {
+    return b.create(t);
+  }
+  updateEdge(t, e = {}) {
+    const s = this.createEdge(t), i = s.getProp();
+    return s.dispose(), this.updateCell(i, e);
+  }
+  addCell(t, e = {}) {
+    return Array.isArray(t) ? this.addCells(t, e) : (!this.collection.has(t) && !this.addings.has(t) && (this.addings.set(t, !0), this.collection.add(this.prepareCell(t, e), e), t.eachChild((s) => this.addCell(s, e)), this.addings.delete(t)), this);
+  }
+  addCells(t, e = {}) {
+    const s = t.length;
+    if (s === 0)
+      return this;
+    const i = Object.assign(Object.assign({}, e), { position: s - 1, maxPosition: s - 1 });
+    return this.startBatch("add", Object.assign(Object.assign({}, i), { cells: t })), t.forEach((n) => {
+      this.addCell(n, i), i.position -= 1;
+    }), this.stopBatch("add", Object.assign(Object.assign({}, i), { cells: t })), this;
+  }
+  updateCell(t, e = {}) {
+    const s = t.id && this.getCell(t.id);
+    return s ? this.batchUpdate("update", () => (Object.entries(t).forEach(([i, n]) => s.setProp(i, n, e)), !0), t) : !1;
+  }
+  removeCell(t, e = {}) {
+    const s = typeof t == "string" ? this.getCell(t) : t;
+    return s && this.has(s) ? this.collection.remove(s, e) : null;
+  }
+  updateCellId(t, e) {
+    if (t.id === e)
+      return;
+    this.startBatch("update", { id: e }), t.prop("id", e);
+    const s = t.clone({ keepId: !0 });
+    return this.addCell(s), this.getConnectedEdges(t).forEach((n) => {
+      const o = n.getSourceCell(), r = n.getTargetCell();
+      o === t && n.setSource(Object.assign(Object.assign({}, n.getSource()), { cell: e })), r === t && n.setTarget(Object.assign(Object.assign({}, n.getTarget()), { cell: e }));
+    }), this.removeCell(t), this.stopBatch("update", { id: e }), s;
+  }
+  removeCells(t, e = {}) {
+    return t.length ? this.batchUpdate("remove", () => t.map((s) => this.removeCell(s, e))) : [];
+  }
+  removeConnectedEdges(t, e = {}) {
+    const s = this.getConnectedEdges(t);
+    return s.forEach((i) => {
+      i.remove(e);
+    }), s;
+  }
+  disconnectConnectedEdges(t, e = {}) {
+    const s = typeof t == "string" ? t : t.id;
+    this.getConnectedEdges(t).forEach((i) => {
+      const n = i.getSourceCellId(), o = i.getTargetCellId();
+      n === s && i.setSource({ x: 0, y: 0 }, e), o === s && i.setTarget({ x: 0, y: 0 }, e);
+    });
+  }
+  has(t) {
+    return this.collection.has(t);
+  }
+  total() {
+    return this.collection.length;
+  }
+  indexOf(t) {
+    return this.collection.indexOf(t);
+  }
+  /**
+   * Returns a cell from the graph by its id.
+   */
+  getCell(t) {
+    return this.collection.get(t);
+  }
+  /**
+   * Returns all the nodes and edges in the graph.
+   */
+  getCells() {
+    return this.collection.toArray();
+  }
+  /**
+   * Returns the first cell (node or edge) in the graph. The first cell is
+   * defined as the cell with the lowest `zIndex`.
+   */
+  getFirstCell() {
+    return this.collection.first();
+  }
+  /**
+   * Returns the last cell (node or edge) in the graph. The last cell is
+   * defined as the cell with the highest `zIndex`.
+   */
+  getLastCell() {
+    return this.collection.last();
+  }
+  /**
+   * Returns the lowest `zIndex` value in the graph.
+   */
+  getMinZIndex() {
+    const t = this.collection.first();
+    return t && t.getZIndex() || 0;
+  }
+  /**
+   * Returns the highest `zIndex` value in the graph.
+   */
+  getMaxZIndex() {
+    const t = this.collection.last();
+    return t && t.getZIndex() || 0;
+  }
+  getCellsFromCache(t) {
+    return t ? Object.keys(t).map((e) => this.getCell(e)).filter((e) => e != null) : [];
+  }
+  /**
+   * Returns all the nodes in the graph.
+   */
+  getNodes() {
+    return this.getCellsFromCache(this.nodes);
+  }
+  /**
+   * Returns all the edges in the graph.
+   */
+  getEdges() {
+    return this.getCellsFromCache(this.edges);
+  }
+  /**
+   * Returns all outgoing edges for the node.
+   */
+  getOutgoingEdges(t) {
+    const e = typeof t == "string" ? t : t.id, s = this.outgoings[e];
+    return s ? s.map((i) => this.getCell(i)).filter((i) => i && i.isEdge()) : null;
+  }
+  /**
+   * Returns all incoming edges for the node.
+   */
+  getIncomingEdges(t) {
+    const e = typeof t == "string" ? t : t.id, s = this.incomings[e];
+    return s ? s.map((i) => this.getCell(i)).filter((i) => i && i.isEdge()) : null;
+  }
+  /**
+   * Returns edges connected with cell.
+   */
+  getConnectedEdges(t, e = {}) {
+    const s = [], i = typeof t == "string" ? this.getCell(t) : t;
+    if (i == null)
+      return s;
+    const n = {}, o = e.indirect;
+    let r = e.incoming, h = e.outgoing;
+    r == null && h == null && (r = h = !0);
+    const d = (c, l) => {
+      const f = l ? this.getOutgoingEdges(c) : this.getIncomingEdges(c);
+      if (f?.forEach((g) => {
+        n[g.id] || (s.push(g), n[g.id] = !0, o && (r && d(g, !1), h && d(g, !0)));
+      }), o && c.isEdge()) {
+        const g = l ? c.getTargetCell() : c.getSourceCell();
+        g && g.isEdge() && (n[g.id] || (s.push(g), d(g, l)));
+      }
+    };
+    if (h && d(i, !0), r && d(i, !1), e.deep) {
+      const c = i.getDescendants({ deep: !0 }), l = {};
+      c.forEach((g) => {
+        g.isNode() && (l[g.id] = !0);
+      });
+      const f = (g, x) => {
+        const O = x ? this.getOutgoingEdges(g.id) : this.getIncomingEdges(g.id);
+        O?.forEach((p) => {
+          if (!n[p.id]) {
+            const y = p.getSourceCell(), N = p.getTargetCell();
+            if (!e.enclosed && y && l[y.id] && N && l[N.id])
+              return;
+            s.push(p), n[p.id] = !0;
+          }
+        });
+      };
+      c.forEach((g) => {
+        g.isEdge() || (h && f(g, !0), r && f(g, !1));
+      });
+    }
+    return s;
+  }
+  isBoundary(t, e) {
+    const s = typeof t == "string" ? this.getCell(t) : t, i = e ? this.getIncomingEdges(s) : this.getOutgoingEdges(s);
+    return i == null || i.length === 0;
+  }
+  getBoundaryNodes(t) {
+    const e = [];
+    return Object.keys(this.nodes).forEach((s) => {
+      if (this.isBoundary(s, t)) {
+        const i = this.getCell(s);
+        i && e.push(i);
+      }
+    }), e;
+  }
+  /**
+   * Returns an array of all the roots of the graph.
+   */
+  getRoots() {
+    return this.getBoundaryNodes(!0);
+  }
+  /**
+   * Returns an array of all the leafs of the graph.
+   */
+  getLeafs() {
+    return this.getBoundaryNodes(!1);
+  }
+  /**
+   * Returns `true` if the node is a root node, i.e. there is no edges
+   * coming to the node.
+   */
+  isRoot(t) {
+    return this.isBoundary(t, !0);
+  }
+  /**
+   * Returns `true` if the node is a leaf node, i.e. there is no edges
+   * going out from the node.
+   */
+  isLeaf(t) {
+    return this.isBoundary(t, !1);
+  }
+  /**
+   * Returns all the neighbors of node in the graph. Neighbors are all
+   * the nodes connected to node via either incoming or outgoing edge.
+   */
+  getNeighbors(t, e = {}) {
+    let s = e.incoming, i = e.outgoing;
+    s == null && i == null && (s = i = !0);
+    const o = this.getConnectedEdges(t, e).reduce((r, h) => {
+      const d = h.hasLoop(e), c = h.getSourceCell(), l = h.getTargetCell();
+      return s && c && c.isNode() && !r[c.id] && (d || c !== t && (!e.deep || !c.isDescendantOf(t))) && (r[c.id] = c), i && l && l.isNode() && !r[l.id] && (d || l !== t && (!e.deep || !l.isDescendantOf(t))) && (r[l.id] = l), r;
+    }, {});
+    if (t.isEdge()) {
+      if (s) {
+        const r = t.getSourceCell();
+        r && r.isNode() && !o[r.id] && (o[r.id] = r);
+      }
+      if (i) {
+        const r = t.getTargetCell();
+        r && r.isNode() && !o[r.id] && (o[r.id] = r);
+      }
+    }
+    return Object.keys(o).map((r) => o[r]);
+  }
+  /**
+   * Returns `true` if `cell2` is a neighbor of `cell1`.
+   */
+  isNeighbor(t, e, s = {}) {
+    let i = s.incoming, n = s.outgoing;
+    return i == null && n == null && (i = n = !0), this.getConnectedEdges(t, s).some((o) => {
+      const r = o.getSourceCell(), h = o.getTargetCell();
+      return !!(i && r && r.id === e.id || n && h && h.id === e.id);
+    });
+  }
+  getSuccessors(t, e = {}) {
+    const s = [];
+    return this.search(t, (i, n) => {
+      i !== t && this.matchDistance(n, e.distance) && s.push(i);
+    }, Object.assign(Object.assign({}, e), { outgoing: !0 })), s;
+  }
+  /**
+   * Returns `true` if `cell2` is a successor of `cell1`.
+   */
+  isSuccessor(t, e, s = {}) {
+    let i = !1;
+    return this.search(t, (n, o) => {
+      if (n === e && n !== t && this.matchDistance(o, s.distance))
+        return i = !0, !1;
+    }, Object.assign(Object.assign({}, s), { outgoing: !0 })), i;
+  }
+  getPredecessors(t, e = {}) {
+    const s = [];
+    return this.search(t, (i, n) => {
+      i !== t && this.matchDistance(n, e.distance) && s.push(i);
+    }, Object.assign(Object.assign({}, e), { incoming: !0 })), s;
+  }
+  /**
+   * Returns `true` if `cell2` is a predecessor of `cell1`.
+   */
+  isPredecessor(t, e, s = {}) {
+    let i = !1;
+    return this.search(t, (n, o) => {
+      if (n === e && n !== t && this.matchDistance(o, s.distance))
+        return i = !0, !1;
+    }, Object.assign(Object.assign({}, s), { incoming: !0 })), i;
+  }
+  matchDistance(t, e) {
+    return e == null ? !0 : typeof e == "function" ? e(t) : Array.isArray(e) && e.includes(t) ? !0 : t === e;
+  }
+  /**
+   * Returns the common ancestor of the passed cells.
+   */
+  getCommonAncestor(...t) {
+    const e = [];
+    return t.forEach((s) => {
+      s && (Array.isArray(s) ? e.push(...s) : e.push(s));
+    }), C.getCommonAncestor(...e);
+  }
+  /**
+   * Returns an array of cells that result from finding nodes/edges that
+   * are connected to any of the cells in the cells array. This function
+   * loops over cells and if the current cell is a edge, it collects its
+   * source/target nodes; if it is an node, it collects its incoming and
+   * outgoing edges if both the edge terminal (source/target) are in the
+   * cells array.
+   */
+  getSubGraph(t, e = {}) {
+    const s = [], i = {}, n = [], o = [], r = (h) => {
+      i[h.id] || (s.push(h), i[h.id] = h, h.isEdge() && o.push(h), h.isNode() && n.push(h));
+    };
+    return t.forEach((h) => {
+      r(h), e.deep && h.getDescendants({ deep: !0 }).forEach((c) => r(c));
+    }), o.forEach((h) => {
+      const d = h.getSourceCell(), c = h.getTargetCell();
+      d && !i[d.id] && (s.push(d), i[d.id] = d, d.isNode() && n.push(d)), c && !i[c.id] && (s.push(c), i[c.id] = c, c.isNode() && n.push(c));
+    }), n.forEach((h) => {
+      this.getConnectedEdges(h, e).forEach((c) => {
+        const l = c.getSourceCell(), f = c.getTargetCell();
+        !i[c.id] && l && i[l.id] && f && i[f.id] && (s.push(c), i[c.id] = c);
+      });
+    }), s;
+  }
+  /**
+   * Clones the whole subgraph (including all the connected links whose
+   * source/target is in the subgraph). If `options.deep` is `true`, also
+   * take into account all the embedded cells of all the subgraph cells.
+   *
+   * Returns a map of the form: { [original cell ID]: [clone] }.
+   */
+  cloneSubGraph(t, e = {}) {
+    const s = this.getSubGraph(t, e);
+    return this.cloneCells(s);
+  }
+  cloneCells(t) {
+    return C.cloneCells(t);
+  }
+  getNodesFromPoint(t, e) {
+    const s = typeof t == "number" ? { x: t, y: e || 0 } : t;
+    return this.getNodes().filter((i) => i.getBBox().containsPoint(s));
+  }
+  getNodesInArea(t, e, s, i, n) {
+    const o = typeof t == "number" ? new m(t, e, s, i) : m.create(t), r = typeof t == "number" ? n : e, h = r && r.strict;
+    return this.getNodes().filter((d) => {
+      const c = d.getBBox();
+      return h ? o.containsRect(c) : o.isIntersectWithRect(c);
+    });
+  }
+  getEdgesInArea(t, e, s, i, n) {
+    const o = typeof t == "number" ? new m(t, e, s, i) : m.create(t), r = typeof t == "number" ? n : e, h = r && r.strict;
+    return this.getEdges().filter((d) => {
+      const c = d.getBBox();
+      return c.width === 0 ? c.inflate(1, 0) : c.height === 0 && c.inflate(0, 1), h ? o.containsRect(c) : o.isIntersectWithRect(c);
+    });
+  }
+  getNodesUnderNode(t, e = {}) {
+    const s = t.getBBox();
+    return (e.by == null || e.by === "bbox" ? this.getNodesInArea(s) : this.getNodesFromPoint(s[e.by])).filter((n) => t.id !== n.id && !n.isDescendantOf(t));
+  }
+  /**
+   * Returns the bounding box that surrounds all cells in the graph.
+   */
+  getAllCellsBBox() {
+    return this.getCellsBBox(this.getCells());
+  }
+  /**
+   * Returns the bounding box that surrounds all the given cells.
+   */
+  getCellsBBox(t, e = {}) {
+    return C.getCellsBBox(t, e);
+  }
+  // #region search
+  search(t, e, s = {}) {
+    s.breadthFirst ? this.breadthFirstSearch(t, e, s) : this.depthFirstSearch(t, e, s);
+  }
+  breadthFirstSearch(t, e, s = {}) {
+    const i = [], n = {}, o = {};
+    for (i.push(t), o[t.id] = 0; i.length > 0; ) {
+      const r = i.shift();
+      if (r == null || n[r.id] || (n[r.id] = !0, S(e, this, r, o[r.id]) === !1))
+        continue;
+      this.getNeighbors(r, s).forEach((d) => {
+        o[d.id] = o[r.id] + 1, i.push(d);
+      });
+    }
+  }
+  depthFirstSearch(t, e, s = {}) {
+    const i = [], n = {}, o = {};
+    for (i.push(t), o[t.id] = 0; i.length > 0; ) {
+      const r = i.pop();
+      if (r == null || n[r.id] || (n[r.id] = !0, S(e, this, r, o[r.id]) === !1))
+        continue;
+      const h = this.getNeighbors(r, s), d = i.length;
+      h.forEach((c) => {
+        o[c.id] = o[r.id] + 1, i.splice(d, 0, c);
+      });
+    }
+  }
+  // #endregion
+  // #region shortest path
+  /** *
+   * Returns an array of IDs of nodes on the shortest
+   * path between source and target.
+   */
+  getShortestPath(t, e, s = {}) {
+    const i = {};
+    this.getEdges().forEach((d) => {
+      const c = d.getSourceCellId(), l = d.getTargetCellId();
+      c && l && (i[c] || (i[c] = []), i[l] || (i[l] = []), i[c].push(l), s.directed || i[l].push(c));
+    });
+    const n = typeof t == "string" ? t : t.id, o = j.run(i, n, s.weight), r = [];
+    let h = typeof e == "string" ? e : e.id;
+    for (o[h] && r.push(h); h = o[h]; )
+      r.unshift(h);
+    return r;
+  }
+  // #endregion
+  // #region transform
+  /**
+   * Translate all cells in the graph by `tx` and `ty` pixels.
+   */
+  translate(t, e, s) {
+    return this.getCells().filter((i) => !i.hasParent()).forEach((i) => i.translate(t, e, s)), this;
+  }
+  resize(t, e, s) {
+    return this.resizeCells(t, e, this.getCells(), s);
+  }
+  resizeCells(t, e, s, i = {}) {
+    const n = this.getCellsBBox(s);
+    if (n) {
+      const o = Math.max(t / n.width, 0), r = Math.max(e / n.height, 0), h = n.getOrigin();
+      s.forEach((d) => d.scale(o, r, h, i));
+    }
+    return this;
+  }
+  // #endregion
+  // #region serialize/deserialize
+  toJSON(t = {}) {
+    return a.toJSON(this.getCells(), t);
+  }
+  parseJSON(t) {
+    return a.fromJSON(t);
+  }
+  fromJSON(t, e = {}) {
+    const s = this.parseJSON(t);
+    return this.resetCells(s, e), this;
+  }
+  // #endregion
+  // #region batch
+  startBatch(t, e = {}) {
+    return this.batches[t] = (this.batches[t] || 0) + 1, this.notify("batch:start", { name: t, data: e }), this;
+  }
+  stopBatch(t, e = {}) {
+    return this.batches[t] = (this.batches[t] || 0) - 1, this.notify("batch:stop", { name: t, data: e }), this;
+  }
+  batchUpdate(t, e, s = {}) {
+    this.startBatch(t, s);
+    const i = e();
+    return this.stopBatch(t, s), i;
+  }
+  hasActiveBatch(t = Object.keys(this.batches)) {
+    return (Array.isArray(t) ? t : [t]).some((s) => this.batches[s] > 0);
+  }
+  // #endregion
+  dispose() {
+    this.collection.dispose();
+  }
+}
+v([
+  a.dispose()
+], a.prototype, "dispose", null);
+(function(u) {
+  u.toStringTag = `X6.${u.name}`;
+  function t(e) {
+    if (e == null)
+      return !1;
+    if (e instanceof u)
+      return !0;
+    const s = e[Symbol.toStringTag], i = e;
+    return (s == null || s === u.toStringTag) && typeof i.addNode == "function" && typeof i.addEdge == "function" && i.collection != null;
+  }
+  u.isModel = t;
+})(a || (a = {}));
+(function(u) {
+  function t(s, i = {}) {
+    return {
+      cells: s.map((n) => n.toJSON(i))
+    };
+  }
+  u.toJSON = t;
+  function e(s) {
+    const i = [];
+    return Array.isArray(s) ? i.push(...s) : (s.cells && i.push(...s.cells), s.nodes && s.nodes.forEach((n) => {
+      n.shape == null && (n.shape = "rect"), i.push(n);
+    }), s.edges && s.edges.forEach((n) => {
+      n.shape == null && (n.shape = "edge"), i.push(n);
+    })), i.map((n) => {
+      const o = n.shape;
+      if (o) {
+        if (E.registry.exist(o))
+          return E.create(n);
+        if (b.registry.exist(o))
+          return b.create(n);
+      }
+      throw new Error("The `shape` should be specified when creating a node/edge instance");
+    });
+  }
+  u.fromJSON = e;
+})(a || (a = {}));
+export {
+  a as Model
+};