@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,163 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import { Basecoat as m } from "../../../x6-common/es/common/basecoat.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 y from "../../../../lodash-es/sortBy.js";
+var v = function(d, t, e, s) {
+  var r = arguments.length, i = r < 3 ? t : s === null ? s = Object.getOwnPropertyDescriptor(t, e) : s, n;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") i = Reflect.decorate(d, t, e, s);
+  else for (var o = d.length - 1; o >= 0; o--) (n = d[o]) && (i = (r < 3 ? n(i) : r > 3 ? n(t, e, i) : n(t, e)) || i);
+  return r > 3 && i && Object.defineProperty(t, e, i), i;
+};
+class p extends m {
+  constructor(t, e = {}) {
+    super(), this.length = 0, this.comparator = e.comparator || "zIndex", this.clean(), t && this.reset(t, { silent: !0 });
+  }
+  toJSON() {
+    return this.cells.map((t) => t.toJSON());
+  }
+  add(t, e, s) {
+    let r, i;
+    typeof e == "number" ? (r = e, i = Object.assign({ merge: !1 }, s)) : (r = this.length, i = Object.assign({ merge: !1 }, e)), r > this.length && (r = this.length), r < 0 && (r += this.length + 1);
+    const n = Array.isArray(t) ? t : [t], o = this.comparator && typeof e != "number" && i.sort !== !1, f = this.comparator || null;
+    let h = !1;
+    const a = [], g = [];
+    return n.forEach((c) => {
+      const l = this.get(c);
+      l ? i.merge && !c.isSameStore(l) && (l.setProp(c.getProp(), s), g.push(l), o && !h && (f == null || typeof f == "function" ? h = l.hasChanged() : typeof f == "string" ? h = l.hasChanged(f) : h = f.some((u) => l.hasChanged(u)))) : (a.push(c), this.reference(c));
+    }), a.length && (o && (h = !0), this.cells.splice(r, 0, ...a), this.length = this.cells.length), h && this.sort({ silent: !0 }), i.silent || (a.forEach((c, l) => {
+      const u = {
+        cell: c,
+        index: r + l,
+        options: i
+      };
+      this.trigger("added", u), i.dryrun || c.notify("added", Object.assign({}, u));
+    }), h && this.trigger("sorted"), (a.length || g.length) && this.trigger("updated", {
+      added: a,
+      merged: g,
+      removed: [],
+      options: i
+    })), this;
+  }
+  remove(t, e = {}) {
+    const s = Array.isArray(t) ? t : [t], r = this.removeCells(s, e);
+    return !e.silent && r.length > 0 && this.trigger("updated", {
+      options: e,
+      removed: r,
+      added: [],
+      merged: []
+    }), Array.isArray(t) ? r : r[0];
+  }
+  removeCells(t, e) {
+    const s = [];
+    for (let r = 0; r < t.length; r += 1) {
+      const i = this.get(t[r]);
+      if (i == null)
+        continue;
+      const n = this.cells.indexOf(i);
+      this.cells.splice(n, 1), this.length -= 1, delete this.map[i.id], s.push(i), this.unreference(i), e.dryrun || i.remove(), e.silent || (this.trigger("removed", { cell: i, index: n, options: e }), e.dryrun || i.notify("removed", { cell: i, index: n, options: e }));
+    }
+    return s;
+  }
+  reset(t, e = {}) {
+    const s = this.cells.slice();
+    if (s.forEach((r) => this.unreference(r)), this.clean(), this.add(t, Object.assign({ silent: !0 }, e)), !e.silent) {
+      const r = this.cells.slice();
+      this.trigger("reseted", {
+        options: e,
+        previous: s,
+        current: r
+      });
+      const i = [], n = [];
+      r.forEach((o) => {
+        s.some((h) => h.id === o.id) || i.push(o);
+      }), s.forEach((o) => {
+        r.some((h) => h.id === o.id) || n.push(o);
+      }), this.trigger("updated", { options: e, added: i, removed: n, merged: [] });
+    }
+    return this;
+  }
+  push(t, e) {
+    return this.add(t, this.length, e);
+  }
+  pop(t) {
+    const e = this.at(this.length - 1);
+    return this.remove(e, t);
+  }
+  unshift(t, e) {
+    return this.add(t, 0, e);
+  }
+  shift(t) {
+    const e = this.at(0);
+    return this.remove(e, t);
+  }
+  get(t) {
+    if (t == null)
+      return null;
+    const e = typeof t == "string" || typeof t == "number" ? t : t.id;
+    return this.map[e] || null;
+  }
+  has(t) {
+    return this.get(t) != null;
+  }
+  at(t) {
+    return t < 0 && (t += this.length), this.cells[t] || null;
+  }
+  first() {
+    return this.at(0);
+  }
+  last() {
+    return this.at(-1);
+  }
+  indexOf(t) {
+    return this.cells.indexOf(t);
+  }
+  toArray() {
+    return this.cells.slice();
+  }
+  sort(t = {}) {
+    return this.comparator != null && (this.cells = y(this.cells, this.comparator), t.silent || this.trigger("sorted")), this;
+  }
+  clone() {
+    const t = this.constructor;
+    return new t(this.cells.slice(), {
+      comparator: this.comparator
+    });
+  }
+  reference(t) {
+    this.map[t.id] = t, t.on("*", this.notifyCellEvent, this);
+  }
+  unreference(t) {
+    t.off("*", this.notifyCellEvent, this), delete this.map[t.id];
+  }
+  notifyCellEvent(t, e) {
+    const s = e.cell;
+    this.trigger(`cell:${t}`, e), s && (s.isNode() ? this.trigger(`node:${t}`, Object.assign(Object.assign({}, e), { node: s })) : s.isEdge() && this.trigger(`edge:${t}`, Object.assign(Object.assign({}, e), { edge: s })));
+  }
+  clean() {
+    this.length = 0, this.cells = [], this.map = {};
+  }
+  dispose() {
+    this.reset([]);
+  }
+}
+v([
+  p.dispose()
+], p.prototype, "dispose", null);
+export {
+  p as Collection
+};

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

@@ -0,0 +1,511 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { createClass as L } from "../../../x6-common/es/object/inherit.js";
+import { pascalCase as N } from "../../../x6-common/es/string/format.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 a } from "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import "../../../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 { Polyline as O } from "../../../x6-geometry/es/polyline.js";
+import { Registry as v } from "../registry/registry.js";
+import { Markup as A } from "../view/markup.js";
+import { ShareRegistry as C } from "./registry.js";
+import { Cell as m } from "./cell.js";
+import T from "../../../../lodash-es/merge.js";
+import P from "../../../../lodash-es/cloneDeep.js";
+import S from "../../../../lodash-es/isEqual.js";
+var b = function(o, e) {
+  var t = {};
+  for (var r in o) Object.prototype.hasOwnProperty.call(o, r) && e.indexOf(r) < 0 && (t[r] = o[r]);
+  if (o != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var s = 0, r = Object.getOwnPropertySymbols(o); s < r.length; s++)
+      e.indexOf(r[s]) < 0 && Object.prototype.propertyIsEnumerable.call(o, r[s]) && (t[r[s]] = o[r[s]]);
+  return t;
+};
+class g extends m {
+  get [Symbol.toStringTag]() {
+    return g.toStringTag;
+  }
+  constructor(e = {}) {
+    super(e);
+  }
+  preprocess(e, t) {
+    const { source: r, sourceCell: s, sourcePort: i, sourcePoint: n, target: l, targetCell: f, targetPort: h, targetPoint: y } = e, u = b(e, ["source", "sourceCell", "sourcePort", "sourcePoint", "target", "targetCell", "targetPort", "targetPoint"]), d = (c) => typeof c == "string" || typeof c == "number";
+    if (r != null)
+      if (m.isCell(r))
+        u.source = { cell: r.id };
+      else if (d(r))
+        u.source = { cell: r };
+      else if (a.isPoint(r))
+        u.source = r.toJSON();
+      else if (Array.isArray(r))
+        u.source = { x: r[0], y: r[1] };
+      else {
+        const c = r.cell;
+        m.isCell(c) ? u.source = Object.assign(Object.assign({}, r), { cell: c.id }) : u.source = r;
+      }
+    if (s != null || i != null) {
+      let c = u.source;
+      if (s != null) {
+        const p = d(s) ? s : s.id;
+        c ? c.cell = p : c = u.source = { cell: p };
+      }
+      i != null && c && (c.port = i);
+    } else n != null && (u.source = a.create(n).toJSON());
+    if (l != null)
+      if (m.isCell(l))
+        u.target = { cell: l.id };
+      else if (d(l))
+        u.target = { cell: l };
+      else if (a.isPoint(l))
+        u.target = l.toJSON();
+      else if (Array.isArray(l))
+        u.target = { x: l[0], y: l[1] };
+      else {
+        const c = l.cell;
+        m.isCell(c) ? u.target = Object.assign(Object.assign({}, l), { cell: c.id }) : u.target = l;
+      }
+    if (f != null || h != null) {
+      let c = u.target;
+      if (f != null) {
+        const p = d(f) ? f : f.id;
+        c ? c.cell = p : c = u.target = { cell: p };
+      }
+      h != null && c && (c.port = h);
+    } else y != null && (u.target = a.create(y).toJSON());
+    return super.preprocess(u, t);
+  }
+  setup() {
+    super.setup(), this.on("change:labels", (e) => this.onLabelsChanged(e)), this.on("change:vertices", (e) => this.onVertexsChanged(e));
+  }
+  isEdge() {
+    return !0;
+  }
+  // #region terminal
+  disconnect(e = {}) {
+    return this.store.set({
+      source: { x: 0, y: 0 },
+      target: { x: 0, y: 0 }
+    }, e), this;
+  }
+  get source() {
+    return this.getSource();
+  }
+  set source(e) {
+    this.setSource(e);
+  }
+  getSource() {
+    return this.getTerminal("source");
+  }
+  getSourceCellId() {
+    return this.source.cell;
+  }
+  getSourcePortId() {
+    return this.source.port;
+  }
+  setSource(e, t, r = {}) {
+    return this.setTerminal("source", e, t, r);
+  }
+  get target() {
+    return this.getTarget();
+  }
+  set target(e) {
+    this.setTarget(e);
+  }
+  getTarget() {
+    return this.getTerminal("target");
+  }
+  getTargetCellId() {
+    return this.target.cell;
+  }
+  getTargetPortId() {
+    return this.target.port;
+  }
+  setTarget(e, t, r = {}) {
+    return this.setTerminal("target", e, t, r);
+  }
+  getTerminal(e) {
+    return Object.assign({}, this.store.get(e));
+  }
+  setTerminal(e, t, r, s = {}) {
+    if (m.isCell(t))
+      return this.store.set(e, T({}, r, { cell: t.id }), s), this;
+    const i = t;
+    return a.isPoint(t) || i.x != null && i.y != null ? (this.store.set(e, T({}, r, { x: i.x, y: i.y }), s), this) : (this.store.set(e, P(t), s), this);
+  }
+  getSourcePoint() {
+    return this.getTerminalPoint("source");
+  }
+  getTargetPoint() {
+    return this.getTerminalPoint("target");
+  }
+  getTerminalPoint(e) {
+    const t = this[e];
+    if (a.isPointLike(t))
+      return a.create(t);
+    const r = this.getTerminalCell(e);
+    return r ? r.getConnectionPoint(this, e) : new a();
+  }
+  getSourceCell() {
+    return this.getTerminalCell("source");
+  }
+  getTargetCell() {
+    return this.getTerminalCell("target");
+  }
+  getTerminalCell(e) {
+    if (this.model) {
+      const t = e === "source" ? this.getSourceCellId() : this.getTargetCellId();
+      if (t)
+        return this.model.getCell(t);
+    }
+    return null;
+  }
+  getSourceNode() {
+    return this.getTerminalNode("source");
+  }
+  getTargetNode() {
+    return this.getTerminalNode("target");
+  }
+  getTerminalNode(e) {
+    let t = this;
+    const r = {};
+    for (; t && t.isEdge(); ) {
+      if (r[t.id])
+        return null;
+      r[t.id] = !0, t = t.getTerminalCell(e);
+    }
+    return t && t.isNode() ? t : null;
+  }
+  // #endregion
+  // #region router
+  get router() {
+    return this.getRouter();
+  }
+  set router(e) {
+    e == null ? this.removeRouter() : this.setRouter(e);
+  }
+  getRouter() {
+    return this.store.get("router");
+  }
+  setRouter(e, t, r) {
+    return typeof e == "object" ? this.store.set("router", e, t) : this.store.set("router", { name: e, args: t }, r), this;
+  }
+  removeRouter(e = {}) {
+    return this.store.remove("router", e), this;
+  }
+  // #endregion
+  // #region connector
+  get connector() {
+    return this.getConnector();
+  }
+  set connector(e) {
+    e == null ? this.removeConnector() : this.setConnector(e);
+  }
+  getConnector() {
+    return this.store.get("connector");
+  }
+  setConnector(e, t, r) {
+    return typeof e == "object" ? this.store.set("connector", e, t) : this.store.set("connector", { name: e, args: t }, r), this;
+  }
+  removeConnector(e = {}) {
+    return this.store.remove("connector", e);
+  }
+  // #endregion
+  // #region labels
+  getDefaultLabel() {
+    const e = this.constructor, t = this.store.get("defaultLabel") || e.defaultLabel || {};
+    return P(t);
+  }
+  get labels() {
+    return this.getLabels();
+  }
+  set labels(e) {
+    this.setLabels(e);
+  }
+  getLabels() {
+    return [...this.store.get("labels", [])].map((e) => this.parseLabel(e));
+  }
+  setLabels(e, t = {}) {
+    return this.store.set("labels", Array.isArray(e) ? e : [e], t), this;
+  }
+  insertLabel(e, t, r = {}) {
+    const s = this.getLabels(), i = s.length;
+    let n = t != null && Number.isFinite(t) ? t : i;
+    return n < 0 && (n = i + n + 1), s.splice(n, 0, this.parseLabel(e)), this.setLabels(s, r);
+  }
+  appendLabel(e, t = {}) {
+    return this.insertLabel(e, -1, t);
+  }
+  getLabelAt(e) {
+    const t = this.getLabels();
+    return e != null && Number.isFinite(e) ? this.parseLabel(t[e]) : null;
+  }
+  setLabelAt(e, t, r = {}) {
+    if (e != null && Number.isFinite(e)) {
+      const s = this.getLabels();
+      s[e] = this.parseLabel(t), this.setLabels(s, r);
+    }
+    return this;
+  }
+  removeLabelAt(e, t = {}) {
+    const r = this.getLabels(), s = e != null && Number.isFinite(e) ? e : -1, i = r.splice(s, 1);
+    return this.setLabels(r, t), i.length ? i[0] : null;
+  }
+  parseLabel(e) {
+    return typeof e == "string" ? this.constructor.parseStringLabel(e) : e;
+  }
+  onLabelsChanged({ previous: e, current: t }) {
+    const r = e && t ? t.filter((i) => e.find((n) => i === n || S(i, n)) ? null : i) : t ? [...t] : [], s = e && t ? e.filter((i) => t.find((n) => i === n || S(i, n)) ? null : i) : e ? [...e] : [];
+    r.length > 0 && this.notify("labels:added", { added: r, cell: this, edge: this }), s.length > 0 && this.notify("labels:removed", { removed: s, cell: this, edge: this });
+  }
+  // #endregion
+  // #region vertices
+  get vertices() {
+    return this.getVertices();
+  }
+  set vertices(e) {
+    this.setVertices(e);
+  }
+  getVertices() {
+    return [...this.store.get("vertices", [])];
+  }
+  setVertices(e, t = {}) {
+    const r = Array.isArray(e) ? e : [e];
+    return this.store.set("vertices", r.map((s) => a.toJSON(s)), t), this;
+  }
+  insertVertex(e, t, r = {}) {
+    const s = this.getVertices(), i = s.length;
+    let n = t != null && Number.isFinite(t) ? t : i;
+    return n < 0 && (n = i + n + 1), s.splice(n, 0, a.toJSON(e)), this.setVertices(s, r);
+  }
+  appendVertex(e, t = {}) {
+    return this.insertVertex(e, -1, t);
+  }
+  getVertexAt(e) {
+    return e != null && Number.isFinite(e) ? this.getVertices()[e] : null;
+  }
+  setVertexAt(e, t, r = {}) {
+    if (e != null && Number.isFinite(e)) {
+      const s = this.getVertices();
+      s[e] = t, this.setVertices(s, r);
+    }
+    return this;
+  }
+  removeVertexAt(e, t = {}) {
+    const r = this.getVertices(), s = e != null && Number.isFinite(e) ? e : -1;
+    return r.splice(s, 1), this.setVertices(r, t);
+  }
+  onVertexsChanged({ previous: e, current: t }) {
+    const r = e && t ? t.filter((i) => e.find((n) => a.equals(i, n)) ? null : i) : t ? [...t] : [], s = e && t ? e.filter((i) => t.find((n) => a.equals(i, n)) ? null : i) : e ? [...e] : [];
+    r.length > 0 && this.notify("vertexs:added", { added: r, cell: this, edge: this }), s.length > 0 && this.notify("vertexs:removed", { removed: s, cell: this, edge: this });
+  }
+  // #endregion
+  // #region markup
+  getDefaultMarkup() {
+    return this.store.get("defaultMarkup") || A.getEdgeMarkup();
+  }
+  getMarkup() {
+    return super.getMarkup() || this.getDefaultMarkup();
+  }
+  // #endregion
+  // #region transform
+  /**
+   * Translate the edge vertices (and source and target if they are points)
+   * by `tx` pixels in the x-axis and `ty` pixels in the y-axis.
+   */
+  translate(e, t, r = {}) {
+    return r.translateBy = r.translateBy || this.id, r.tx = e, r.ty = t, this.applyToPoints((s) => ({
+      x: (s.x || 0) + e,
+      y: (s.y || 0) + t
+    }), r);
+  }
+  /**
+   * Scales the edge's points (vertices) relative to the given origin.
+   */
+  scale(e, t, r, s = {}) {
+    return this.applyToPoints((i) => a.create(i).scale(e, t, r).toJSON(), s);
+  }
+  applyToPoints(e, t = {}) {
+    const r = {}, s = this.getSource(), i = this.getTarget();
+    a.isPointLike(s) && (r.source = e(s)), a.isPointLike(i) && (r.target = e(i));
+    const n = this.getVertices();
+    return n.length > 0 && (r.vertices = n.map(e)), this.store.set(r, t), this;
+  }
+  // #endregion
+  // #region common
+  getBBox() {
+    return this.getPolyline().bbox();
+  }
+  getConnectionPoint() {
+    return this.getPolyline().pointAt(0.5);
+  }
+  getPolyline() {
+    const e = [
+      this.getSourcePoint(),
+      ...this.getVertices().map((t) => a.create(t)),
+      this.getTargetPoint()
+    ];
+    return new O(e);
+  }
+  updateParent(e) {
+    let t = null;
+    const r = this.getSourceCell(), s = this.getTargetCell(), i = this.getParent();
+    return r && s && (r === s || r.isDescendantOf(s) ? t = s : s.isDescendantOf(r) ? t = r : t = m.getCommonAncestor(r, s)), i && t && t.id !== i.id && i.unembed(this, e), t && (!i || i.id !== t.id) && t.embed(this, e), t;
+  }
+  hasLoop(e = {}) {
+    const t = this.getSource(), r = this.getTarget(), s = t.cell, i = r.cell;
+    if (!s || !i)
+      return !1;
+    let n = s === i;
+    if (!n && e.deep && this._model) {
+      const l = this.getSourceCell(), f = this.getTargetCell();
+      l && f && (n = l.isAncestorOf(f, e) || f.isAncestorOf(l, e));
+    }
+    return n;
+  }
+  getFragmentAncestor() {
+    const e = [this, this.getSourceNode(), this.getTargetNode()].filter((t) => t != null);
+    return this.getCommonAncestor(...e);
+  }
+  isFragmentDescendantOf(e) {
+    const t = this.getFragmentAncestor();
+    return !!t && (t.id === e.id || t.isDescendantOf(e));
+  }
+}
+g.defaults = {};
+(function(o) {
+  function e(t, r) {
+    const s = t, i = r;
+    return s.cell === i.cell ? s.port === i.port || s.port == null && i.port == null : !1;
+  }
+  o.equalTerminals = e;
+})(g || (g = {}));
+(function(o) {
+  o.defaultLabel = {
+    markup: [
+      {
+        tagName: "rect",
+        selector: "body"
+      },
+      {
+        tagName: "text",
+        selector: "label"
+      }
+    ],
+    attrs: {
+      text: {
+        fill: "#000",
+        fontSize: 14,
+        textAnchor: "middle",
+        textVerticalAnchor: "middle",
+        pointerEvents: "none"
+      },
+      rect: {
+        ref: "label",
+        fill: "#fff",
+        rx: 3,
+        ry: 3,
+        refWidth: 1,
+        refHeight: 1,
+        refX: 0,
+        refY: 0
+      }
+    },
+    position: {
+      distance: 0.5
+    }
+  };
+  function e(t) {
+    return {
+      attrs: { label: { text: t } }
+    };
+  }
+  o.parseStringLabel = e;
+})(g || (g = {}));
+(function(o) {
+  o.toStringTag = `X6.${o.name}`;
+  function e(t) {
+    if (t == null)
+      return !1;
+    if (t instanceof o)
+      return !0;
+    const r = t[Symbol.toStringTag], s = t;
+    return (r == null || r === o.toStringTag) && typeof s.isNode == "function" && typeof s.isEdge == "function" && typeof s.prop == "function" && typeof s.attr == "function" && typeof s.disconnect == "function" && typeof s.getSource == "function" && typeof s.getTarget == "function";
+  }
+  o.isEdge = e;
+})(g || (g = {}));
+(function(o) {
+  o.registry = v.create({
+    type: "edge",
+    process(e, t) {
+      if (C.exist(e, !1))
+        throw new Error(`Edge with name '${e}' was registered by anthor Node`);
+      if (typeof t == "function")
+        return t.config({ shape: e }), t;
+      let r = o;
+      const { inherit: s = "edge" } = t, i = b(t, ["inherit"]);
+      if (typeof s == "string") {
+        const l = this.get(s || "edge");
+        l == null && s ? this.onNotFound(s, "inherited") : r = l;
+      } else
+        r = s;
+      i.constructorName == null && (i.constructorName = e);
+      const n = r.define.call(r, i);
+      return n.config({ shape: e }), n;
+    }
+  }), C.setEdgeRegistry(o.registry);
+})(g || (g = {}));
+(function(o) {
+  let e = 0;
+  function t(i) {
+    return i ? N(i) : (e += 1, `CustomEdge${e}`);
+  }
+  function r(i) {
+    const { constructorName: n, overwrite: l } = i, f = b(i, ["constructorName", "overwrite"]), h = L(t(n || f.shape), this);
+    return h.config(f), f.shape && o.registry.register(f.shape, h, l), h;
+  }
+  o.define = r;
+  function s(i) {
+    const n = i.shape || "edge", l = o.registry.get(n);
+    return l ? new l(i) : o.registry.onNotFound(n);
+  }
+  o.create = s;
+})(g || (g = {}));
+(function(o) {
+  const e = "basic.edge";
+  o.config({
+    shape: e,
+    propHooks(t) {
+      const { label: r, vertices: s } = t, i = b(t, ["label", "vertices"]);
+      if (r) {
+        i.labels == null && (i.labels = []);
+        const n = typeof r == "string" ? o.parseStringLabel(r) : r;
+        i.labels.push(n);
+      }
+      return s && Array.isArray(s) && (i.vertices = s.map((n) => a.create(n).toJSON())), i;
+    }
+  }), o.registry.register(e, o);
+})(g || (g = {}));
+export {
+  g as Edge
+};