@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,287 @@
+import "../../../x6-common/es/polyfill/index.js";
+import { Disposable as w } from "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { call as m } from "../../../x6-common/es/function/function.js";
+import "../../../x6-common/es/platform/index.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import "../../../x6-common/es/dom/prefix.js";
+import { css as p } from "../../../x6-common/es/dom/css.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 "../view/markup.js";
+import "../view/view.js";
+import { CellView as u } from "../view/cell.js";
+import { EdgeView as v } from "../view/edge.js";
+import { NodeView as V } from "../view/node.js";
+import "../view/tool.js";
+import { JobQueue as E, JOB_PRIORITY as a } from "./queueJob.js";
+var R = function(c, e, t, i) {
+  var s = arguments.length, o = s < 3 ? e : i === null ? i = Object.getOwnPropertyDescriptor(e, t) : i, n;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") o = Reflect.decorate(c, e, t, i);
+  else for (var r = c.length - 1; r >= 0; r--) (n = c[r]) && (o = (s < 3 ? n(o) : s > 3 ? n(e, t, o) : n(e, t)) || o);
+  return s > 3 && o && Object.defineProperty(e, t, o), o;
+};
+class l extends w {
+  get model() {
+    return this.graph.model;
+  }
+  get container() {
+    return this.graph.view.stage;
+  }
+  constructor(e) {
+    super(), this.views = {}, this.willRemoveViews = {}, this.queue = new E(), this.graph = e, this.init();
+  }
+  init() {
+    this.startListening(), this.renderViews(this.model.getCells());
+  }
+  startListening() {
+    this.model.on("reseted", this.onModelReseted, this), this.model.on("cell:added", this.onCellAdded, this), this.model.on("cell:removed", this.onCellRemoved, this), this.model.on("cell:change:zIndex", this.onCellZIndexChanged, this), this.model.on("cell:change:visible", this.onCellVisibleChanged, this);
+  }
+  stopListening() {
+    this.model.off("reseted", this.onModelReseted, this), this.model.off("cell:added", this.onCellAdded, this), this.model.off("cell:removed", this.onCellRemoved, this), this.model.off("cell:change:zIndex", this.onCellZIndexChanged, this), this.model.off("cell:change:visible", this.onCellVisibleChanged, this);
+  }
+  onModelReseted({ options: e }) {
+    this.queue.clearJobs(), this.removeZPivots(), this.resetViews();
+    const t = this.model.getCells();
+    this.renderViews(t, Object.assign(Object.assign({}, e), { queue: t.map((i) => i.id) }));
+  }
+  onCellAdded({ cell: e, options: t }) {
+    this.renderViews([e], t);
+  }
+  onCellRemoved({ cell: e }) {
+    this.removeViews([e]);
+  }
+  onCellZIndexChanged({ cell: e, options: t }) {
+    const i = this.views[e.id];
+    i && this.requestViewUpdate(i.view, l.FLAG_INSERT, t, a.Update, !0);
+  }
+  onCellVisibleChanged({ cell: e, current: t }) {
+    this.toggleVisible(e, !!t);
+  }
+  requestViewUpdate(e, t, i = {}, s = a.Update, o = !0) {
+    const n = e.cell.id, r = this.views[n];
+    if (!r)
+      return;
+    r.flag = t, r.options = i, (e.hasAction(t, ["translate", "resize", "rotate"]) || i.async === !1) && (s = a.PRIOR, o = !1), this.queue.queueJob({
+      id: n,
+      priority: s,
+      cb: () => {
+        this.renderViewInArea(e, t, i);
+        const d = i.queue;
+        if (d) {
+          const g = d.indexOf(e.cell.id);
+          g >= 0 && d.splice(g, 1), d.length === 0 && this.graph.trigger("render:done");
+        }
+      }
+    }), this.getEffectedEdges(e).forEach((d) => {
+      this.requestViewUpdate(d.view, d.flag, i, s, !1);
+    }), o && this.flush();
+  }
+  setRenderArea(e) {
+    this.renderArea = e, this.flushWaitingViews();
+  }
+  isViewMounted(e) {
+    if (e == null)
+      return !1;
+    const t = this.views[e.cell.id];
+    return t ? t.state === l.ViewState.MOUNTED : !1;
+  }
+  renderViews(e, t = {}) {
+    e.sort((i, s) => i.isNode() && s.isEdge() ? -1 : 0), e.forEach((i) => {
+      const s = i.id, o = this.views;
+      let n = 0, r = o[s];
+      if (r)
+        n = l.FLAG_INSERT;
+      else {
+        const h = this.createCellView(i);
+        h && (h.graph = this.graph, n = l.FLAG_INSERT | h.getBootstrapFlag(), r = {
+          view: h,
+          flag: n,
+          options: t,
+          state: l.ViewState.CREATED
+        }, this.views[s] = r);
+      }
+      r && this.requestViewUpdate(r.view, n, t, this.getRenderPriority(r.view), !1);
+    }), this.flush();
+  }
+  renderViewInArea(e, t, i = {}) {
+    const s = e.cell, o = s.id, n = this.views[o];
+    if (!n)
+      return;
+    let r = 0;
+    this.isUpdatable(e) ? (r = this.updateView(e, t, i), n.flag = r) : n.state === l.ViewState.MOUNTED ? (r = this.updateView(e, t, i), n.flag = r) : n.state = l.ViewState.WAITING, r && s.isEdge() && (r & e.getFlag(["source", "target"])) === 0 && this.queue.queueJob({
+      id: o,
+      priority: a.RenderEdge,
+      cb: () => {
+        this.updateView(e, t, i);
+      }
+    });
+  }
+  removeViews(e) {
+    e.forEach((t) => {
+      const i = t.id, s = this.views[i];
+      s && (this.willRemoveViews[i] = s, delete this.views[i], this.queue.queueJob({
+        id: i,
+        priority: this.getRenderPriority(s.view),
+        cb: () => {
+          this.removeView(s.view);
+        }
+      }));
+    }), this.flush();
+  }
+  flush() {
+    this.graph.options.async ? this.queue.queueFlush() : this.queue.queueFlushSync();
+  }
+  flushWaitingViews() {
+    Object.values(this.views).forEach((e) => {
+      if (e && e.state === l.ViewState.WAITING) {
+        const { view: t, flag: i, options: s } = e;
+        this.requestViewUpdate(t, i, s, this.getRenderPriority(t), !1);
+      }
+    }), this.flush();
+  }
+  updateView(e, t, i = {}) {
+    if (e == null)
+      return 0;
+    if (u.isCellView(e)) {
+      if (t & l.FLAG_REMOVE)
+        return this.removeView(e.cell), 0;
+      t & l.FLAG_INSERT && (this.insertView(e), t ^= l.FLAG_INSERT);
+    }
+    return t ? e.confirmUpdate(t, i) : 0;
+  }
+  insertView(e) {
+    const t = this.views[e.cell.id];
+    if (t) {
+      const i = e.cell.getZIndex(), s = this.addZPivot(i);
+      this.container.insertBefore(e.container, s), e.cell.isVisible() || this.toggleVisible(e.cell, !1), t.state = l.ViewState.MOUNTED, this.graph.trigger("view:mounted", { view: e });
+    }
+  }
+  resetViews() {
+    this.willRemoveViews = Object.assign(Object.assign({}, this.views), this.willRemoveViews), Object.values(this.willRemoveViews).forEach((e) => {
+      e && this.removeView(e.view);
+    }), this.views = {}, this.willRemoveViews = {};
+  }
+  removeView(e) {
+    const t = e.cell, i = this.willRemoveViews[t.id];
+    i && e && (i.view.remove(), delete this.willRemoveViews[t.id], this.graph.trigger("view:unmounted", { view: e }));
+  }
+  toggleVisible(e, t) {
+    const i = this.model.getConnectedEdges(e);
+    for (let o = 0, n = i.length; o < n; o += 1) {
+      const r = i[o];
+      if (t) {
+        const h = r.getSourceCell(), f = r.getTargetCell();
+        if (h && !h.isVisible() || f && !f.isVisible())
+          continue;
+        this.toggleVisible(r, !0);
+      } else
+        this.toggleVisible(r, !1);
+    }
+    const s = this.views[e.id];
+    s && p(s.view.container, {
+      display: t ? "unset" : "none"
+    });
+  }
+  addZPivot(e = 0) {
+    this.zPivots == null && (this.zPivots = {});
+    const t = this.zPivots;
+    let i = t[e];
+    if (i)
+      return i;
+    i = t[e] = document.createComment(`z-index:${e + 1}`);
+    let s = -1 / 0;
+    for (const n in t) {
+      const r = +n;
+      r < e && r > s && (s = r, e - 1);
+    }
+    const o = this.container;
+    if (s !== -1 / 0) {
+      const n = t[s];
+      o.insertBefore(i, n.nextSibling);
+    } else
+      o.insertBefore(i, o.firstChild);
+    return i;
+  }
+  removeZPivots() {
+    this.zPivots && Object.values(this.zPivots).forEach((e) => {
+      e && e.parentNode && e.parentNode.removeChild(e);
+    }), this.zPivots = {};
+  }
+  createCellView(e) {
+    const t = { graph: this.graph }, i = this.graph.options.createCellView;
+    if (i) {
+      const o = m(i, this.graph, e);
+      if (o)
+        return new o(e, t);
+      if (o === null)
+        return null;
+    }
+    const s = e.view;
+    if (s != null && typeof s == "string") {
+      const o = u.registry.get(s);
+      return o ? new o(e, t) : u.registry.onNotFound(s);
+    }
+    return e.isNode() ? new V(e, t) : e.isEdge() ? new v(e, t) : null;
+  }
+  getEffectedEdges(e) {
+    const t = [], i = e.cell, s = this.model.getConnectedEdges(i);
+    for (let o = 0, n = s.length; o < n; o += 1) {
+      const r = s[o], h = this.views[r.id];
+      if (!h)
+        continue;
+      const f = h.view;
+      if (!this.isViewMounted(f))
+        continue;
+      const d = ["update"];
+      r.getTargetCell() === i && d.push("target"), r.getSourceCell() === i && d.push("source"), t.push({
+        id: r.id,
+        view: f,
+        flag: f.getFlag(d)
+      });
+    }
+    return t;
+  }
+  isUpdatable(e) {
+    if (e.isNodeView())
+      return this.renderArea ? this.renderArea.isIntersectWithRect(e.cell.getBBox()) : !0;
+    if (e.isEdgeView()) {
+      const t = e.cell, i = t.getSourceCell(), s = t.getTargetCell();
+      if (this.renderArea && i && s)
+        return this.renderArea.isIntersectWithRect(i.getBBox()) || this.renderArea.isIntersectWithRect(s.getBBox());
+    }
+    return !0;
+  }
+  getRenderPriority(e) {
+    return e.cell.isNode() ? a.RenderNode : a.RenderEdge;
+  }
+  dispose() {
+    this.stopListening(), Object.keys(this.views).forEach((e) => {
+      this.views[e].view.dispose();
+    }), this.views = {};
+  }
+}
+R([
+  w.dispose()
+], l.prototype, "dispose", null);
+(function(c) {
+  c.FLAG_INSERT = 1 << 30, c.FLAG_REMOVE = 1 << 29, c.FLAG_RENDER = (1 << 26) - 1;
+})(l || (l = {}));
+(function(c) {
+  (function(e) {
+    e[e.CREATED = 0] = "CREATED", e[e.MOUNTED = 1] = "MOUNTED", e[e.WAITING = 2] = "WAITING";
+  })(c.ViewState || (c.ViewState = {}));
+})(l || (l = {}));
+export {
+  l as Scheduler
+};

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

@@ -0,0 +1,74 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { setByPath as n } from "../../../x6-common/es/object/object.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 "../model/cell.js";
+import { Node as p } from "../model/node.js";
+import "../model/edge.js";
+import "../model/model.js";
+import "../model/collection.js";
+var m = function(t, r) {
+  var o = {};
+  for (var e in t) Object.prototype.hasOwnProperty.call(t, e) && r.indexOf(e) < 0 && (o[e] = t[e]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, e = Object.getOwnPropertySymbols(t); i < e.length; i++)
+      r.indexOf(e[i]) < 0 && Object.prototype.propertyIsEnumerable.call(t, e[i]) && (o[e[i]] = t[e[i]]);
+  return o;
+};
+class l extends p {
+  get label() {
+    return this.getLabel();
+  }
+  set label(r) {
+    this.setLabel(r);
+  }
+  getLabel() {
+    return this.getAttrByPath("text/text");
+  }
+  setLabel(r, o) {
+    return r == null ? this.removeLabel() : this.setAttrByPath("text/text", r, o), this;
+  }
+  removeLabel() {
+    return this.removeAttrByPath("text/text"), this;
+  }
+}
+(function(t) {
+  t.bodyAttr = {
+    fill: "#ffffff",
+    stroke: "#333333",
+    strokeWidth: 2
+  }, t.labelAttr = {
+    fontSize: 14,
+    fill: "#000000",
+    refX: 0.5,
+    refY: 0.5,
+    textAnchor: "middle",
+    textVerticalAnchor: "middle",
+    fontFamily: "Arial, helvetica, sans-serif"
+  }, t.config({
+    attrs: { text: Object.assign({}, t.labelAttr) },
+    propHooks(r) {
+      const { label: o } = r, e = m(r, ["label"]);
+      return o && n(e, "attrs/text/text", o), e;
+    },
+    visible: !0
+  });
+})(l || (l = {}));
+export {
+  l as Base
+};

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

@@ -0,0 +1,10 @@
+import { createShape as r } from "./util.js";
+r("circle", {
+  attrs: {
+    body: {
+      refCx: "50%",
+      refCy: "50%",
+      refR: "50%"
+    }
+  }
+});

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

@@ -0,0 +1,43 @@
+import { Edge as e } from "../model/edge.js";
+const r = e.define({
+  shape: "edge",
+  markup: [
+    {
+      tagName: "path",
+      selector: "wrap",
+      groupSelector: "lines",
+      attrs: {
+        fill: "none",
+        cursor: "pointer",
+        stroke: "transparent",
+        strokeLinecap: "round"
+      }
+    },
+    {
+      tagName: "path",
+      selector: "line",
+      groupSelector: "lines",
+      attrs: {
+        fill: "none",
+        pointerEvents: "none"
+      }
+    }
+  ],
+  attrs: {
+    lines: {
+      connection: !0,
+      strokeLinejoin: "round"
+    },
+    wrap: {
+      strokeWidth: 10
+    },
+    line: {
+      stroke: "#333",
+      strokeWidth: 2,
+      targetMarker: "classic"
+    }
+  }
+});
+export {
+  r as Edge
+};

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

@@ -0,0 +1,11 @@
+import { createShape as e } from "./util.js";
+e("ellipse", {
+  attrs: {
+    body: {
+      refCx: "50%",
+      refCy: "50%",
+      refRx: "50%",
+      refRy: "50%"
+    }
+  }
+});

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

@@ -0,0 +1,128 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import "../../../x6-common/es/platform/index.js";
+import { empty as m, append as h } from "../../../x6-common/es/dom/elem.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 { Markup as a } from "../view/markup.js";
+import "../view/view.js";
+import "../view/cell.js";
+import "../view/edge.js";
+import { NodeView as c } from "../view/node.js";
+import "../view/tool.js";
+import { Node as l } from "../model/node.js";
+import { Graph as u } from "../graph/graph.js";
+var d = function(e, n, i, t) {
+  var r = arguments.length, o = r < 3 ? n : t === null ? t = Object.getOwnPropertyDescriptor(n, i) : t, p;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") o = Reflect.decorate(e, n, i, t);
+  else for (var f = e.length - 1; f >= 0; f--) (p = e[f]) && (o = (r < 3 ? p(o) : r > 3 ? p(n, i, o) : p(n, i)) || o);
+  return r > 3 && o && Object.defineProperty(n, i, o), o;
+}, g = function(e, n) {
+  var i = {};
+  for (var t in e) Object.prototype.hasOwnProperty.call(e, t) && n.indexOf(t) < 0 && (i[t] = e[t]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var r = 0, t = Object.getOwnPropertySymbols(e); r < t.length; r++)
+      n.indexOf(t[r]) < 0 && Object.prototype.propertyIsEnumerable.call(e, t[r]) && (i[t[r]] = e[t[r]]);
+  return i;
+};
+class s extends l {
+}
+(function(e) {
+  class n extends c {
+    init() {
+      super.init(), this.cell.on("change:*", this.onCellChangeAny, this);
+    }
+    onCellChangeAny({ key: t }) {
+      const r = e.shapeMaps[this.cell.shape];
+      if (r) {
+        const { effect: o } = r;
+        (!o || o.includes(t)) && this.renderHTMLComponent();
+      }
+    }
+    confirmUpdate(t) {
+      const r = super.confirmUpdate(t);
+      return this.handleAction(r, n.action, () => this.renderHTMLComponent());
+    }
+    renderHTMLComponent() {
+      const t = this.selectors && this.selectors.foContent;
+      if (t) {
+        m(t);
+        const r = e.shapeMaps[this.cell.shape];
+        if (!r)
+          return;
+        let { html: o } = r;
+        typeof o == "function" && (o = o(this.cell)), o && (typeof o == "string" ? t.innerHTML = o : h(t, o));
+      }
+    }
+    dispose() {
+      this.cell.off("change:*", this.onCellChangeAny, this);
+    }
+  }
+  d([
+    n.dispose()
+  ], n.prototype, "dispose", null), e.View = n, (function(i) {
+    i.action = "html", i.config({
+      bootstrap: [i.action],
+      actions: {
+        html: i.action
+      }
+    }), c.registry.register("html-view", i, !0);
+  })(n = e.View || (e.View = {}));
+})(s || (s = {}));
+(function(e) {
+  e.config({
+    view: "html-view",
+    markup: [
+      {
+        tagName: "rect",
+        selector: "body"
+      },
+      Object.assign({}, a.getForeignObjectMarkup()),
+      {
+        tagName: "text",
+        selector: "label"
+      }
+    ],
+    attrs: {
+      body: {
+        fill: "none",
+        stroke: "none",
+        refWidth: "100%",
+        refHeight: "100%"
+      },
+      fo: {
+        refWidth: "100%",
+        refHeight: "100%"
+      }
+    }
+  }), l.registry.register("html", e, !0);
+})(s || (s = {}));
+(function(e) {
+  e.shapeMaps = {};
+  function n(i) {
+    const { shape: t, html: r, effect: o, inherit: p } = i, f = g(i, ["shape", "html", "effect", "inherit"]);
+    if (!t)
+      throw new Error("should specify shape in config");
+    e.shapeMaps[t] = {
+      html: r,
+      effect: o
+    }, u.registerNode(t, Object.assign({ inherit: p || "html" }, f), !0);
+  }
+  e.register = n;
+})(s || (s = {}));
+export {
+  s as HTML
+};

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

@@ -0,0 +1,12 @@
+import { createShape as e, getImageUrlHook as r } from "./util.js";
+e("image", {
+  attrs: {
+    image: {
+      refWidth: "100%",
+      refHeight: "100%"
+    }
+  },
+  propHooks: r()
+}, {
+  selector: "image"
+});

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

@@ -0,0 +1,63 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { setByPath as i } from "../../../x6-common/es/object/object.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 { Base as n } from "./base.js";
+var m = function(t, p) {
+  var o = {};
+  for (var r in t) Object.prototype.hasOwnProperty.call(t, r) && p.indexOf(r) < 0 && (o[r] = t[r]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var e = 0, r = Object.getOwnPropertySymbols(t); e < r.length; e++)
+      p.indexOf(r[e]) < 0 && Object.prototype.propertyIsEnumerable.call(t, r[e]) && (o[r[e]] = t[r[e]]);
+  return o;
+};
+n.define({
+  shape: "path",
+  markup: [
+    {
+      tagName: "rect",
+      selector: "bg"
+    },
+    {
+      tagName: "path",
+      selector: "body"
+    },
+    {
+      tagName: "text",
+      selector: "label"
+    }
+  ],
+  attrs: {
+    bg: {
+      refWidth: "100%",
+      refHeight: "100%",
+      fill: "none",
+      stroke: "none",
+      pointerEvents: "all"
+    },
+    body: {
+      fill: "none",
+      stroke: "#000",
+      strokeWidth: 2
+    }
+  },
+  propHooks(t) {
+    const { path: p } = t, o = m(t, ["path"]);
+    return p && i(o, "attrs/body/refD", p), o;
+  }
+});