@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,764 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import { Basecoat as I } from "../../../x6-common/es/common/basecoat.js";
+import { uuid as B } from "../../../x6-common/es/string/uuid.js";
+import { call as w } 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 "../../../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 H } from "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as S } 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 "../registry/grid/index.js";
+import "../registry/background/index.js";
+import "../registry/filter/index.js";
+import { Attr as T } from "../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 "../registry/node-anchor/index.js";
+import "../registry/edge-anchor/index.js";
+import "../registry/connection-point/index.js";
+import "../registry/router/index.js";
+import "../registry/connector/index.js";
+import "../registry/registry.js";
+import { Store as k } from "./store.js";
+import { Animation as $ } from "./animation.js";
+import A from "../../../../lodash-es/merge.js";
+import C from "../../../../lodash-es/cloneDeep.js";
+import z from "../../../../lodash-es/camelCase.js";
+import Z from "../../../../lodash-es/isPlainObject.js";
+import j from "../../../../lodash-es/isEqual.js";
+import _ from "../../../../lodash-es/isObject.js";
+import M from "../../../../lodash-es/isEmpty.js";
+import V from "../../../../lodash-es/uniq.js";
+var F = function(h, t, e, s) {
+  var r = arguments.length, i = r < 3 ? t : s === null ? s = Object.getOwnPropertyDescriptor(t, e) : s, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") i = Reflect.decorate(h, t, e, s);
+  else for (var n = h.length - 1; n >= 0; n--) (o = h[n]) && (i = (r < 3 ? o(i) : r > 3 ? o(t, e, i) : o(t, e)) || i);
+  return r > 3 && i && Object.defineProperty(t, e, i), i;
+}, D = function(h, t) {
+  var e = {};
+  for (var s in h) Object.prototype.hasOwnProperty.call(h, s) && t.indexOf(s) < 0 && (e[s] = h[s]);
+  if (h != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var r = 0, s = Object.getOwnPropertySymbols(h); r < s.length; r++)
+      t.indexOf(s[r]) < 0 && Object.prototype.propertyIsEnumerable.call(h, s[r]) && (e[s[r]] = h[s[r]]);
+  return e;
+};
+class f extends I {
+  static config(t) {
+    const { markup: e, propHooks: s, attrHooks: r } = t, i = D(t, ["markup", "propHooks", "attrHooks"]);
+    e != null && (this.markup = e), s && (this.propHooks = this.propHooks.slice(), Array.isArray(s) ? this.propHooks.push(...s) : typeof s == "function" ? this.propHooks.push(s) : Object.values(s).forEach((o) => {
+      typeof o == "function" && this.propHooks.push(o);
+    })), r && (this.attrHooks = Object.assign(Object.assign({}, this.attrHooks), r)), this.defaults = A({}, this.defaults, i);
+  }
+  static getMarkup() {
+    return this.markup;
+  }
+  static getDefaults(t) {
+    return t ? this.defaults : C(this.defaults);
+  }
+  static getAttrHooks() {
+    return this.attrHooks;
+  }
+  static applyPropHooks(t, e) {
+    return this.propHooks.reduce((s, r) => r ? w(r, t, s) : s, e);
+  }
+  // #endregion
+  get [Symbol.toStringTag]() {
+    return f.toStringTag;
+  }
+  constructor(t = {}) {
+    super();
+    const s = this.constructor.getDefaults(!0), r = A({}, this.preprocess(s), this.preprocess(t));
+    this.id = r.id || B(), this.store = new k(r), this.animation = new $(this), this.setup(), this.init(), this.postprocess(t);
+  }
+  init() {
+  }
+  // #region model
+  get model() {
+    return this._model;
+  }
+  set model(t) {
+    this._model !== t && (this._model = t);
+  }
+  // #endregion
+  preprocess(t, e) {
+    const s = t.id, i = this.constructor.applyPropHooks(this, t);
+    return s == null && e !== !0 && (i.id = B()), i;
+  }
+  postprocess(t) {
+  }
+  // eslint-disable-line
+  setup() {
+    this.store.on("change:*", (t) => {
+      const { key: e, current: s, previous: r, options: i } = t;
+      this.notify("change:*", {
+        key: e,
+        options: i,
+        current: s,
+        previous: r,
+        cell: this
+      }), this.notify(`change:${e}`, {
+        options: i,
+        current: s,
+        previous: r,
+        cell: this
+      });
+      const o = e;
+      (o === "source" || o === "target") && this.notify("change:terminal", {
+        type: o,
+        current: s,
+        previous: r,
+        options: i,
+        cell: this
+      });
+    }), this.store.on("changed", ({ options: t }) => this.notify("changed", { options: t, cell: this }));
+  }
+  notify(t, e) {
+    this.trigger(t, e);
+    const s = this.model;
+    return s && (s.notify(`cell:${t}`, e), this.isNode() ? s.notify(`node:${t}`, Object.assign(Object.assign({}, e), { node: this })) : this.isEdge() && s.notify(`edge:${t}`, Object.assign(Object.assign({}, e), { edge: this }))), this;
+  }
+  isNode() {
+    return !1;
+  }
+  isEdge() {
+    return !1;
+  }
+  isSameStore(t) {
+    return this.store === t.store;
+  }
+  get view() {
+    return this.store.get("view");
+  }
+  get shape() {
+    return this.store.get("shape", "");
+  }
+  getProp(t, e) {
+    return t == null ? this.store.get() : this.store.get(t, e);
+  }
+  setProp(t, e, s) {
+    if (typeof t == "string")
+      this.store.set(t, e, s);
+    else {
+      const r = this.preprocess(t, !0);
+      this.store.set(A({}, this.getProp(), r), e), this.postprocess(t);
+    }
+    return this;
+  }
+  removeProp(t, e) {
+    return typeof t == "string" || Array.isArray(t) ? this.store.removeByPath(t, e) : this.store.remove(e), this;
+  }
+  hasChanged(t) {
+    return t == null ? this.store.hasChanged() : this.store.hasChanged(t);
+  }
+  getPropByPath(t) {
+    return this.store.getByPath(t);
+  }
+  setPropByPath(t, e, s = {}) {
+    return this.model && (t === "children" ? this._children = e ? e.map((r) => this.model.getCell(r)).filter((r) => r != null) : null : t === "parent" && (this._parent = e ? this.model.getCell(e) : null)), this.store.setByPath(t, e, s), this;
+  }
+  removePropByPath(t, e = {}) {
+    const s = Array.isArray(t) ? t : t.split("/");
+    return s[0] === "attrs" && (e.dirty = !0), this.store.removeByPath(s, e), this;
+  }
+  prop(t, e, s) {
+    return t == null ? this.getProp() : typeof t == "string" || Array.isArray(t) ? arguments.length === 1 ? this.getPropByPath(t) : e == null ? this.removePropByPath(t, s || {}) : this.setPropByPath(t, e, s || {}) : this.setProp(t, e || {});
+  }
+  previous(t) {
+    return this.store.getPrevious(t);
+  }
+  // #endregion
+  // #region zIndex
+  get zIndex() {
+    return this.getZIndex();
+  }
+  set zIndex(t) {
+    t == null ? this.removeZIndex() : this.setZIndex(t);
+  }
+  getZIndex() {
+    return this.store.get("zIndex");
+  }
+  setZIndex(t, e = {}) {
+    return this.store.set("zIndex", t, e), this;
+  }
+  removeZIndex(t = {}) {
+    return this.store.remove("zIndex", t), this;
+  }
+  toFront(t = {}) {
+    const e = this.model;
+    if (e) {
+      let s = e.getMaxZIndex(), r;
+      t.deep ? (r = this.getDescendants({ deep: !0, breadthFirst: !0 }), r.unshift(this)) : r = [this], s = s - r.length + 1;
+      const i = e.total();
+      let o = e.indexOf(this) !== i - r.length;
+      o || (o = r.some((n, l) => n.getZIndex() !== s + l)), o && this.batchUpdate("to-front", () => {
+        s += r.length, r.forEach((n, l) => {
+          n.setZIndex(s + l, t);
+        });
+      });
+    }
+    return this;
+  }
+  toBack(t = {}) {
+    const e = this.model;
+    if (e) {
+      let s = e.getMinZIndex(), r;
+      t.deep ? (r = this.getDescendants({ deep: !0, breadthFirst: !0 }), r.unshift(this)) : r = [this];
+      let i = e.indexOf(this) !== 0;
+      i || (i = r.some((o, n) => o.getZIndex() !== s + n)), i && this.batchUpdate("to-back", () => {
+        s -= r.length, r.forEach((o, n) => {
+          o.setZIndex(s + n, t);
+        });
+      });
+    }
+    return this;
+  }
+  // #endregion
+  // #region markup
+  get markup() {
+    return this.getMarkup();
+  }
+  set markup(t) {
+    t == null ? this.removeMarkup() : this.setMarkup(t);
+  }
+  getMarkup() {
+    let t = this.store.get("markup");
+    return t == null && (t = this.constructor.getMarkup()), t;
+  }
+  setMarkup(t, e = {}) {
+    return this.store.set("markup", t, e), this;
+  }
+  removeMarkup(t = {}) {
+    return this.store.remove("markup", t), this;
+  }
+  // #endregion
+  // #region attrs
+  get attrs() {
+    return this.getAttrs();
+  }
+  set attrs(t) {
+    t == null ? this.removeAttrs() : this.setAttrs(t);
+  }
+  getAttrs() {
+    const t = this.store.get("attrs");
+    return t ? Object.assign({}, t) : {};
+  }
+  setAttrs(t, e = {}) {
+    if (t == null)
+      this.removeAttrs(e);
+    else {
+      const s = (r) => this.store.set("attrs", r, e);
+      if (e.overwrite === !0)
+        s(t);
+      else {
+        const r = this.getAttrs();
+        e.deep === !1 ? s(Object.assign(Object.assign({}, r), t)) : s(A({}, r, t));
+      }
+    }
+    return this;
+  }
+  replaceAttrs(t, e = {}) {
+    return this.setAttrs(t, Object.assign(Object.assign({}, e), { overwrite: !0 }));
+  }
+  updateAttrs(t, e = {}) {
+    return this.setAttrs(t, Object.assign(Object.assign({}, e), { deep: !1 }));
+  }
+  removeAttrs(t = {}) {
+    return this.store.remove("attrs", t), this;
+  }
+  getAttrDefinition(t) {
+    if (!t)
+      return null;
+    const s = this.constructor.getAttrHooks() || {};
+    let r = s[t] || T.registry.get(t);
+    if (!r) {
+      const i = z(t);
+      r = s[i] || T.registry.get(i);
+    }
+    return r || null;
+  }
+  getAttrByPath(t) {
+    return t == null || t === "" ? this.getAttrs() : this.getPropByPath(this.prefixAttrPath(t));
+  }
+  setAttrByPath(t, e, s = {}) {
+    return this.setPropByPath(this.prefixAttrPath(t), e, s), this;
+  }
+  removeAttrByPath(t, e = {}) {
+    return this.removePropByPath(this.prefixAttrPath(t), e), this;
+  }
+  prefixAttrPath(t) {
+    return Array.isArray(t) ? ["attrs"].concat(t) : `attrs/${t}`;
+  }
+  attr(t, e, s) {
+    return t == null ? this.getAttrByPath() : typeof t == "string" || Array.isArray(t) ? arguments.length === 1 ? this.getAttrByPath(t) : e == null ? this.removeAttrByPath(t, s || {}) : this.setAttrByPath(t, e, s || {}) : this.setAttrs(t, e || {});
+  }
+  // #endregion
+  // #region visible
+  get visible() {
+    return this.isVisible();
+  }
+  set visible(t) {
+    this.setVisible(t);
+  }
+  setVisible(t, e = {}) {
+    return this.store.set("visible", t, e), this;
+  }
+  isVisible() {
+    return this.store.get("visible") !== !1;
+  }
+  show(t = {}) {
+    return this.isVisible() || this.setVisible(!0, t), this;
+  }
+  hide(t = {}) {
+    return this.isVisible() && this.setVisible(!1, t), this;
+  }
+  toggleVisible(t, e = {}) {
+    const s = typeof t == "boolean" ? t : !this.isVisible(), r = typeof t == "boolean" ? e : t;
+    return s ? this.show(r) : this.hide(r), this;
+  }
+  // #endregion
+  // #region data
+  get data() {
+    return this.getData();
+  }
+  set data(t) {
+    this.setData(t);
+  }
+  getData() {
+    return this.store.get("data");
+  }
+  setData(t, e = {}) {
+    if (t == null)
+      this.removeData(e);
+    else {
+      const s = (r) => this.store.set("data", r, e);
+      if (e.overwrite === !0)
+        s(t);
+      else {
+        const r = this.getData();
+        e.deep === !1 ? s(typeof t == "object" ? Object.assign(Object.assign({}, r), t) : t) : s(A({}, r, t));
+      }
+    }
+    return this;
+  }
+  replaceData(t, e = {}) {
+    return this.setData(t, Object.assign(Object.assign({}, e), { overwrite: !0 }));
+  }
+  updateData(t, e = {}) {
+    return this.setData(t, Object.assign(Object.assign({}, e), { deep: !1 }));
+  }
+  removeData(t = {}) {
+    return this.store.remove("data", t), this;
+  }
+  // #endregion
+  // #region parent children
+  get parent() {
+    return this.getParent();
+  }
+  get children() {
+    return this.getChildren();
+  }
+  getParentId() {
+    return this.store.get("parent");
+  }
+  getParent() {
+    const t = this.getParentId();
+    if (t && this.model) {
+      const e = this.model.getCell(t);
+      return this._parent = e, e;
+    }
+    return null;
+  }
+  getChildren() {
+    const t = this.store.get("children");
+    if (t && t.length && this.model) {
+      const e = t.map((s) => {
+        var r;
+        return (r = this.model) === null || r === void 0 ? void 0 : r.getCell(s);
+      }).filter((s) => s != null);
+      return this._children = e, [...e];
+    }
+    return null;
+  }
+  hasParent() {
+    return this.parent != null;
+  }
+  isParentOf(t) {
+    return t != null && t.getParent() === this;
+  }
+  isChildOf(t) {
+    return t != null && this.getParent() === t;
+  }
+  eachChild(t, e) {
+    return this.children && this.children.forEach(t, e), this;
+  }
+  filterChild(t, e) {
+    return this.children ? this.children.filter(t, e) : [];
+  }
+  getChildCount() {
+    return this.children == null ? 0 : this.children.length;
+  }
+  getChildIndex(t) {
+    return this.children == null ? -1 : this.children.indexOf(t);
+  }
+  getChildAt(t) {
+    return this.children != null && t >= 0 ? this.children[t] : null;
+  }
+  getAncestors(t = {}) {
+    const e = [];
+    let s = this.getParent();
+    for (; s; )
+      e.push(s), s = t.deep !== !1 ? s.getParent() : null;
+    return e;
+  }
+  getDescendants(t = {}) {
+    if (t.deep !== !1) {
+      if (t.breadthFirst) {
+        const e = [], s = this.getChildren() || [];
+        for (; s.length > 0; ) {
+          const r = s.shift(), i = r.getChildren();
+          e.push(r), i && s.push(...i);
+        }
+        return e;
+      }
+      {
+        const e = this.getChildren() || [];
+        return e.forEach((s) => {
+          e.push(...s.getDescendants(t));
+        }), e;
+      }
+    }
+    return this.getChildren() || [];
+  }
+  isDescendantOf(t, e = {}) {
+    if (t == null)
+      return !1;
+    if (e.deep !== !1) {
+      let s = this.getParent();
+      for (; s; ) {
+        if (s === t)
+          return !0;
+        s = s.getParent();
+      }
+      return !1;
+    }
+    return this.isChildOf(t);
+  }
+  isAncestorOf(t, e = {}) {
+    return t == null ? !1 : t.isDescendantOf(this, e);
+  }
+  contains(t) {
+    return this.isAncestorOf(t);
+  }
+  getCommonAncestor(...t) {
+    return f.getCommonAncestor(this, ...t);
+  }
+  setParent(t, e = {}) {
+    return this._parent = t, t ? this.store.set("parent", t.id, e) : this.store.remove("parent", e), this;
+  }
+  setChildren(t, e = {}) {
+    return this._children = t, t != null ? this.store.set("children", t.map((s) => s.id), e) : this.store.remove("children", e), this;
+  }
+  unembed(t, e = {}) {
+    const s = this.children;
+    if (s != null && t != null) {
+      const r = this.getChildIndex(t);
+      r !== -1 && (s.splice(r, 1), t.setParent(null, e), this.setChildren(s, e));
+    }
+    return this;
+  }
+  embed(t, e = {}) {
+    return t.addTo(this, e), this;
+  }
+  addTo(t, e = {}) {
+    return f.isCell(t) ? t.addChild(this, e) : t.addCell(this, e), this;
+  }
+  insertTo(t, e, s = {}) {
+    return t.insertChild(this, e, s), this;
+  }
+  addChild(t, e = {}) {
+    return this.insertChild(t, void 0, e);
+  }
+  insertChild(t, e, s = {}) {
+    if (t != null && t !== this) {
+      const r = t.getParent(), i = this !== r;
+      let o = e;
+      if (o == null && (o = this.getChildCount(), i || (o -= 1)), r) {
+        const l = r.getChildren();
+        if (l) {
+          const u = l.indexOf(t);
+          u >= 0 && (t.setParent(null, s), l.splice(u, 1), r.setChildren(l, s));
+        }
+      }
+      let n = this.children;
+      if (n == null ? (n = [], n.push(t)) : n.splice(o, 0, t), t.setParent(this, s), this.setChildren(n, s), i && this.model) {
+        const l = this.model.getIncomingEdges(this), u = this.model.getOutgoingEdges(this);
+        l && l.forEach((p) => p.updateParent(s)), u && u.forEach((p) => p.updateParent(s));
+      }
+      this.model && this.model.addCell(t, s);
+    }
+    return this;
+  }
+  removeFromParent(t = {}) {
+    const e = this.getParent();
+    if (e != null) {
+      const s = e.getChildIndex(this);
+      e.removeChildAt(s, t);
+    }
+    return this;
+  }
+  removeChild(t, e = {}) {
+    const s = this.getChildIndex(t);
+    return this.removeChildAt(s, e);
+  }
+  removeChildAt(t, e = {}) {
+    const s = this.getChildAt(t);
+    return this.children != null && s != null && (this.unembed(s, e), s.remove(e)), s;
+  }
+  remove(t = {}) {
+    return this.batchUpdate("remove", () => {
+      const e = this.getParent();
+      e && e.removeChild(this, t), t.deep !== !1 && this.eachChild((s) => s.remove(t)), this.model && this.model.removeCell(this, t);
+    }), this;
+  }
+  transition(t, e, s = {}, r = "/") {
+    return this.animation.start(t, e, s, r);
+  }
+  stopTransition(t, e, s = "/") {
+    return this.animation.stop(t, e, s), this;
+  }
+  getTransitions() {
+    return this.animation.get();
+  }
+  // #endregion
+  // #region transform
+  // eslint-disable-next-line
+  translate(t, e, s) {
+    return this;
+  }
+  scale(t, e, s, r) {
+    return this;
+  }
+  addTools(t, e, s) {
+    const r = Array.isArray(t) ? t : [t], i = typeof e == "string" ? e : null, o = typeof e == "object" ? e : typeof s == "object" ? s : {};
+    if (o.reset)
+      return this.setTools({ name: i, items: r, local: o.local }, o);
+    let n = C(this.getTools());
+    if (n == null || i == null || n.name === i)
+      return n == null && (n = {}), n.items || (n.items = []), n.name = i, n.items = [...n.items, ...r], this.setTools(Object.assign({}, n), o);
+  }
+  setTools(t, e = {}) {
+    return t == null ? this.removeTools() : this.store.set("tools", f.normalizeTools(t), e), this;
+  }
+  getTools() {
+    return this.store.get("tools");
+  }
+  removeTools(t = {}) {
+    return this.store.remove("tools", t), this;
+  }
+  hasTools(t) {
+    const e = this.getTools();
+    return e == null ? !1 : t == null ? !0 : e.name === t;
+  }
+  hasTool(t) {
+    const e = this.getTools();
+    return e == null ? !1 : e.items.some((s) => typeof s == "string" ? s === t : s.name === t);
+  }
+  removeTool(t, e = {}) {
+    const s = C(this.getTools());
+    if (s) {
+      let r = !1;
+      const i = s.items.slice(), o = (n) => {
+        i.splice(n, 1), r = !0;
+      };
+      if (typeof t == "number")
+        o(t);
+      else
+        for (let n = i.length - 1; n >= 0; n -= 1) {
+          const l = i[n];
+          (typeof l == "string" ? l === t : l.name === t) && o(n);
+        }
+      r && (s.items = i, this.setTools(s, e));
+    }
+    return this;
+  }
+  // #endregion
+  // #region common
+  // eslint-disable-next-line
+  getBBox(t) {
+    return new S();
+  }
+  // eslint-disable-next-line
+  getConnectionPoint(t, e) {
+    return new H();
+  }
+  toJSON(t = {}) {
+    const e = Object.assign({}, this.store.get()), s = Object.prototype.toString, r = this.isNode() ? "node" : this.isEdge() ? "edge" : "cell";
+    if (!e.shape) {
+      const c = this.constructor;
+      throw new Error(`Unable to serialize ${r} missing "shape" prop, check the ${r} "${c.name || s.call(c)}"`);
+    }
+    const i = this.constructor, o = t.diff === !0, n = e.attrs || {}, l = i.getDefaults(!0), u = o ? this.preprocess(l, !0) : l, p = u.attrs || {}, a = {};
+    Object.entries(e).forEach(([c, m]) => {
+      if (m != null && !Array.isArray(m) && typeof m == "object" && !Z(m))
+        throw new Error(`Can only serialize ${r} with plain-object props, but got a "${s.call(m)}" type of key "${c}" on ${r} "${this.id}"`);
+      if (c !== "attrs" && c !== "shape" && o) {
+        const y = u[c];
+        j(m, y) && delete e[c];
+      }
+    }), Object.keys(n).forEach((c) => {
+      const m = n[c], y = p[c];
+      Object.keys(m).forEach((P) => {
+        const b = m[P], O = y ? y[P] : null;
+        b != null && typeof b == "object" && !Array.isArray(b) ? Object.keys(b).forEach((v) => {
+          const x = b[v];
+          if (y == null || O == null || !_(O) || !j(O[v], x)) {
+            a[c] == null && (a[c] = {}), a[c][P] == null && (a[c][P] = {});
+            const E = a[c][P];
+            E[v] = x;
+          }
+        }) : (y == null || !j(O, b)) && (a[c] == null && (a[c] = {}), a[c][P] = b);
+      });
+    });
+    const d = Object.assign(Object.assign({}, e), { attrs: M(a) ? void 0 : a });
+    d.attrs == null && delete d.attrs;
+    const g = d;
+    return g.angle === 0 && delete g.angle, C(g);
+  }
+  clone(t = {}) {
+    if (!t.deep) {
+      const s = Object.assign({}, this.store.get());
+      t.keepId || delete s.id, delete s.parent, delete s.children;
+      const r = this.constructor;
+      return new r(s);
+    }
+    return f.deepClone(this)[this.id];
+  }
+  findView(t) {
+    return t.findViewByCell(this);
+  }
+  // #endregion
+  // #region batch
+  startBatch(t, e = {}, s = this.model) {
+    return this.notify("batch:start", { name: t, data: e, cell: this }), s && s.startBatch(t, Object.assign(Object.assign({}, e), { cell: this })), this;
+  }
+  stopBatch(t, e = {}, s = this.model) {
+    return s && s.stopBatch(t, Object.assign(Object.assign({}, e), { cell: this })), this.notify("batch:stop", { name: t, data: e, cell: this }), this;
+  }
+  batchUpdate(t, e, s) {
+    const r = this.model;
+    this.startBatch(t, s, r);
+    const i = e();
+    return this.stopBatch(t, s, r), i;
+  }
+  // #endregion
+  // #region IDisposable
+  dispose() {
+    this.removeFromParent(), this.store.dispose();
+  }
+}
+f.defaults = {};
+f.attrHooks = {};
+f.propHooks = [];
+F([
+  I.dispose()
+], f.prototype, "dispose", null);
+(function(h) {
+  function t(e) {
+    return typeof e == "string" ? { items: [e] } : Array.isArray(e) ? { items: e } : e.items ? e : {
+      items: [e]
+    };
+  }
+  h.normalizeTools = t;
+})(f || (f = {}));
+(function(h) {
+  h.toStringTag = `X6.${h.name}`;
+  function t(e) {
+    if (e == null)
+      return !1;
+    if (e instanceof h)
+      return !0;
+    const s = e[Symbol.toStringTag], r = e;
+    return (s == null || s === h.toStringTag) && typeof r.isNode == "function" && typeof r.isEdge == "function" && typeof r.prop == "function" && typeof r.attr == "function";
+  }
+  h.isCell = t;
+})(f || (f = {}));
+(function(h) {
+  function t(...i) {
+    const o = i.filter((l) => l != null).map((l) => l.getAncestors()).sort((l, u) => l.length - u.length);
+    return o.shift().find((l) => o.every((u) => u.includes(l))) || null;
+  }
+  h.getCommonAncestor = t;
+  function e(i, o = {}) {
+    let n = null;
+    for (let l = 0, u = i.length; l < u; l += 1) {
+      const p = i[l];
+      let a = p.getBBox(o);
+      if (a) {
+        if (p.isNode()) {
+          const d = p.getAngle();
+          d != null && d !== 0 && (a = a.bbox(d));
+        }
+        n = n == null ? a : n.union(a);
+      }
+    }
+    return n;
+  }
+  h.getCellsBBox = e;
+  function s(i) {
+    const o = [i, ...i.getDescendants({ deep: !0 })];
+    return h.cloneCells(o);
+  }
+  h.deepClone = s;
+  function r(i) {
+    const o = V(i), n = o.reduce((l, u) => (l[u.id] = u.clone(), l), {});
+    return o.forEach((l) => {
+      const u = n[l.id];
+      if (u.isEdge()) {
+        const d = u.getSourceCellId(), g = u.getTargetCellId();
+        d && n[d] && u.setSource(Object.assign(Object.assign({}, u.getSource()), { cell: n[d].id })), g && n[g] && u.setTarget(Object.assign(Object.assign({}, u.getTarget()), { cell: n[g].id }));
+      }
+      const p = l.getParent();
+      p && n[p.id] && u.setParent(n[p.id]);
+      const a = l.getChildren();
+      if (a && a.length) {
+        const d = a.reduce((g, c) => (n[c.id] && g.push(n[c.id]), g), []);
+        d.length > 0 && u.setChildren(d);
+      }
+    }), n;
+  }
+  h.cloneCells = r;
+})(f || (f = {}));
+(function(h) {
+  h.config({
+    propHooks(t) {
+      var { tools: e } = t, s = D(t, ["tools"]);
+      return e && (s.tools = h.normalizeTools(e)), s;
+    }
+  });
+})(f || (f = {}));
+export {
+  f as Cell
+};