service-flow-designer 0.0.1-beta.1 → 0.0.1-beta.4

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/dagre/src/util.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const number = require("../../../util/number.js");
+const graphlib = require("./graphlib.js");
+const Graph = graphlib.Graph;
+const addDummyNode = (g, type, attrs, name) => {
+  let v;
+  do {
+    v = `${name}${Math.random()}`;
+  } while (g.hasNode(v));
+  attrs.dummy = type;
+  g.setNode(v, attrs);
+  return v;
+};
+const simplify = (g) => {
+  const simplified = new Graph().setGraph(g.graph());
+  g.nodes().forEach((v) => {
+    simplified.setNode(v, g.node(v));
+  });
+  g.edges().forEach((e) => {
+    const simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
+    const label = g.edge(e);
+    simplified.setEdge(e.v, e.w, {
+      weight: simpleLabel.weight + label.weight,
+      minlen: Math.max(simpleLabel.minlen, label.minlen)
+    });
+  });
+  return simplified;
+};
+const asNonCompoundGraph = (g) => {
+  const simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+  g.nodes().forEach((v) => {
+    var _a;
+    if (!((_a = g.children(v)) === null || _a === void 0 ? void 0 : _a.length)) {
+      simplified.setNode(v, g.node(v));
+    }
+  });
+  g.edges().forEach((e) => simplified.setEdge(e, g.edge(e)));
+  return simplified;
+};
+const zipObject = (keys, values) => {
+  const result = {};
+  keys === null || keys === void 0 ? void 0 : keys.forEach((key, i) => {
+    result[key] = values[i];
+  });
+  return result;
+};
+const successorWeights = (g) => {
+  const weightMap = g.nodes().map((v) => {
+    var _a;
+    const sucs = {};
+    (_a = g.outEdges(v)) === null || _a === void 0 ? void 0 : _a.forEach((e) => {
+      sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
+    });
+    return sucs;
+  });
+  return zipObject(g.nodes(), weightMap);
+};
+const predecessorWeights = (g) => {
+  const weightMap = g.nodes().map((v) => {
+    var _a;
+    const preds = {};
+    (_a = g.inEdges(v)) === null || _a === void 0 ? void 0 : _a.forEach((e) => {
+      preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
+    });
+    return preds;
+  });
+  return zipObject(g.nodes(), weightMap);
+};
+const intersectRect = (rect, point) => {
+  const x = rect.x;
+  const y = rect.y;
+  const dx = point.x - x;
+  const dy = point.y - y;
+  let w = rect.width / 2;
+  let h = rect.height / 2;
+  if (!dx && !dy) {
+    return { x: 0, y: 0 };
+  }
+  let sx;
+  let sy;
+  if (Math.abs(dy) * w > Math.abs(dx) * h) {
+    if (dy < 0) {
+      h = -h;
+    }
+    sx = h * dx / dy;
+    sy = h;
+  } else {
+    if (dx < 0) {
+      w = -w;
+    }
+    sx = w;
+    sy = w * dy / dx;
+  }
+  return { x: x + sx, y: y + sy };
+};
+const buildLayerMatrix = (g) => {
+  const layering = [];
+  const layeringNodes = [];
+  const rankMax = maxRank(g) + 1;
+  for (let i = 0; i < rankMax; i++) {
+    layering.push([]);
+    layeringNodes.push([]);
+  }
+  g.nodes().forEach((v) => {
+    const node = g.node(v);
+    const rank = node.rank;
+    if (rank !== void 0 && layering[rank]) {
+      layeringNodes[rank].push(v);
+    }
+  });
+  layeringNodes === null || layeringNodes === void 0 ? void 0 : layeringNodes.forEach((layer, rank) => {
+    layer === null || layer === void 0 ? void 0 : layer.sort((va, vb) => {
+      var _a, _b;
+      return ((_a = g.node(va)) === null || _a === void 0 ? void 0 : _a.order) - ((_b = g.node(vb)) === null || _b === void 0 ? void 0 : _b.order);
+    });
+    layer.forEach((v) => {
+      layering[rank].push(v);
+    });
+  });
+  return layering;
+};
+const normalizeRanks = (g) => {
+  const nodeRanks = g.nodes().filter((v) => g.node(v).rank !== void 0).map((v) => g.node(v).rank);
+  const min = Math.min(...nodeRanks);
+  g.nodes().forEach((v) => {
+    const node = g.node(v);
+    if (node.hasOwnProperty("rank")) {
+      if (!node.rank)
+        node.rank = 0;
+      node.rank -= min;
+    }
+  });
+};
+const removeEmptyRanks = (g) => {
+  const nodeRanks = g.nodes().filter((v) => g.node(v).rank !== void 0).map((v) => g.node(v).rank);
+  const offset = Math.min(...nodeRanks);
+  const layers = [];
+  g.nodes().forEach((v) => {
+    var _a;
+    const rank = (((_a = g.node(v)) === null || _a === void 0 ? void 0 : _a.rank) || 0) - offset;
+    if (!layers[rank]) {
+      layers[rank] = [];
+    }
+    layers[rank].push(v);
+  });
+  let delta = 0;
+  const nodeRankFactor = g.graph().nodeRankFactor || 0;
+  for (let i = 0; i < layers.length; i++) {
+    const vs = layers[i];
+    if (vs === void 0 && i % nodeRankFactor !== 0) {
+      --delta;
+    } else if (delta) {
+      vs === null || vs === void 0 ? void 0 : vs.forEach((v) => {
+        if (!g.node(v).rank)
+          g.node(v).rank = 0;
+        g.node(v).rank += delta;
+      });
+    }
+  }
+};
+const addBorderNode = (g, prefix, rank, order) => {
+  const node = {
+    width: 0,
+    height: 0
+  };
+  if (number.isNumber(rank) && number.isNumber(order)) {
+    node.rank = rank;
+    node.order = order;
+  }
+  return addDummyNode(g, "border", node, prefix);
+};
+const maxRank = (g) => {
+  const nodeRanks = g.nodes().map((v) => {
+    const rank = g.node(v).rank;
+    if (rank !== void 0) {
+      return rank;
+    }
+    return -Infinity;
+  });
+  return Math.max(...nodeRanks);
+};
+const partition = (collection, fn) => {
+  const result = { lhs: [], rhs: [] };
+  collection === null || collection === void 0 ? void 0 : collection.forEach((value) => {
+    if (fn(value)) {
+      result.lhs.push(value);
+    } else {
+      result.rhs.push(value);
+    }
+  });
+  return result;
+};
+const time = (name, fn) => {
+  const start = Date.now();
+  try {
+    return fn();
+  } finally {
+    console.log(`${name} time: ${Date.now() - start}ms`);
+  }
+};
+const notime = (name, fn) => {
+  return fn();
+};
+const minBy = (array, func) => {
+  let min = Infinity;
+  let minObject;
+  array === null || array === void 0 ? void 0 : array.forEach((item) => {
+    const value = func(item);
+    if (min > value) {
+      min = value;
+      minObject = item;
+    }
+  });
+  return minObject;
+};
+const util = {
+  addDummyNode,
+  simplify,
+  asNonCompoundGraph,
+  successorWeights,
+  predecessorWeights,
+  intersectRect,
+  buildLayerMatrix,
+  normalizeRanks,
+  removeEmptyRanks,
+  addBorderNode,
+  maxRank,
+  partition,
+  time,
+  notime,
+  zipObject,
+  minBy
+};
+exports.addBorderNode = addBorderNode;
+exports.addDummyNode = addDummyNode;
+exports.asNonCompoundGraph = asNonCompoundGraph;
+exports.buildLayerMatrix = buildLayerMatrix;
+exports.default = util;
+exports.intersectRect = intersectRect;
+exports.maxRank = maxRank;
+exports.minBy = minBy;
+exports.normalizeRanks = normalizeRanks;
+exports.notime = notime;
+exports.partition = partition;
+exports.predecessorWeights = predecessorWeights;
+exports.removeEmptyRanks = removeEmptyRanks;
+exports.simplify = simplify;
+exports.successorWeights = successorWeights;
+exports.time = time;
+exports.zipObject = zipObject;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/dagre.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./dagre/index.js");
+const array = require("../util/array.js");
+const number = require("../util/number.js");
+const math = require("../util/math.js");
+const object = require("../util/object.js");
+const base = require("./base.js");
+class DagreLayout extends base.Base {
+  constructor(options) {
+    super();
+    this.rankdir = "TB";
+    this.nodesep = 50;
+    this.ranksep = 50;
+    this.controlPoints = false;
+    this.sortByCombo = false;
+    this.edgeLabelSpace = true;
+    this.nodes = [];
+    this.edges = [];
+    this.onLayoutEnd = () => {
+    };
+    this.layoutNode = (nodeId) => {
+      const self = this;
+      const { nodes } = self;
+      const node = nodes.find((node2) => node2.id === nodeId);
+      if (node) {
+        const layout = node.layout !== false;
+        return layout;
+      }
+      return true;
+    };
+    this.updateCfg(options);
+  }
+  getDefaultCfg() {
+    return {
+      rankdir: "TB",
+      align: void 0,
+      nodeSize: void 0,
+      nodesepFunc: void 0,
+      ranksepFunc: void 0,
+      nodesep: 50,
+      ranksep: 50,
+      controlPoints: false
+      // 是否保留布局连线的控制点
+    };
+  }
+  /**
+   * 执行布局
+   */
+  execute() {
+    const self = this;
+    const { nodes, nodeSize, rankdir, combos, begin } = self;
+    if (!nodes)
+      return;
+    const edges = self.edges || [];
+    const g = new index.graphlib.Graph({
+      multigraph: true,
+      compound: true
+    });
+    let nodeSizeFunc;
+    if (!nodeSize) {
+      nodeSizeFunc = (d) => {
+        if (d.size) {
+          if (array.isArray(d.size)) {
+            return d.size;
+          }
+          if (object.isObject(d.size)) {
+            return [d.size.width || 40, d.size.height || 40];
+          }
+          return [d.size, d.size];
+        }
+        return [40, 40];
+      };
+    } else if (array.isArray(nodeSize)) {
+      nodeSizeFunc = () => nodeSize;
+    } else {
+      nodeSizeFunc = () => [nodeSize, nodeSize];
+    }
+    let horisep = getFunc(self.nodesepFunc, self.nodesep, 50);
+    let vertisep = getFunc(self.ranksepFunc, self.ranksep, 50);
+    if (rankdir === "LR" || rankdir === "RL") {
+      horisep = getFunc(self.ranksepFunc, self.ranksep, 50);
+      vertisep = getFunc(self.nodesepFunc, self.nodesep, 50);
+    }
+    g.setDefaultEdgeLabel(() => ({}));
+    g.setGraph(self);
+    const comboMap = {};
+    nodes.filter((node) => node.layout !== false).forEach((node) => {
+      const size = nodeSizeFunc(node);
+      const verti = vertisep(node);
+      const hori = horisep(node);
+      const width = size[0] + 2 * hori;
+      const height = size[1] + 2 * verti;
+      const layer = node.layer;
+      if (number.isNumber(layer)) {
+        g.setNode(node.id, { width, height, layer });
+      } else {
+        g.setNode(node.id, { width, height });
+      }
+      if (this.sortByCombo && node.comboId) {
+        if (!comboMap[node.comboId]) {
+          comboMap[node.comboId] = true;
+          g.setNode(node.comboId, {});
+        }
+        g.setParent(node.id, node.comboId);
+      }
+    });
+    if (this.sortByCombo && combos) {
+      combos.forEach((combo) => {
+        if (!combo.parentId)
+          return;
+        if (!comboMap[combo.parentId]) {
+          comboMap[combo.parentId] = true;
+          g.setNode(combo.parentId, {});
+        }
+        g.setParent(combo.id, combo.parentId);
+      });
+    }
+    edges.forEach((edge) => {
+      const source = math.getEdgeTerminal(edge, "source");
+      const target = math.getEdgeTerminal(edge, "target");
+      if (this.layoutNode(source) && this.layoutNode(target)) {
+        g.setEdge(source, target, {
+          weight: edge.weight || 1
+        });
+      }
+    });
+    let prevGraph = void 0;
+    if (self.preset) {
+      prevGraph = new index.graphlib.Graph({
+        multigraph: true,
+        compound: true
+      });
+      self.preset.nodes.forEach((node) => {
+        prevGraph === null || prevGraph === void 0 ? void 0 : prevGraph.setNode(node.id, node);
+      });
+    }
+    index.layout(g, {
+      prevGraph,
+      edgeLabelSpace: self.edgeLabelSpace,
+      keepNodeOrder: Boolean(!!self.nodeOrder),
+      nodeOrder: self.nodeOrder
+    });
+    const dBegin = [0, 0];
+    if (begin) {
+      let minX = Infinity;
+      let minY = Infinity;
+      g.nodes().forEach((node) => {
+        const coord = g.node(node);
+        if (minX > coord.x)
+          minX = coord.x;
+        if (minY > coord.y)
+          minY = coord.y;
+      });
+      g.edges().forEach((edge) => {
+        const coord = g.edge(edge);
+        coord.points.forEach((point) => {
+          if (minX > point.x)
+            minX = point.x;
+          if (minY > point.y)
+            minY = point.y;
+        });
+      });
+      dBegin[0] = begin[0] - minX;
+      dBegin[1] = begin[1] - minY;
+    }
+    g.nodes().forEach((node) => {
+      const coord = g.node(node);
+      const i = nodes.findIndex((it) => it.id === node);
+      if (!nodes[i])
+        return;
+      nodes[i].x = coord.x + dBegin[0];
+      nodes[i].y = coord.y + dBegin[1];
+      nodes[i]._order = coord._order;
+    });
+    g.edges().forEach((edge) => {
+      const coord = g.edge(edge);
+      const i = edges.findIndex((it) => {
+        const source = math.getEdgeTerminal(it, "source");
+        const target = math.getEdgeTerminal(it, "target");
+        return source === edge.v && target === edge.w;
+      });
+      if (self.edgeLabelSpace && self.controlPoints && edges[i].type !== "loop") {
+        edges[i].controlPoints = coord.points.slice(1, coord.points.length - 1);
+        edges[i].controlPoints.forEach((point) => {
+          point.x += dBegin[0];
+          point.y += dBegin[1];
+        });
+      }
+    });
+    if (self.onLayoutEnd)
+      self.onLayoutEnd();
+    return {
+      nodes,
+      edges
+    };
+  }
+  getType() {
+    return "dagre";
+  }
+}
+function getFunc(func, value, defaultValue) {
+  let resultFunc;
+  if (func) {
+    resultFunc = func;
+  } else if (number.isNumber(value)) {
+    resultFunc = () => value;
+  } else {
+    resultFunc = () => defaultValue;
+  }
+  return resultFunc;
+}
+exports.DagreLayout = DagreLayout;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/gpu/fruchterman.js

@@ -0,0 +1,34 @@
+"use strict";
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/camera/Camera.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/geometry/index.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/Kernel.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/material/index.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/renderable/Renderable.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/World.js");
+(function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+});

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/layout/gpu/gForce.js

@@ -0,0 +1,34 @@
+"use strict";
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/camera/Camera.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/geometry/index.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/Kernel.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/material/index.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/renderable/Renderable.js");
+require("../../../../../../../@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/World.js");
+(function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+});

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/util/array.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isArray = Array.isArray;
+exports.isArray = isArray;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/util/math.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const object = require("./object.js");
+const getEdgeTerminal = (edge, type) => {
+  const terminal = edge[type];
+  if (object.isObject(terminal)) {
+    return terminal.cell;
+  }
+  return terminal;
+};
+exports.getEdgeTerminal = getEdgeTerminal;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/util/number.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isNumber = (val) => typeof val === "number";
+exports.isNumber = isNumber;

package/dist/lib/node_modules/.pnpm/@antv_layout@0.1.31/node_modules/@antv/layout/es/util/object.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isObject = (val) => val !== null && typeof val === "object";
+const clone = (target) => {
+  if (target === null) {
+    return target;
+  }
+  if (target instanceof Date) {
+    return new Date(target.getTime());
+  }
+  if (target instanceof Array) {
+    const cp = [];
+    target.forEach((v) => {
+      cp.push(v);
+    });
+    return cp.map((n) => clone(n));
+  }
+  if (typeof target === "object" && target !== {}) {
+    const cp = Object.assign({}, target);
+    Object.keys(cp).forEach((k) => {
+      cp[k] = clone(cp[k]);
+    });
+    return cp;
+  }
+  return target;
+};
+exports.clone = clone;
+exports.isObject = isObject;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js

@@ -0,0 +1,10 @@
+"use strict";
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+  var a = {};
+  return Object.keys(n).forEach(function(i2) {
+    a[i2] = n[i2];
+  }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = true), a = r.slice().reverse().reduce(function(r2, n2) {
+    return n2(i, e, r2) || r2;
+  }, a), void 0 === a.initializer && (Object.defineProperty(i, e, a), a = null), a;
+}
+module.exports = _applyDecoratedDescriptor;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js

@@ -0,0 +1,7 @@
+"use strict";
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+module.exports = _arrayLikeToArray;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js

@@ -0,0 +1,5 @@
+"use strict";
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+module.exports = _arrayWithHoles;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

@@ -0,0 +1,6 @@
+"use strict";
+const arrayLikeToArray = require("./arrayLikeToArray.js");
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return arrayLikeToArray(r);
+}
+module.exports = _arrayWithoutHoles;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js

@@ -0,0 +1,6 @@
+"use strict";
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+module.exports = _assertThisInitialized;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js

@@ -0,0 +1,25 @@
+"use strict";
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c), u = i.value;
+  } catch (n2) {
+    return void e(n2);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function() {
+    var t = this, e = arguments;
+    return new Promise(function(r, o) {
+      var a = n.apply(t, e);
+      function _next(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
+      }
+      function _throw(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
+      }
+      _next(void 0);
+    });
+  };
+}
+module.exports = _asyncToGenerator;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js

@@ -0,0 +1,5 @@
+"use strict";
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+module.exports = _classCallCheck;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js

@@ -0,0 +1,14 @@
+"use strict";
+const toPropertyKey = require("./toPropertyKey.js");
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: false
+  }), e;
+}
+module.exports = _createClass;

package/dist/lib/node_modules/.pnpm/@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/defineProperty.js

@@ -0,0 +1,11 @@
+"use strict";
+const toPropertyKey = require("./toPropertyKey.js");
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+module.exports = _defineProperty;