@hkyhy/marsun-components-core 0.1.133 → 0.1.135

package/dist/node_modules/@antv/g6/esm/runtime/element.js

@@ -1,582 +0,0 @@
-import "../../../g/dist/index.esm.js";
-import "../constants/change.js";
-import { AnimationType as E } from "../constants/events/animation.js";
-import "../constants/events/canvas.js";
-import "../constants/events/combo.js";
-import "../constants/events/common.js";
-import "../constants/events/container.js";
-import "../constants/events/edge.js";
-import { GraphEvent as p } from "../constants/events/graph.js";
-import "../constants/events/history.js";
-import "../constants/events/node.js";
-import { COMBO_KEY as I } from "../constants/graphlib.js";
-import "../constants/registry.js";
-import { ELEMENT_TYPES as U } from "../constants/element.js";
-import { getExtension as W } from "../registry/get.js";
-import { hasCachedStyle as z, cacheStyle as X } from "../utils/cache.js";
-import { reduceDataChanges as Y } from "../utils/change.js";
-import { isCollapsed as G } from "../utils/collapsibility.js";
-import { isOverridable as x } from "../utils/data.js";
-import { updateStyle as M, markToBeDestroyed as $ } from "../utils/element.js";
-import { emit as K } from "../utils/event/index.js";
-import { idOf as u } from "../utils/id.js";
-import { parsePalette as N, assignColorByPalette as V } from "../utils/palette.js";
-import { positionOf as _ } from "../utils/position.js";
-import { print as q } from "../utils/print.js";
-import { computeElementCallbackStyle as L } from "../utils/style.js";
-import { themeOf as H } from "../utils/theme.js";
-import { subtract as J } from "../utils/vector.js";
-import { setVisibility as F } from "../utils/visibility.js";
-import { Group as Q } from "../../../g-lite/dist/index.esm.js";
-import { GraphLifeCycleEvent as S, AnimateEvent as y, ElementLifeCycleEvent as A } from "../utils/event/events.js";
-import Z from "../../../util/esm/lodash/group-by.js";
-var D = function(T, t, e, s) {
-  function a(n) {
-    return n instanceof e ? n : new e(function(i) {
-      i(n);
-    });
-  }
-  return new (e || (e = Promise))(function(n, i) {
-    function o(d) {
-      try {
-        l(s.next(d));
-      } catch (c) {
-        i(c);
-      }
-    }
-    function r(d) {
-      try {
-        l(s.throw(d));
-      } catch (c) {
-        i(c);
-      }
-    }
-    function l(d) {
-      d.done ? n(d.value) : a(d.value).then(o, r);
-    }
-    l((s = s.apply(T, t || [])).next());
-  });
-};
-class Nt {
-  constructor(t) {
-    this.elementMap = {}, this.shapeTypeMap = {}, this.paletteStyle = {}, this.defaultStyle = {}, this.stateStyle = {}, this.visibilityCache = /* @__PURE__ */ new WeakMap(), this.context = t;
-  }
-  init() {
-    this.initContainer();
-  }
-  initContainer() {
-    if (!this.container || this.container.destroyed) {
-      const { canvas: t } = this.context;
-      this.container = t.appendChild(new Q({ className: "elements" }));
-    }
-  }
-  emit(t, e) {
-    e.silence || K(this.context.graph, t);
-  }
-  forEachElementData(t) {
-    U.forEach((e) => {
-      const s = this.context.model.getElementsDataByType(e);
-      t(e, s);
-    });
-  }
-  getElementType(t, e) {
-    var s;
-    const { options: a, graph: n } = this.context, i = x(e) && ((s = a[t]) === null || s === void 0 ? void 0 : s.type) || e.type;
-    return i ? typeof i == "string" ? i : i.call(n, e) : t === "edge" ? "line" : "circle";
-  }
-  getTheme(t) {
-    return H(this.context.options)[t] || {};
-  }
-  getThemeStyle(t) {
-    return this.getTheme(t).style || {};
-  }
-  getThemeStateStyle(t, e) {
-    const { state: s = {} } = this.getTheme(t);
-    return Object.assign({}, ...e.map((a) => s[a] || {}));
-  }
-  computePaletteStyle() {
-    const { options: t } = this.context;
-    this.paletteStyle = {}, this.forEachElementData((e, s) => {
-      var a, n;
-      const i = Object.assign({}, N((a = this.getTheme(e)) === null || a === void 0 ? void 0 : a.palette), N((n = t[e]) === null || n === void 0 ? void 0 : n.palette));
-      i != null && i.field && Object.assign(this.paletteStyle, V(s, i));
-    });
-  }
-  getPaletteStyle(t, e) {
-    const s = this.paletteStyle[e];
-    return s ? t === "edge" ? { stroke: s } : { fill: s } : {};
-  }
-  /**
-   * <zh/> 计算单个元素的默认样式
-   *
-   * <en/> compute default style of single element
-   */
-  computeElementDefaultStyle(t, e) {
-    var s;
-    const { options: a } = this.context, n = ((s = a[t]) === null || s === void 0 ? void 0 : s.style) || {};
-    "transform" in n && Array.isArray(n.transform) && (n.transform = [...n.transform]), this.defaultStyle[u(e.datum)] = L(n, e);
-  }
-  computeElementsDefaultStyle(t) {
-    const { graph: e } = this.context;
-    this.forEachElementData((s, a) => {
-      const n = a.length;
-      for (let i = 0; i < n; i++) {
-        const o = a[i];
-        (t === void 0 || t.includes(u(o))) && this.computeElementDefaultStyle(s, { datum: o, graph: e });
-      }
-    });
-  }
-  getDefaultStyle(t) {
-    return this.defaultStyle[t] || {};
-  }
-  getElementState(t) {
-    try {
-      const { model: e } = this.context;
-      return e.getElementState(t);
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * <zh/> 获取单个元素的单个状态的样式
-   *
-   * <en/> get single state style of single element
-   */
-  getElementStateStyle(t, e, s) {
-    var a, n;
-    const { options: i } = this.context, o = ((n = (a = i[t]) === null || a === void 0 ? void 0 : a.state) === null || n === void 0 ? void 0 : n[e]) || {};
-    return L(o, s);
-  }
-  /**
-   * <zh/> 计算单个元素的合并状态样式
-   *
-   * <en/> compute merged state style of single element
-   */
-  computeElementStatesStyle(t, e, s) {
-    this.stateStyle[u(s.datum)] = Object.assign({}, ...e.map((a) => this.getElementStateStyle(t, a, s)));
-  }
-  /**
-   * <zh/> 计算全部元素的状态样式
-   *
-   * <en/> compute state style of all elements
-   * @param ids - <zh/> 计算指定元素的状态样式 | <en/> compute state style of specified elements
-   */
-  computeElementsStatesStyle(t) {
-    const { graph: e } = this.context;
-    this.forEachElementData((s, a) => {
-      const n = a.length;
-      for (let i = 0; i < n; i++) {
-        const o = a[i];
-        if (t === void 0 || t.includes(u(o))) {
-          const r = this.getElementState(u(o));
-          this.computeElementStatesStyle(s, r, { datum: o, graph: e });
-        }
-      }
-    });
-  }
-  getStateStyle(t) {
-    return this.stateStyle[t] || {};
-  }
-  computeStyle(t, e) {
-    t && ["translate", "zIndex"].includes(t) || (this.computePaletteStyle(), this.computeElementsDefaultStyle(e), this.computeElementsStatesStyle(e));
-  }
-  getElement(t) {
-    return this.elementMap[t];
-  }
-  getNodes() {
-    return this.context.model.getNodeData().map(({ id: t }) => this.elementMap[t]);
-  }
-  getEdges() {
-    return this.context.model.getEdgeData().map((t) => this.elementMap[u(t)]);
-  }
-  getCombos() {
-    return this.context.model.getComboData().map(({ id: t }) => this.elementMap[t]);
-  }
-  getElementComputedStyle(t, e) {
-    const s = u(e), a = this.getThemeStyle(t), n = this.getPaletteStyle(t, s), i = e.style || {}, o = this.getDefaultStyle(s), r = this.getThemeStateStyle(t, this.getElementState(s)), l = this.getStateStyle(s), d = x(e) ? Object.assign({}, a, n, i, o, r, l) : Object.assign({}, i);
-    if (t === "combo") {
-      const c = this.context.model.getChildrenData(s), h = !!d.collapsed ? [] : c.map(u).filter((f) => this.getElement(f));
-      Object.assign(d, { childrenNode: h, childrenData: c });
-    }
-    return d;
-  }
-  getDrawData(t) {
-    this.init();
-    const e = this.computeChangesAndDrawData(t);
-    if (!e)
-      return null;
-    const { type: s = "draw", stage: a = s } = t;
-    return this.markDestroyElement(e.drawData), this.computeStyle(a), { type: s, stage: a, data: e };
-  }
-  /**
-   * <zh/> 开始绘制流程
-   *
-   * <en/> start render process
-   */
-  draw(t = { animation: !0 }) {
-    const e = this.getDrawData(t);
-    if (!e)
-      return;
-    const { data: { drawData: { add: s, update: a, remove: n } } } = e;
-    return this.destroyElements(n, t), this.createElements(s, t), this.updateElements(a, t), this.setAnimationTask(t, e);
-  }
-  preLayoutDraw() {
-    return D(this, arguments, void 0, function* (t = { animation: !0 }) {
-      var e, s;
-      const a = this.getDrawData(t);
-      if (!a)
-        return;
-      const { data: { drawData: n } } = a;
-      yield (s = (e = this.context.layout) === null || e === void 0 ? void 0 : e.preLayout) === null || s === void 0 ? void 0 : s.call(e, n);
-      const { add: i, update: o, remove: r } = n;
-      return this.destroyElements(r, t), this.createElements(i, t), this.updateElements(o, t), this.setAnimationTask(t, a);
-    });
-  }
-  setAnimationTask(t, e) {
-    const { animation: s, silence: a } = t, { data: { dataChanges: n, drawData: i }, stage: o, type: r } = e;
-    return this.context.animation.animate(s, a ? {} : {
-      before: () => this.emit(new S(p.BEFORE_DRAW, {
-        dataChanges: n,
-        animation: s,
-        stage: o,
-        render: r === "render"
-      }), t),
-      beforeAnimate: (l) => this.emit(new y(p.BEFORE_ANIMATE, E.DRAW, l, i), t),
-      afterAnimate: (l) => this.emit(new y(p.AFTER_ANIMATE, E.DRAW, l, i), t),
-      after: () => this.emit(new S(p.AFTER_DRAW, {
-        dataChanges: n,
-        animation: s,
-        stage: o,
-        render: r === "render",
-        firstRender: this.context.graph.rendered === !1
-      }), t)
-    });
-  }
-  computeChangesAndDrawData(t) {
-    const { model: e } = this.context, s = e.getChanges(), a = Y(s);
-    if (a.length === 0)
-      return null;
-    const { NodeAdded: n = [], NodeUpdated: i = [], NodeRemoved: o = [], EdgeAdded: r = [], EdgeUpdated: l = [], EdgeRemoved: d = [], ComboAdded: c = [], ComboUpdated: m = [], ComboRemoved: h = [] } = Z(a, (b) => b.type), f = (b, O) => {
-      const w = [];
-      return b.forEach((R) => {
-        const B = u(R.value);
-        this.getElement(B) ? w.push(R) : O.push(R);
-      }), w;
-    }, g = f(i, n), C = f(l, r), P = f(m, c), v = (b) => new Map(b.map((O) => {
-      const w = O.value;
-      return [u(w), w];
-    })), j = {
-      add: {
-        nodes: v(n),
-        edges: v(r),
-        combos: v(c)
-      },
-      update: {
-        nodes: v(g),
-        edges: v(C),
-        combos: v(P)
-      },
-      remove: {
-        nodes: v(o),
-        edges: v(d),
-        combos: v(h)
-      }
-    }, k = this.transformData(j, t);
-    return e.clearChanges(), { dataChanges: s, drawData: k };
-  }
-  transformData(t, e) {
-    const s = this.context.transform.getTransformInstance();
-    return Object.values(s).reduce((a, n) => n.beforeDraw(a, e), t);
-  }
-  createElement(t, e, s) {
-    var a;
-    const n = u(e);
-    if (this.getElement(n))
-      return;
-    const o = this.getElementType(t, e), r = this.getElementComputedStyle(t, e), l = W(t, o);
-    if (!l)
-      return q.warn(`The element ${o} of ${t} is not registered.`);
-    this.emit(new A(p.BEFORE_ELEMENT_CREATE, t, e), s);
-    const d = this.container.appendChild(new l({
-      id: n,
-      context: this.context,
-      style: r
-    }));
-    this.shapeTypeMap[n] = o, this.elementMap[n] = d;
-    const { stage: c = "enter" } = s;
-    (a = this.context.animation) === null || a === void 0 || a.add({
-      element: d,
-      elementType: t,
-      stage: c,
-      originalStyle: Object.assign({}, d.attributes),
-      updatedStyle: r
-    }, {
-      after: () => {
-        var m;
-        this.emit(new A(p.AFTER_ELEMENT_CREATE, t, e), s), (m = d.onCreate) === null || m === void 0 || m.call(d);
-      }
-    });
-  }
-  createElements(t, e) {
-    const { nodes: s, edges: a, combos: n } = t;
-    [
-      ["node", s],
-      ["combo", n],
-      ["edge", a]
-    ].forEach(([o, r]) => {
-      r.forEach((l) => this.createElement(o, l, e));
-    });
-  }
-  getUpdateStageStyle(t, e, s) {
-    const { stage: a = "update" } = s;
-    if (a === "translate")
-      if (t === "node" || t === "combo") {
-        const { style: { x: n = 0, y: i = 0, z: o = 0 } = {} } = e;
-        return { x: n, y: i, z: o };
-      } else
-        return {};
-    return this.getElementComputedStyle(t, e);
-  }
-  updateElement(t, e, s) {
-    var a;
-    const n = u(e), { stage: i = "update" } = s, o = this.getElement(n);
-    if (!o)
-      return () => null;
-    this.emit(new A(p.BEFORE_ELEMENT_UPDATE, t, e), s);
-    const r = this.getElementType(t, e), l = this.getUpdateStageStyle(t, e, s);
-    this.shapeTypeMap[n] !== r && (o.destroy(), delete this.shapeTypeMap[n], delete this.elementMap[n], this.createElement(t, e, { animation: !1, silence: !0 }));
-    const d = i !== "visibility" ? i : l.visibility === "hidden" ? "hide" : "show";
-    d === "hide" && delete l.visibility, (a = this.context.animation) === null || a === void 0 || a.add({
-      element: o,
-      elementType: t,
-      stage: d,
-      originalStyle: Object.assign({}, o.attributes),
-      updatedStyle: l
-    }, {
-      before: () => {
-        const c = this.elementMap[n];
-        i !== "collapse" && M(c, l), i === "visibility" && (z(c, "opacity") || X(c, "opacity"), this.visibilityCache.set(c, d === "show" ? "visible" : "hidden"), d === "show" && F(c, "visible"));
-      },
-      after: () => {
-        var c;
-        const m = this.elementMap[n];
-        i === "collapse" && M(m, l), d === "hide" && F(m, this.visibilityCache.get(m)), this.emit(new A(p.AFTER_ELEMENT_UPDATE, t, e), s), (c = m.onUpdate) === null || c === void 0 || c.call(m);
-      }
-    });
-  }
-  updateElements(t, e) {
-    const { nodes: s, edges: a, combos: n } = t;
-    [
-      ["node", s],
-      ["combo", n],
-      ["edge", a]
-    ].forEach(([o, r]) => {
-      r.forEach((l) => this.updateElement(o, l, e));
-    });
-  }
-  /**
-   * <zh/> 标记销毁元素
-   *
-   * <en/> mark destroy element
-   * @param data - <zh/> 绘制数据 | <en/> draw data
-   */
-  markDestroyElement(t) {
-    Object.values(t.remove).forEach((e) => {
-      e.forEach((s) => {
-        const a = u(s), n = this.getElement(a);
-        n && $(n);
-      });
-    });
-  }
-  destroyElement(t, e, s) {
-    var a;
-    const { stage: n = "exit" } = s, i = u(e), o = this.elementMap[i];
-    if (!o)
-      return () => null;
-    this.emit(new A(p.BEFORE_ELEMENT_DESTROY, t, e), s), (a = this.context.animation) === null || a === void 0 || a.add({
-      element: o,
-      elementType: t,
-      stage: n,
-      originalStyle: Object.assign({}, o.attributes),
-      updatedStyle: {}
-    }, {
-      after: () => {
-        var r;
-        this.clearElement(i), o.destroy(), (r = o.onDestroy) === null || r === void 0 || r.call(o), this.emit(new A(p.AFTER_ELEMENT_DESTROY, t, e), s);
-      }
-    });
-  }
-  destroyElements(t, e) {
-    const { nodes: s, edges: a, combos: n } = t;
-    [
-      ["combo", n],
-      ["edge", a],
-      ["node", s]
-    ].forEach(([o, r]) => {
-      r.forEach((l) => this.destroyElement(o, l, e));
-    });
-  }
-  clearElement(t) {
-    delete this.paletteStyle[t], delete this.defaultStyle[t], delete this.stateStyle[t], delete this.elementMap[t], delete this.shapeTypeMap[t];
-  }
-  /**
-   * <zh/> 将布局结果对齐到元素，避免视图偏移。会修改布局结果
-   *
-   * <en/> Align the layout result to the element to avoid view offset. Will modify the layout result
-   * @param layoutResult - <zh/> 布局结果 | <en/> layout result
-   * @param id - <zh/> 元素 ID | <en/> element ID
-   */
-  alignLayoutResultToElement(t, e) {
-    var s, a;
-    const n = (s = t.nodes) === null || s === void 0 ? void 0 : s.find((i) => u(i) === e);
-    if (n) {
-      const i = _(this.context.model.getNodeLikeDatum(e)), o = _(n), r = J(i, o);
-      (a = t.nodes) === null || a === void 0 || a.forEach((l) => {
-        var d, c, m;
-        !((d = l.style) === null || d === void 0) && d.x && (l.style.x += r[0]), !((c = l.style) === null || c === void 0) && c.y && (l.style.y += r[1]), !((m = l.style) === null || m === void 0) && m.z && (l.style.z += r[2] || 0);
-      });
-    }
-  }
-  /**
-   * <zh/> 同步布局结果
-   *
-   * <en/> Sync layout result
-   * @param id - <zh/> 元素 ID | <en/> element ID
-   * @param align - <zh/> 是否对齐 | <en/> whether to align
-   */
-  syncLayoutResult(t, e) {
-    return D(this, void 0, void 0, function* () {
-      const { layout: s, model: a } = this.context;
-      if (!s)
-        return;
-      const n = this.context.options.layout, i = (r) => Array.isArray(r) ? r.map((l) => Object.assign(Object.assign({}, l), { preLayout: !0 })) : Object.assign(Object.assign({}, r), { preLayout: !0 }), o = yield s.simulate(n ? i(n) : void 0);
-      e && this.alignLayoutResultToElement(o, t), a.updateData(o);
-    });
-  }
-  /**
-   * <zh/> 收起节点
-   *
-   * <en/> collapse node
-   * @param id - <zh/> 元素 ID | <en/> element ID
-   * @param options - <zh/> 选项 | <en/> options
-   */
-  collapseNode(t, e) {
-    return D(this, void 0, void 0, function* () {
-      var s;
-      const { animation: a, align: n } = e;
-      yield this.syncLayoutResult(t, n);
-      const i = this.computeChangesAndDrawData({ stage: "collapse", animation: a });
-      if (this.context.animation.clear(), this.computeStyle("collapse"), !i)
-        return;
-      const { drawData: o } = i, { add: r, remove: l, update: d } = o;
-      this.markDestroyElement(o);
-      const c = { animation: a, stage: "collapse", data: o };
-      this.destroyElements(l, c), this.createElements(r, c), this.updateElements(d, c), yield (s = this.context.animation.animate(a, {
-        beforeAnimate: (m) => this.emit(new y(p.BEFORE_ANIMATE, E.COLLAPSE, m, o), c),
-        afterAnimate: (m) => this.emit(new y(p.AFTER_ANIMATE, E.COLLAPSE, m, o), c)
-      }, {
-        collapse: {
-          target: t,
-          descendants: Array.from(l.nodes).map(([, m]) => u(m)),
-          position: _(d.nodes.get(t))
-        }
-      })) === null || s === void 0 ? void 0 : s.finished;
-    });
-  }
-  /**
-   * <zh/> 展开节点
-   *
-   * <en/> expand node
-   * @param id - <zh/> 元素 ID | <en/> element ID
-   * @param animation - <zh/> 是否使用动画，默认为 true | <en/> Whether to use animation, default is true
-   */
-  expandNode(t, e) {
-    return D(this, void 0, void 0, function* () {
-      var s;
-      const { model: a } = this.context, { animation: n, align: i } = e, o = _(a.getNodeData([t])[0]);
-      yield this.syncLayoutResult(t, i);
-      const r = this.computeChangesAndDrawData({ stage: "expand", animation: n });
-      if (this.createElements(r.drawData.add, { animation: !1, stage: "expand", target: t }), this.context.animation.clear(), this.computeStyle("expand"), !r)
-        return;
-      const { drawData: l } = r, { update: d, add: c } = l, m = { animation: n, stage: "expand", data: l };
-      c.edges.forEach((h) => d.edges.set(u(h), h)), c.nodes.forEach((h) => d.nodes.set(u(h), h)), this.updateElements(d, m), yield (s = this.context.animation.animate(n, {
-        beforeAnimate: (h) => this.emit(new y(p.BEFORE_ANIMATE, E.EXPAND, h, l), m),
-        afterAnimate: (h) => this.emit(new y(p.AFTER_ANIMATE, E.EXPAND, h, l), m)
-      }, {
-        expand: {
-          target: t,
-          descendants: Array.from(c.nodes).map(([, h]) => u(h)),
-          position: o
-        }
-      })) === null || s === void 0 ? void 0 : s.finished;
-    });
-  }
-  collapseCombo(t, e) {
-    return D(this, void 0, void 0, function* () {
-      var s;
-      const { model: a, element: n } = this.context;
-      if (a.getAncestorsData(t, I).some((g) => G(g)))
-        return;
-      const i = n.getElement(t), o = i.getComboPosition(Object.assign(Object.assign({}, i.attributes), { collapsed: !0 })), r = this.computeChangesAndDrawData({ stage: "collapse", animation: e });
-      if (!r)
-        return;
-      const { dataChanges: l, drawData: d } = r;
-      this.markDestroyElement(d);
-      const { update: c, remove: m } = d, h = { animation: e, stage: "collapse", data: d };
-      this.destroyElements(m, h), this.updateElements(c, h);
-      const f = (g) => Array.from(g).map(([, C]) => u(C));
-      yield (s = this.context.animation.animate(e, {
-        before: () => this.emit(new S(p.BEFORE_DRAW, { dataChanges: l, animation: e }), h),
-        beforeAnimate: (g) => this.emit(new y(p.BEFORE_ANIMATE, E.COLLAPSE, g, d), h),
-        afterAnimate: (g) => this.emit(new y(p.AFTER_ANIMATE, E.COLLAPSE, g, d), h),
-        after: () => this.emit(new S(p.AFTER_DRAW, { dataChanges: l, animation: e }), h)
-      }, {
-        collapse: {
-          target: t,
-          descendants: [...f(m.nodes), ...f(m.combos)],
-          position: o
-        }
-      })) === null || s === void 0 ? void 0 : s.finished;
-    });
-  }
-  expandCombo(t, e) {
-    return D(this, void 0, void 0, function* () {
-      var s;
-      const { model: a } = this.context, n = _(a.getComboData([t])[0]);
-      this.computeStyle("expand");
-      const i = this.computeChangesAndDrawData({ stage: "expand", animation: e });
-      if (!i)
-        return;
-      const { dataChanges: o, drawData: r } = i, { add: l, update: d } = r, c = { animation: e, stage: "expand", data: r, target: t };
-      this.createElements(l, c), this.updateElements(d, c);
-      const m = (h) => Array.from(h).map(([, f]) => u(f));
-      yield (s = this.context.animation.animate(e, {
-        before: () => this.emit(new S(p.BEFORE_DRAW, { dataChanges: o, animation: e }), c),
-        beforeAnimate: (h) => this.emit(new y(p.BEFORE_ANIMATE, E.EXPAND, h, r), c),
-        afterAnimate: (h) => this.emit(new y(p.AFTER_ANIMATE, E.EXPAND, h, r), c),
-        after: () => this.emit(new S(p.AFTER_DRAW, { dataChanges: o, animation: e }), c)
-      }, {
-        expand: {
-          target: t,
-          descendants: [...m(l.nodes), ...m(l.combos)],
-          position: n
-        }
-      })) === null || s === void 0 ? void 0 : s.finished;
-    });
-  }
-  /**
-   * <zh/> 清空所有元素
-   *
-   * <en/> clear all elements
-   */
-  clear() {
-    this.container.destroy(), this.initContainer(), this.elementMap = {}, this.shapeTypeMap = {}, this.defaultStyle = {}, this.stateStyle = {}, this.paletteStyle = {};
-  }
-  destroy() {
-    this.clear(), this.container.destroy(), this.context = {};
-  }
-}
-export {
-  Nt as ElementController
-};
-//# sourceMappingURL=element.js.map