@flowgram.ai/free-lines-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,638 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  LINE_OFFSET: () => LINE_OFFSET,
+  LinesLayer: () => LinesLayer,
+  WorkflowPortRender: () => WorkflowPortRender,
+  createFreeLinesPlugin: () => createFreeLinesPlugin
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/components/workflow-port-render/index.tsx
+var import_react_dom = __toESM(require("react-dom"));
+var import_react2 = __toESM(require("react"));
+var import_clsx = __toESM(require("clsx"));
+var import_free_layout_core = require("@flowgram.ai/free-layout-core");
+var import_core = require("@flowgram.ai/core");
+
+// src/constants/points.ts
+var STROKE_WIDTH_SLECTED = 3;
+var STROKE_WIDTH = 2;
+var PORT_BG_CLASS_NAME = "workflow-port-bg";
+
+// src/components/workflow-port-render/style.ts
+var import_styled_components = __toESM(require("styled-components"));
+var WorkflowPointStyle = import_styled_components.default.div`
+  width: 20px;
+  height: 20px;
+  border-radius: 50%;
+  margin-top: -10px;
+  margin-left: -10px;
+  left: 50%;
+  top: 50%;
+  position: absolute;
+  // 非 hover 状态下的样式
+  border: none;
+
+  & > .symbol {
+    opacity: 0;
+  }
+
+  .bg-circle {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: absolute;
+    border-radius: 50%;
+    width: 20px;
+    height: 20px;
+    background-color: #fff;
+    transform: scale(0.5);
+    transition: all 0.2s linear 0s;
+  }
+
+  .bg {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: relative;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background: #9197F1;
+    transform: scale(0.4, 0.4);
+    transition: all 0.2s linear 0s;
+
+    &.hasError {
+      background: red;
+    }
+
+    .symbol {
+      position: absolute;
+      width: 14px;
+      height: 14px;
+      opacity: 0;
+      pointer-events: none;
+      color: #fff;
+      transition: opacity 0.2s linear 0s;
+
+      & > svg {
+        width: 14px;
+        height: 14px;
+      }
+    }
+
+    .focus-circle {
+      position: absolute;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      width: 8px;
+      height: 8px;
+      opacity: 0;
+      background: #9197f1;
+      border-radius: 50%;
+      transition: opacity 0.2s linear 0s;
+    }
+  }
+
+  &.linked .bg:not(.hasError) {
+    background: #4d53e8;
+  }
+
+  &.hovered .bg:not(.hasError) {
+    border: none;
+    cursor: crosshair;
+    transform: scale(1, 1);
+    background: #4d53e8;
+
+    & > .symbol {
+      opacity: 1;
+    }
+  }
+
+  .cross-hair {
+    position: relative;
+    left: 2px;
+    top: 2px;
+
+    &::after,
+    &::before {
+      content: '';
+      background: #fff;
+      border-radius: 2px;
+      position: absolute;
+    }
+
+    &::after {
+      left: 4px;
+      width: 2px;
+      height: 6px;
+      box-shadow: 0 4px #fff;
+    }
+
+    &::before {
+      top: 4px;
+      width: 6px;
+      height: 2px;
+      box-shadow: 4px 0 #fff;
+    }
+`;
+
+// src/components/workflow-port-render/cross-hair.tsx
+var import_react = __toESM(require("react"));
+function CrossHair() {
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: "symbol" }, /* @__PURE__ */ import_react.default.createElement("div", { className: "cross-hair" }));
+}
+
+// src/components/workflow-port-render/index.tsx
+var WorkflowPortRender = (
+  // eslint-disable-next-line react/display-name
+  import_react2.default.memo((props) => {
+    const hoverService = (0, import_core.useService)(import_free_layout_core.WorkflowHoverService);
+    const linesManager = (0, import_core.useService)(import_free_layout_core.WorkflowLinesManager);
+    const { entity, onClick } = props;
+    const { portType, relativePosition, disabled } = entity;
+    const [targetElement, setTargetElement] = (0, import_react2.useState)(entity.targetElement);
+    const [posX, updatePosX] = (0, import_react2.useState)(relativePosition.x);
+    const [posY, updatePosY] = (0, import_react2.useState)(relativePosition.y);
+    const [hovered, setHovered] = (0, import_react2.useState)(false);
+    const [linked, setLinked] = (0, import_react2.useState)(Boolean(entity?.lines?.length));
+    const [hasError, setHasError] = (0, import_react2.useState)(props.entity.hasError);
+    const readonly = (0, import_free_layout_core.usePlaygroundReadonlyState)();
+    (0, import_react2.useEffect)(() => {
+      entity.validate();
+      setHasError(entity.hasError);
+      const dispose = entity.onEntityChange(() => {
+        if (entity.targetElement) {
+          if (entity.targetElement !== targetElement) {
+            setTargetElement(entity.targetElement);
+          }
+          return;
+        }
+        const newPos = entity.relativePosition;
+        updatePosX(Math.round(newPos.x));
+        updatePosY(Math.round(newPos.y));
+      });
+      const dispose2 = hoverService.onHoveredChange((id) => {
+        setHovered(hoverService.isHovered(entity.id));
+      });
+      const dispose3 = entity.onErrorChanged(() => {
+        setHasError(entity.hasError);
+      });
+      const dispose4 = linesManager.onAvailableLinesChange(() => {
+        setTimeout(() => {
+          if (linesManager.disposed || entity.disposed) return;
+          setLinked(Boolean(entity.lines.length));
+        }, 0);
+      });
+      return () => {
+        dispose.dispose();
+        dispose2.dispose();
+        dispose3.dispose();
+        dispose4.dispose();
+      };
+    }, [hoverService, entity, targetElement]);
+    const className = (0, import_clsx.default)(props.className || "", {
+      hovered: !readonly && hovered && !disabled && portType !== "input",
+      // 有线条链接的时候深蓝色小圆点
+      linked
+    });
+    const content = /* @__PURE__ */ import_react2.default.createElement(
+      WorkflowPointStyle,
+      {
+        className,
+        style: targetElement ? props.style : { ...props.style, left: posX, top: posY },
+        onClick,
+        "data-port-entity-id": entity.id,
+        "data-port-entity-type": entity.portType,
+        "data-testid": "sdk.workflow.canvas.node.port"
+      },
+      /* @__PURE__ */ import_react2.default.createElement("div", { className: (0, import_clsx.default)("bg-circle", "workflow-bg-circle") }),
+      /* @__PURE__ */ import_react2.default.createElement(
+        "div",
+        {
+          className: (0, import_clsx.default)({
+            bg: true,
+            [PORT_BG_CLASS_NAME]: true,
+            "workflow-point-bg": true,
+            hasError
+          })
+        },
+        /* @__PURE__ */ import_react2.default.createElement(CrossHair, null)
+      ),
+      /* @__PURE__ */ import_react2.default.createElement("div", { className: "focus-circle" })
+    );
+    if (targetElement) {
+      return import_react_dom.default.createPortal(content, targetElement);
+    }
+    return content;
+  })
+);
+
+// src/constants/lines.ts
+var LINE_OFFSET = 6;
+
+// src/create-free-lines-plugin.ts
+var import_core3 = require("@flowgram.ai/core");
+
+// src/layer/lines-layer.tsx
+var import_react_dom2 = __toESM(require("react-dom"));
+var import_react7 = __toESM(require("react"));
+var import_inversify = require("inversify");
+var import_utils = require("@flowgram.ai/utils");
+var import_free_layout_core5 = require("@flowgram.ai/free-layout-core");
+var import_core2 = require("@flowgram.ai/core");
+
+// src/components/lines/index.tsx
+var import_react6 = __toESM(require("react"));
+var import_free_layout_core4 = require("@flowgram.ai/free-layout-core");
+
+// src/components/lines/fold-line/index.tsx
+var import_react4 = __toESM(require("react"));
+var import_free_layout_core2 = require("@flowgram.ai/free-layout-core");
+
+// src/components/lines/index.style.ts
+var import_styled_components2 = __toESM(require("styled-components"));
+var LineStyle = import_styled_components2.default.div.attrs({
+  className: "gedit-flow-activity-edge"
+})`
+  position: absolute;
+
+  @keyframes flowingDash {
+    to {
+      stroke-dashoffset: -13;
+    }
+  }
+
+  .flowing-line {
+    stroke-dasharray: 8, 5;
+    animation: flowingDash 0.5s linear infinite;
+  }
+`;
+
+// src/components/lines/arrow/index.tsx
+var import_react3 = __toESM(require("react"));
+function ArrowRenderer({
+  id,
+  pos,
+  reverseArrow,
+  strokeWidth,
+  vertical,
+  hide
+}) {
+  if (hide) {
+    return null;
+  }
+  const arrowPath = vertical ? reverseArrow ? `M ${pos.x - LINE_OFFSET},${pos.y} L ${pos.x},${pos.y - LINE_OFFSET} L ${pos.x + LINE_OFFSET},${pos.y}` : `M ${pos.x - LINE_OFFSET},${pos.y - LINE_OFFSET} L ${pos.x},${pos.y} L ${pos.x + LINE_OFFSET},${pos.y - LINE_OFFSET}` : reverseArrow ? `M ${pos.x},${pos.y + LINE_OFFSET} L ${pos.x - LINE_OFFSET},${pos.y} L ${pos.x},${pos.y - LINE_OFFSET}` : `M ${pos.x - LINE_OFFSET},${pos.y - LINE_OFFSET} L ${pos.x},${pos.y} L ${pos.x - LINE_OFFSET},${pos.y + LINE_OFFSET}`;
+  return /* @__PURE__ */ import_react3.default.createElement(
+    "path",
+    {
+      d: arrowPath,
+      strokeLinecap: "round",
+      stroke: `url(#${id})`,
+      fill: "none",
+      strokeWidth
+    }
+  );
+}
+
+// src/components/lines/fold-line/index.tsx
+var FoldLineRender = (props) => {
+  const { selected, color, line, children } = props;
+  const { to, from } = line.position;
+  const strokeWidth = selected ? STROKE_WIDTH_SLECTED : STROKE_WIDTH;
+  const arrowToPos = {
+    x: to.x - import_free_layout_core2.POINT_RADIUS,
+    y: to.y
+  };
+  const arrowFromPos = {
+    x: from.x + import_free_layout_core2.POINT_RADIUS + LINE_OFFSET,
+    y: from.y
+  };
+  return /* @__PURE__ */ import_react4.default.createElement(LineStyle, null, children, /* @__PURE__ */ import_react4.default.createElement("svg", { overflow: "visible" }, /* @__PURE__ */ import_react4.default.createElement("defs", null, /* @__PURE__ */ import_react4.default.createElement(
+    "linearGradient",
+    {
+      x1: "0%",
+      y1: "100%",
+      x2: "100%",
+      y2: "100%",
+      id: line.id,
+      gradientUnits: "userSpaceOnUse"
+    },
+    /* @__PURE__ */ import_react4.default.createElement("stop", { stopColor: color, offset: "0%" }),
+    /* @__PURE__ */ import_react4.default.createElement("stop", { stopColor: color, offset: "100%" })
+  )), /* @__PURE__ */ import_react4.default.createElement("g", null, /* @__PURE__ */ import_react4.default.createElement(
+    "path",
+    {
+      d: line.bezier.foldPath,
+      fill: "none",
+      strokeLinecap: "round",
+      stroke: color,
+      strokeWidth,
+      className: line.flowing || line.processing ? "flowing-line" : ""
+    }
+  ), /* @__PURE__ */ import_react4.default.createElement(
+    ArrowRenderer,
+    {
+      id: line.id,
+      reverseArrow: line.reverse,
+      pos: line.reverse ? arrowFromPos : arrowToPos,
+      strokeWidth,
+      hide: line.hideArrow
+    }
+  ))));
+};
+
+// src/components/lines/bezier-line/index.tsx
+var import_react5 = __toESM(require("react"));
+var import_free_layout_core3 = require("@flowgram.ai/free-layout-core");
+var PADDING = 12;
+var BezierLineRender = (props) => {
+  const { line, color, fromColor, toColor, selected, children, strokePrefix } = props;
+  const { bbox } = line.bezier;
+  const { position, reverse, vertical, hideArrow } = line;
+  const toRelative = (p) => ({
+    x: p.x - bbox.x + PADDING,
+    y: p.y - bbox.y + PADDING
+  });
+  const fromPos = toRelative(position.from);
+  const toPos = toRelative(position.to);
+  const arrowToPos = vertical ? { x: toPos.x, y: toPos.y - import_free_layout_core3.POINT_RADIUS } : { x: toPos.x - import_free_layout_core3.POINT_RADIUS, y: toPos.y };
+  const arrowFromPos = vertical ? { x: fromPos.x, y: fromPos.y + import_free_layout_core3.POINT_RADIUS + LINE_OFFSET } : { x: fromPos.x + import_free_layout_core3.POINT_RADIUS + LINE_OFFSET, y: fromPos.y };
+  const controls = line.bezier.controls.map((c) => toRelative(c));
+  const getLinearStartColor = () => {
+    if (vertical) {
+      return fromPos.y < arrowToPos.y ? fromColor : toColor;
+    }
+    return fromPos.x < arrowToPos.x ? fromColor : toColor;
+  };
+  const getLinearEndColor = () => {
+    if (vertical) {
+      return fromPos.y < arrowToPos.y ? toColor : fromColor;
+    }
+    return fromPos.x < arrowToPos.x ? toColor : fromColor;
+  };
+  const linearStartColor = getLinearStartColor();
+  const linearEndColor = getLinearEndColor();
+  const getPathData = () => {
+    const controlPoints = controls.map((s) => `${s.x} ${s.y}`).join(",");
+    const curveType = controls.length === 1 ? "S" : "C";
+    if (vertical) {
+      return `M${fromPos.x} ${fromPos.y + import_free_layout_core3.POINT_RADIUS} ${curveType} ${controlPoints}, ${arrowToPos.x} ${arrowToPos.y}`;
+    }
+    return `M${fromPos.x + import_free_layout_core3.POINT_RADIUS} ${fromPos.y} ${curveType} ${controlPoints}, ${arrowToPos.x} ${arrowToPos.y}`;
+  };
+  const pathData = getPathData();
+  const strokeWidth = selected ? STROKE_WIDTH_SLECTED : STROKE_WIDTH;
+  const strokeID = strokePrefix ? `${strokePrefix}-${line.id}` : line.id;
+  const path = /* @__PURE__ */ import_react5.default.createElement(
+    "path",
+    {
+      d: pathData,
+      fill: "none",
+      stroke: `url(#${strokeID})`,
+      strokeWidth,
+      className: line.processing || line.flowing ? "flowing-line" : ""
+    }
+  );
+  return /* @__PURE__ */ import_react5.default.createElement(
+    LineStyle,
+    {
+      style: {
+        left: bbox.x - PADDING,
+        top: bbox.y - PADDING,
+        position: "absolute"
+      }
+    },
+    children,
+    /* @__PURE__ */ import_react5.default.createElement("svg", { width: bbox.width + PADDING * 2, height: bbox.height + PADDING * 2 }, /* @__PURE__ */ import_react5.default.createElement("defs", null, /* @__PURE__ */ import_react5.default.createElement(
+      "linearGradient",
+      {
+        x1: vertical ? "100%" : "0%",
+        y1: vertical ? "0%" : "100%",
+        x2: "100%",
+        y2: "100%",
+        id: strokeID,
+        gradientUnits: "userSpaceOnUse"
+      },
+      /* @__PURE__ */ import_react5.default.createElement("stop", { stopColor: color || linearStartColor, offset: "0%" }),
+      /* @__PURE__ */ import_react5.default.createElement("stop", { stopColor: color || linearEndColor, offset: "100%" })
+    )), /* @__PURE__ */ import_react5.default.createElement("g", null, path, /* @__PURE__ */ import_react5.default.createElement(
+      ArrowRenderer,
+      {
+        id: strokeID,
+        reverseArrow: reverse,
+        pos: reverse ? arrowFromPos : arrowToPos,
+        strokeWidth,
+        vertical,
+        hide: hideArrow
+      }
+    ), props.showControlPoints ? controls.map((c, i) => /* @__PURE__ */ import_react5.default.createElement("circle", { key: i, cx: c.x, cy: c.y, r: "4", fill: "#ccc" })) : void 0))
+  );
+};
+
+// src/components/lines/index.tsx
+var LineTypeRender = (props) => {
+  if (props.lineType === import_free_layout_core4.LineType.LINE_CHART) {
+    return /* @__PURE__ */ import_react6.default.createElement(FoldLineRender, { ...props });
+  }
+  return /* @__PURE__ */ import_react6.default.createElement(BezierLineRender, { ...props });
+};
+var LineRender = (0, import_react6.memo)(
+  LineTypeRender,
+  (prevProps, nextProps) => prevProps.version === nextProps.version
+);
+
+// src/layer/lines-layer.tsx
+var LinesLayer = class extends import_core2.Layer {
+  constructor() {
+    super(...arguments);
+    this.layerID = (0, import_free_layout_core5.nanoid)();
+    this.mountedLines = /* @__PURE__ */ new Map();
+    this._version = 0;
+    /**
+     * 节点线条
+     */
+    this.node = import_utils.domUtils.createDivWithClass("gedit-playground-layer gedit-flow-lines-layer");
+  }
+  onZoom(scale) {
+    this.node.style.transform = `scale(${scale})`;
+  }
+  onReady() {
+    this.pipelineNode.appendChild(this.node);
+    this.toDispose.pushAll([
+      this.selectService.onSelectionChanged(() => this.render()),
+      this.hoverService.onHoveredChange(() => this.render()),
+      this.workflowDocument.linesManager.onForceUpdate(() => {
+        this.mountedLines.clear();
+        this.bumpVersion();
+        this.render();
+      })
+    ]);
+  }
+  dispose() {
+    this.mountedLines.clear();
+  }
+  render() {
+    const [, forceUpdate] = (0, import_react7.useState)({});
+    (0, import_react7.useLayoutEffect)(() => {
+      const updateLines = () => {
+        let needsUpdate = false;
+        this.lines.forEach((line) => {
+          const oldVersion = line.bezierDataVersion;
+          line.refreshBezier();
+          if (line.bezierDataVersion !== oldVersion) {
+            needsUpdate = true;
+          }
+        });
+        if (needsUpdate) {
+          forceUpdate({});
+        }
+      };
+      const rafId = requestAnimationFrame(updateLines);
+      return () => cancelAnimationFrame(rafId);
+    }, [this.lines]);
+    const lines = this.lines.map((line) => this.renderLine(line));
+    return /* @__PURE__ */ import_react7.default.createElement(import_react7.default.Fragment, null, lines);
+  }
+  // 用来绕过 memo
+  bumpVersion() {
+    this._version = this._version + 1;
+    if (this._version === Number.MAX_SAFE_INTEGER) {
+      this._version = 0;
+    }
+  }
+  lineProps(line) {
+    const { lineType } = this.workflowDocument.linesManager;
+    const selected = this.selectService.isSelected(line.id);
+    const { version: lineVersion, bezierDataVersion, color } = line;
+    const version = `${this._version}:${lineVersion}:${bezierDataVersion}:${lineType}:${color}:${selected}`;
+    return {
+      key: line.id,
+      color: line.color,
+      selected,
+      line,
+      lineType,
+      version,
+      strokePrefix: this.layerID
+    };
+  }
+  lineComponent(props) {
+    const RenderInsideLine = this.options.renderInsideLine ?? (() => /* @__PURE__ */ import_react7.default.createElement(import_react7.default.Fragment, null));
+    return /* @__PURE__ */ import_react7.default.createElement(LineRender, { ...props }, /* @__PURE__ */ import_react7.default.createElement(RenderInsideLine, { ...props }));
+  }
+  renderLine(line) {
+    const lineProps = this.lineProps(line);
+    const cache = this.mountedLines.get(line.id);
+    const isCached = cache !== void 0;
+    const { portal: cachedPortal, version: cachedVersion } = cache ?? {};
+    if (isCached && cachedVersion === lineProps.version) {
+      return cachedPortal;
+    }
+    if (!isCached) {
+      this.renderElement.appendChild(line.node);
+      line.onDispose(() => {
+        this.mountedLines.delete(line.id);
+        line.node.remove();
+      });
+    }
+    const portal = import_react_dom2.default.createPortal(this.lineComponent(lineProps), line.node);
+    this.mountedLines.set(line.id, { line, portal, version: lineProps.version });
+    return portal;
+  }
+  get renderElement() {
+    if (typeof this.options.renderElement === "function") {
+      const element = this.options.renderElement();
+      if (element) {
+        return element;
+      }
+    } else if (typeof this.options.renderElement !== "undefined") {
+      return this.options.renderElement;
+    }
+    return this.node;
+  }
+};
+LinesLayer.type = "WorkflowLinesLayer";
+__decorateClass([
+  (0, import_inversify.inject)(import_free_layout_core5.WorkflowHoverService)
+], LinesLayer.prototype, "hoverService", 2);
+__decorateClass([
+  (0, import_inversify.inject)(import_free_layout_core5.WorkflowSelectService)
+], LinesLayer.prototype, "selectService", 2);
+__decorateClass([
+  (0, import_core2.observeEntities)(import_free_layout_core5.WorkflowLineEntity)
+], LinesLayer.prototype, "lines", 2);
+__decorateClass([
+  (0, import_core2.observeEntities)(import_free_layout_core5.WorkflowPortEntity)
+], LinesLayer.prototype, "ports", 2);
+__decorateClass([
+  (0, import_core2.observeEntityDatas)(import_free_layout_core5.WorkflowNodeEntity, import_core2.TransformData)
+], LinesLayer.prototype, "trans", 2);
+__decorateClass([
+  (0, import_inversify.inject)(import_free_layout_core5.WorkflowDocument)
+], LinesLayer.prototype, "workflowDocument", 2);
+LinesLayer = __decorateClass([
+  (0, import_inversify.injectable)()
+], LinesLayer);
+
+// src/create-free-lines-plugin.ts
+var createFreeLinesPlugin = (0, import_core3.definePluginCreator)({
+  onInit: (ctx, opts) => {
+    ctx.playground.registerLayer(LinesLayer, {
+      ...opts,
+      renderElement: () => {
+        if (typeof opts.renderElement === "function") {
+          return opts.renderElement(ctx);
+        } else {
+          return opts.renderElement;
+        }
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LINE_OFFSET,
+  LinesLayer,
+  WorkflowPortRender,
+  createFreeLinesPlugin
+});
+//# sourceMappingURL=index.js.map