@yorz/cli 0.1.0

package/dist/wardleyDiagram-EHGQE667-DHR2Avlu.js

@@ -0,0 +1,976 @@
+#!/usr/bin/env node
+import { p as populateCommonDb } from "./chunk-JWPE2WC7-XiIefccF.js";
+import { s as setAccDescription, g as getAccDescription, o as getDiagramTitle, n as setDiagramTitle, a as getAccTitle, b as setAccTitle, _ as __name, E as getThemeVariables3, y as getConfig, A as cleanAndMerge, l as log, D as selectSvgElement, e as configureSvgSize, p as clear, c as getConfig2 } from "./mermaid.core-Dy_tFRs7.js";
+import { p as parse } from "./cynefin-VYW2F7L2-BwTeE-TI.js";
+var toPercent = /* @__PURE__ */ __name((value, context) => {
+  const normalized = value <= 1 ? value * 100 : value;
+  if (normalized < 0 || normalized > 100) {
+    throw new Error(
+      `${context} must be between 0-1 (decimal) or 0-100 (percentage). Received: ${value}`
+    );
+  }
+  return normalized;
+}, "toPercent");
+var toCoordinates = /* @__PURE__ */ __name((visibility, evolution, context) => {
+  return {
+    x: toPercent(evolution, `${context} evolution`),
+    y: toPercent(visibility, `${context} visibility`)
+  };
+}, "toCoordinates");
+var getFlowFromPort = /* @__PURE__ */ __name((port) => {
+  if (!port) {
+    return void 0;
+  }
+  if (port === "+<>") {
+    return "bidirectional";
+  }
+  if (port === "+<") {
+    return "backward";
+  }
+  if (port === "+>") {
+    return "forward";
+  }
+  return void 0;
+}, "getFlowFromPort");
+var extractFlowFromArrow = /* @__PURE__ */ __name((arrow) => {
+  if (!arrow?.startsWith("+")) {
+    return {};
+  }
+  const labelMatch = /^\+'([^']*)'/.exec(arrow);
+  const flowLabel = labelMatch?.[1];
+  if (arrow.includes("<>")) {
+    return { flow: "bidirectional", label: flowLabel };
+  }
+  if (arrow.includes("<")) {
+    return { flow: "backward", label: flowLabel };
+  }
+  if (arrow.includes(">")) {
+    return { flow: "forward", label: flowLabel };
+  }
+  return { label: flowLabel };
+}, "extractFlowFromArrow");
+var populateDb = /* @__PURE__ */ __name((ast, db) => {
+  populateCommonDb(ast, db);
+  if (ast.size) {
+    db.setSize(ast.size.width, ast.size.height);
+  }
+  if (ast.evolution) {
+    const stages = ast.evolution.stages.map((stage) => {
+      if (stage.secondName) {
+        return `${stage.name.trim()} / ${stage.secondName.trim()}`;
+      }
+      return stage.name.trim();
+    });
+    const stageBoundaries = ast.evolution.stages.filter((stage) => stage.boundary !== void 0).map((stage) => stage.boundary);
+    db.updateAxes({ stages, stageBoundaries });
+  }
+  ast.anchors.forEach((anchor) => {
+    const coords = toCoordinates(anchor.visibility, anchor.evolution, `Anchor "${anchor.name}"`);
+    db.addNode(anchor.name, anchor.name, coords.x, coords.y, "anchor");
+  });
+  ast.components.forEach((component) => {
+    const coords = toCoordinates(
+      component.visibility,
+      component.evolution,
+      `Component "${component.name}"`
+    );
+    const labelOffsetX = component.label ? (component.label.negX ? -1 : 1) * component.label.offsetX : void 0;
+    const labelOffsetY = component.label ? (component.label.negY ? -1 : 1) * component.label.offsetY : void 0;
+    const sourceStrategy = component.decorator?.strategy;
+    db.addNode(
+      component.name,
+      component.name,
+      coords.x,
+      coords.y,
+      "component",
+      labelOffsetX,
+      labelOffsetY,
+      component.inertia,
+      sourceStrategy
+    );
+  });
+  ast.notes.forEach((note) => {
+    const coords = toCoordinates(note.visibility, note.evolution, `Note "${note.text}"`);
+    db.addNote(note.text, coords.x, coords.y);
+  });
+  ast.pipelines.forEach((pipeline) => {
+    const parentNode = db.getNode(pipeline.parent);
+    if (!parentNode || typeof parentNode.y !== "number") {
+      throw new Error(
+        `Pipeline "${pipeline.parent}" must reference an existing component with coordinates.`
+      );
+    }
+    const parentY = parentNode.y;
+    db.startPipeline(pipeline.parent);
+    pipeline.components.forEach((component) => {
+      const componentId = `${pipeline.parent}_${component.name}`;
+      const labelOffsetX = component.label ? (component.label.negX ? -1 : 1) * component.label.offsetX : void 0;
+      const labelOffsetY = component.label ? (component.label.negY ? -1 : 1) * component.label.offsetY : void 0;
+      const x = toPercent(component.evolution, `Pipeline component "${component.name}" evolution`);
+      db.addNode(
+        componentId,
+        component.name,
+        x,
+        parentY,
+        "pipeline-component",
+        labelOffsetX,
+        labelOffsetY
+      );
+      db.addPipelineComponent(pipeline.parent, componentId);
+    });
+  });
+  ast.links.forEach((link) => {
+    const isDashed = !!link.arrow && (link.arrow.includes("-.->") || link.arrow.includes(".-."));
+    let flow = getFlowFromPort(link.fromPort) ?? getFlowFromPort(link.toPort);
+    const { flow: arrowFlow, label: flowLabel } = extractFlowFromArrow(link.arrow);
+    if (!flow && arrowFlow) {
+      flow = arrowFlow;
+    }
+    const annotation = link.linkLabel;
+    const label = flowLabel ?? annotation;
+    db.addLink(db.resolveNodeId(link.from), db.resolveNodeId(link.to), isDashed, label, flow);
+  });
+  ast.evolves.forEach((evolve) => {
+    const node = db.getNode(evolve.component);
+    if (node?.y !== void 0) {
+      const target = toPercent(evolve.target, `Evolve target for "${evolve.component}"`);
+      db.addTrend(evolve.component, target, node.y);
+    }
+  });
+  if (ast.annotations.length > 0) {
+    const annotationsBox = ast.annotations[0];
+    const coords = toCoordinates(annotationsBox.x, annotationsBox.y, "Annotations box");
+    db.setAnnotationsBox(coords.x, coords.y);
+  }
+  ast.annotation.forEach((annotation) => {
+    const coords = toCoordinates(annotation.x, annotation.y, `Annotation ${annotation.number}`);
+    db.addAnnotation(annotation.number, [{ x: coords.x, y: coords.y }], annotation.text);
+  });
+  ast.accelerators.forEach((accelerator) => {
+    const coords = toCoordinates(accelerator.x, accelerator.y, `Accelerator "${accelerator.name}"`);
+    db.addAccelerator(accelerator.name, coords.x, coords.y);
+  });
+  ast.deaccelerators.forEach((deaccelerator) => {
+    const coords = toCoordinates(
+      deaccelerator.x,
+      deaccelerator.y,
+      `Deaccelerator "${deaccelerator.name}"`
+    );
+    db.addDeaccelerator(deaccelerator.name, coords.x, coords.y);
+  });
+}, "populateDb");
+var parser = {
+  parser: {
+    // @ts-expect-error - WardleyDB is not assignable to DiagramDB
+    yy: void 0
+  },
+  parse: /* @__PURE__ */ __name(async (input) => {
+    const ast = await parse("wardley", input);
+    log.debug(ast);
+    const db = parser.parser?.yy;
+    if (!db || typeof db.addNode !== "function") {
+      throw new Error(
+        "parser.parser?.yy was not a WardleyDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues."
+      );
+    }
+    populateDb(ast, db);
+  }, "parse")
+};
+var WardleyBuilder = class {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.links = [];
+    this.trends = /* @__PURE__ */ new Map();
+    this.pipelines = /* @__PURE__ */ new Map();
+    this.annotations = [];
+    this.notes = [];
+    this.accelerators = [];
+    this.deaccelerators = [];
+    this.axes = {};
+  }
+  static {
+    __name(this, "WardleyBuilder");
+  }
+  addNode(node) {
+    const existing = this.nodes.get(node.id) ?? { id: node.id, label: node.label };
+    const merged = {
+      ...existing,
+      ...node,
+      className: node.className ?? existing.className,
+      labelOffsetX: node.labelOffsetX ?? existing.labelOffsetX,
+      labelOffsetY: node.labelOffsetY ?? existing.labelOffsetY
+    };
+    this.nodes.set(node.id, merged);
+  }
+  addLink(link) {
+    this.links.push(link);
+  }
+  addTrend(trend) {
+    this.trends.set(trend.nodeId, trend);
+  }
+  startPipeline(nodeId) {
+    this.pipelines.set(nodeId, { nodeId, componentIds: [] });
+    const node = this.nodes.get(nodeId);
+    if (node) {
+      node.isPipelineParent = true;
+    }
+  }
+  addPipelineComponent(pipelineNodeId, componentId) {
+    const pipeline = this.pipelines.get(pipelineNodeId);
+    if (pipeline) {
+      pipeline.componentIds.push(componentId);
+    }
+    const node = this.nodes.get(componentId);
+    if (node) {
+      node.inPipeline = true;
+    }
+  }
+  addAnnotation(annotation) {
+    this.annotations.push(annotation);
+  }
+  addNote(note) {
+    this.notes.push(note);
+  }
+  addAccelerator(accelerator) {
+    this.accelerators.push(accelerator);
+  }
+  addDeaccelerator(deaccelerator) {
+    this.deaccelerators.push(deaccelerator);
+  }
+  setAnnotationsBox(x, y) {
+    this.annotationsBox = { x, y };
+  }
+  setAxes(partial) {
+    this.axes = {
+      ...this.axes,
+      ...partial
+    };
+  }
+  setSize(width, height) {
+    this.size = { width, height };
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  /**
+   * Resolve a name to a node ID. Tries exact ID match first,
+   * then falls back to finding a node whose label matches the name
+   * (handles pipeline components which have synthetic IDs like "Parent_Child").
+   */
+  resolveNodeId(name) {
+    if (this.nodes.has(name)) {
+      return name;
+    }
+    for (const [id, node] of this.nodes) {
+      if (node.label === name) {
+        return id;
+      }
+    }
+    return name;
+  }
+  build() {
+    const nodes = [];
+    for (const node of this.nodes.values()) {
+      if (typeof node.x !== "number" || typeof node.y !== "number") {
+        throw new Error(`Node "${node.label}" is missing coordinates`);
+      }
+      nodes.push(node);
+    }
+    return {
+      nodes,
+      links: [...this.links],
+      trends: [...this.trends.values()],
+      pipelines: [...this.pipelines.values()],
+      annotations: [...this.annotations],
+      notes: [...this.notes],
+      accelerators: [...this.accelerators],
+      deaccelerators: [...this.deaccelerators],
+      annotationsBox: this.annotationsBox,
+      axes: { ...this.axes },
+      size: this.size
+    };
+  }
+  clear() {
+    this.nodes.clear();
+    this.links = [];
+    this.trends.clear();
+    this.pipelines.clear();
+    this.annotations = [];
+    this.notes = [];
+    this.accelerators = [];
+    this.deaccelerators = [];
+    this.annotationsBox = void 0;
+    this.axes = {};
+    this.size = void 0;
+  }
+};
+var builder = new WardleyBuilder();
+function getConfig3() {
+  return getConfig2()["wardley-beta"];
+}
+__name(getConfig3, "getConfig");
+function addNode(id, label, x, y, className, labelOffsetX, labelOffsetY, inertia, sourceStrategy) {
+  builder.addNode({
+    id,
+    label,
+    x,
+    y,
+    className,
+    labelOffsetX,
+    labelOffsetY,
+    inertia,
+    sourceStrategy
+  });
+}
+__name(addNode, "addNode");
+function addLink(sourceId, targetId, dashed = false, label, flow) {
+  builder.addLink({
+    source: sourceId,
+    target: targetId,
+    dashed,
+    label,
+    flow
+  });
+}
+__name(addLink, "addLink");
+function addTrend(nodeId, targetX, targetY) {
+  builder.addTrend({ nodeId, targetX, targetY });
+}
+__name(addTrend, "addTrend");
+function addAnnotation(number, coordinates, text) {
+  builder.addAnnotation({
+    number,
+    coordinates,
+    text
+  });
+}
+__name(addAnnotation, "addAnnotation");
+function addNote(text, x, y) {
+  builder.addNote({
+    text,
+    x,
+    y
+  });
+}
+__name(addNote, "addNote");
+function addAccelerator(name, x, y) {
+  builder.addAccelerator({
+    name,
+    x,
+    y
+  });
+}
+__name(addAccelerator, "addAccelerator");
+function addDeaccelerator(name, x, y) {
+  builder.addDeaccelerator({
+    name,
+    x,
+    y
+  });
+}
+__name(addDeaccelerator, "addDeaccelerator");
+function setAnnotationsBox(x, y) {
+  builder.setAnnotationsBox(x, y);
+}
+__name(setAnnotationsBox, "setAnnotationsBox");
+function setSize(width, height) {
+  builder.setSize(width, height);
+}
+__name(setSize, "setSize");
+function startPipeline(nodeId) {
+  builder.startPipeline(nodeId);
+}
+__name(startPipeline, "startPipeline");
+function addPipelineComponent(pipelineNodeId, componentId) {
+  builder.addPipelineComponent(pipelineNodeId, componentId);
+}
+__name(addPipelineComponent, "addPipelineComponent");
+function updateAxes(partial) {
+  builder.setAxes(partial);
+}
+__name(updateAxes, "updateAxes");
+function getNode(id) {
+  return builder.getNode(id);
+}
+__name(getNode, "getNode");
+function resolveNodeId(name) {
+  return builder.resolveNodeId(name);
+}
+__name(resolveNodeId, "resolveNodeId");
+function getWardleyData() {
+  return builder.build();
+}
+__name(getWardleyData, "getWardleyData");
+function clear2() {
+  builder.clear();
+  clear();
+}
+__name(clear2, "clear");
+var wardleyDb_default = {
+  getConfig: getConfig3,
+  addNode,
+  addLink,
+  addTrend,
+  addAnnotation,
+  addNote,
+  addAccelerator,
+  addDeaccelerator,
+  setAnnotationsBox,
+  setSize,
+  startPipeline,
+  addPipelineComponent,
+  updateAxes,
+  getNode,
+  resolveNodeId,
+  getWardleyData,
+  clear: clear2,
+  setAccTitle,
+  getAccTitle,
+  setDiagramTitle,
+  getDiagramTitle,
+  getAccDescription,
+  setAccDescription
+};
+var DEFAULT_STAGES = ["Genesis", "Custom Built", "Product", "Commodity"];
+var getTheme = /* @__PURE__ */ __name(() => {
+  const { themeVariables } = getConfig2();
+  return {
+    backgroundColor: themeVariables.wardley?.backgroundColor ?? themeVariables.background ?? "#fff",
+    axisColor: themeVariables.wardley?.axisColor ?? "#000",
+    axisTextColor: themeVariables.wardley?.axisTextColor ?? themeVariables.primaryTextColor ?? "#222",
+    gridColor: themeVariables.wardley?.gridColor ?? "rgba(100, 100, 100, 0.2)",
+    componentFill: themeVariables.wardley?.componentFill ?? "#fff",
+    componentStroke: themeVariables.wardley?.componentStroke ?? "#000",
+    componentLabelColor: themeVariables.wardley?.componentLabelColor ?? themeVariables.primaryTextColor ?? "#222",
+    linkStroke: themeVariables.wardley?.linkStroke ?? "#000",
+    evolutionStroke: themeVariables.wardley?.evolutionStroke ?? "#dc3545",
+    annotationStroke: themeVariables.wardley?.annotationStroke ?? "#000",
+    annotationTextColor: themeVariables.wardley?.annotationTextColor ?? themeVariables.primaryTextColor ?? "#222",
+    annotationFill: themeVariables.wardley?.annotationFill ?? themeVariables.background ?? "#fff"
+  };
+}, "getTheme");
+var getConfigValues = /* @__PURE__ */ __name(() => {
+  const wardleyConfig = getConfig2()["wardley-beta"];
+  return {
+    width: wardleyConfig?.width ?? 900,
+    height: wardleyConfig?.height ?? 600,
+    padding: wardleyConfig?.padding ?? 48,
+    nodeRadius: wardleyConfig?.nodeRadius ?? 6,
+    nodeLabelOffset: wardleyConfig?.nodeLabelOffset ?? 8,
+    axisFontSize: wardleyConfig?.axisFontSize ?? 12,
+    labelFontSize: wardleyConfig?.labelFontSize ?? 10,
+    showGrid: wardleyConfig?.showGrid ?? false,
+    useMaxWidth: wardleyConfig?.useMaxWidth ?? true
+  };
+}, "getConfigValues");
+var draw = /* @__PURE__ */ __name((text, id, _version, diagObj) => {
+  log.debug("Rendering Wardley map\n" + text);
+  const configValues = getConfigValues();
+  const theme = getTheme();
+  const squareSize = configValues.nodeRadius * 1.6;
+  const db = diagObj.db;
+  const data = db.getWardleyData();
+  const title = db.getDiagramTitle();
+  const width = data.size?.width ?? configValues.width;
+  const height = data.size?.height ?? configValues.height;
+  const svg = selectSvgElement(id);
+  svg.selectAll("*").remove();
+  configureSvgSize(svg, height, width, configValues.useMaxWidth);
+  svg.attr("viewBox", `0 0 ${width} ${height}`);
+  const root = svg.append("g").attr("class", "wardley-map");
+  const defs = svg.append("defs");
+  defs.append("marker").attr("id", `arrow-${id}`).attr("viewBox", "0 0 10 10").attr("refX", 9).attr("refY", 5).attr("markerWidth", 6).attr("markerHeight", 6).attr("orient", "auto-start-reverse").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("fill", theme.evolutionStroke).attr("stroke", "none");
+  defs.append("marker").attr("id", `link-arrow-end-${id}`).attr("viewBox", "0 0 10 10").attr("refX", 9).attr("refY", 5).attr("markerWidth", 5).attr("markerHeight", 5).attr("orient", "auto").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("fill", theme.linkStroke).attr("stroke", "none");
+  defs.append("marker").attr("id", `link-arrow-start-${id}`).attr("viewBox", "0 0 10 10").attr("refX", 1).attr("refY", 5).attr("markerWidth", 5).attr("markerHeight", 5).attr("orient", "auto").append("path").attr("d", "M 10 0 L 0 5 L 10 10 z").attr("fill", theme.linkStroke).attr("stroke", "none");
+  root.append("rect").attr("class", "wardley-background").attr("width", width).attr("height", height).attr("fill", theme.backgroundColor);
+  const chartWidth = width - configValues.padding * 2;
+  const chartHeight = height - configValues.padding * 2;
+  if (title) {
+    root.append("text").attr("class", "wardley-title").attr("x", width / 2).attr("y", configValues.padding / 2).attr("fill", theme.axisTextColor).attr("font-size", configValues.axisFontSize * 1.05).attr("font-weight", "bold").attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(title);
+  }
+  const projectX = /* @__PURE__ */ __name((value) => configValues.padding + value / 100 * chartWidth, "projectX");
+  const projectY = /* @__PURE__ */ __name((value) => height - configValues.padding - value / 100 * chartHeight, "projectY");
+  const axisGroup = root.append("g").attr("class", "wardley-axes");
+  axisGroup.append("line").attr("x1", configValues.padding).attr("x2", width - configValues.padding).attr("y1", height - configValues.padding).attr("y2", height - configValues.padding).attr("stroke", theme.axisColor).attr("stroke-width", 1);
+  axisGroup.append("line").attr("x1", configValues.padding).attr("x2", configValues.padding).attr("y1", configValues.padding).attr("y2", height - configValues.padding).attr("stroke", theme.axisColor).attr("stroke-width", 1);
+  const xLabel = data.axes.xLabel ?? "Evolution";
+  const yLabel = data.axes.yLabel ?? "Visibility";
+  axisGroup.append("text").attr("class", "wardley-axis-label wardley-axis-label-x").attr("x", configValues.padding + chartWidth / 2).attr("y", height - configValues.padding / 4).attr("fill", theme.axisTextColor).attr("font-size", configValues.axisFontSize).attr("font-weight", "bold").attr("text-anchor", "middle").text(xLabel);
+  axisGroup.append("text").attr("class", "wardley-axis-label wardley-axis-label-y").attr("x", configValues.padding / 3).attr("y", configValues.padding + chartHeight / 2).attr("fill", theme.axisTextColor).attr("font-size", configValues.axisFontSize).attr("font-weight", "bold").attr("text-anchor", "middle").attr(
+    "transform",
+    `rotate(-90 ${configValues.padding / 3} ${configValues.padding + chartHeight / 2})`
+  ).text(yLabel);
+  const stages = data.axes.stages && data.axes.stages.length > 0 ? data.axes.stages : DEFAULT_STAGES;
+  if (stages.length > 0) {
+    const stageGroup = root.append("g").attr("class", "wardley-stages");
+    const boundaries = data.axes.stageBoundaries;
+    const stagePositions = [];
+    if (boundaries && boundaries.length === stages.length) {
+      let prevBoundary = 0;
+      boundaries.forEach((boundary) => {
+        stagePositions.push({ start: prevBoundary, end: boundary });
+        prevBoundary = boundary;
+      });
+    } else {
+      const stageWidth = 1 / stages.length;
+      stages.forEach((_, index) => {
+        stagePositions.push({
+          start: index * stageWidth,
+          end: (index + 1) * stageWidth
+        });
+      });
+    }
+    stages.forEach((stage, index) => {
+      const pos = stagePositions[index];
+      const startX = configValues.padding + pos.start * chartWidth;
+      const endX = configValues.padding + pos.end * chartWidth;
+      const centerX = (startX + endX) / 2;
+      if (index > 0) {
+        stageGroup.append("line").attr("x1", startX).attr("x2", startX).attr("y1", configValues.padding).attr("y2", height - configValues.padding).attr("stroke", "#000").attr("stroke-width", 1).attr("stroke-dasharray", "5 5").attr("opacity", 0.8);
+      }
+      stageGroup.append("text").attr("class", "wardley-stage-label").attr("x", centerX).attr("y", height - configValues.padding / 1.5).attr("fill", theme.axisTextColor).attr("font-size", configValues.axisFontSize - 2).attr("text-anchor", "middle").text(stage);
+    });
+  }
+  if (configValues.showGrid) {
+    const gridGroup = root.append("g").attr("class", "wardley-grid");
+    for (let i = 1; i < 4; i++) {
+      const ratio = i / 4;
+      const x = configValues.padding + chartWidth * ratio;
+      gridGroup.append("line").attr("x1", x).attr("x2", x).attr("y1", configValues.padding).attr("y2", height - configValues.padding).attr("stroke", theme.gridColor).attr("stroke-dasharray", "2 6");
+      gridGroup.append("line").attr("x1", configValues.padding).attr("x2", width - configValues.padding).attr("y1", height - configValues.padding - chartHeight * ratio).attr("y2", height - configValues.padding - chartHeight * ratio).attr("stroke", theme.gridColor).attr("stroke-dasharray", "2 6");
+    }
+  }
+  const positions = /* @__PURE__ */ new Map();
+  data.nodes.forEach((node) => {
+    positions.set(node.id, {
+      x: projectX(node.x),
+      y: projectY(node.y),
+      node
+    });
+  });
+  if (data.pipelines.length > 0) {
+    const pipelineGroup = root.append("g").attr("class", "wardley-pipelines");
+    const pipelineLinksGroup = root.append("g").attr("class", "wardley-pipeline-links");
+    data.pipelines.forEach((pipeline) => {
+      if (pipeline.componentIds.length === 0) {
+        return;
+      }
+      const sortedComponents = pipeline.componentIds.map((id2) => ({ id: id2, pos: positions.get(id2), node: data.nodes.find((n) => n.id === id2) })).filter((c) => c.pos && c.node).sort((a, b) => a.node.x - b.node.x);
+      for (let i = 0; i < sortedComponents.length - 1; i++) {
+        const current = sortedComponents[i];
+        const next = sortedComponents[i + 1];
+        pipelineLinksGroup.append("line").attr("class", "wardley-pipeline-evolution-link").attr("x1", current.pos.x).attr("y1", current.pos.y).attr("x2", next.pos.x).attr("y2", next.pos.y).attr("stroke", theme.linkStroke).attr("stroke-width", 1).attr("stroke-dasharray", "4 4");
+      }
+      let minX = Infinity;
+      let maxX = -Infinity;
+      let y = 0;
+      pipeline.componentIds.forEach((componentId) => {
+        const pos = positions.get(componentId);
+        if (pos) {
+          minX = Math.min(minX, pos.x);
+          maxX = Math.max(maxX, pos.x);
+          y = pos.y;
+        }
+      });
+      if (minX !== Infinity && maxX !== -Infinity) {
+        const padding = 15;
+        const height2 = configValues.nodeRadius * 4;
+        const boxTop = y - height2 / 2;
+        const parentPos = positions.get(pipeline.nodeId);
+        if (parentPos) {
+          const centerX = (minX + maxX) / 2;
+          parentPos.x = centerX;
+          parentPos.y = boxTop - squareSize / 6;
+        }
+        pipelineGroup.append("rect").attr("class", "wardley-pipeline-box").attr("x", minX - padding).attr("y", boxTop).attr("width", maxX - minX + padding * 2).attr("height", height2).attr("fill", "none").attr("stroke", theme.axisColor).attr("stroke-width", 1.5).attr("rx", 4).attr("ry", 4);
+      }
+    });
+  }
+  const linksGroup = root.append("g").attr("class", "wardley-links");
+  const pipelineMap = /* @__PURE__ */ new Map();
+  data.pipelines.forEach((pipeline) => {
+    pipelineMap.set(pipeline.nodeId, new Set(pipeline.componentIds));
+  });
+  const validLinks = data.links.filter((link) => {
+    if (!positions.has(link.source) || !positions.has(link.target)) {
+      return false;
+    }
+    const pipelineComponents = pipelineMap.get(link.target);
+    if (pipelineComponents?.has(link.source)) {
+      return false;
+    }
+    return true;
+  });
+  linksGroup.selectAll("line").data(validLinks).enter().append("line").attr("class", (link) => `wardley-link${link.dashed ? " wardley-link--dashed" : ""}`).attr("x1", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const sourceNode = data.nodes.find((n) => n.id === link.source);
+    const radius = sourceNode.isPipelineParent ? squareSize / Math.sqrt(2) : configValues.nodeRadius;
+    const dx = targetPos.x - sourcePos.x;
+    const dy = targetPos.y - sourcePos.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    return sourcePos.x + dx / distance * radius;
+  }).attr("y1", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const sourceNode = data.nodes.find((n) => n.id === link.source);
+    const radius = sourceNode.isPipelineParent ? squareSize / Math.sqrt(2) : configValues.nodeRadius;
+    const dx = targetPos.x - sourcePos.x;
+    const dy = targetPos.y - sourcePos.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    return sourcePos.y + dy / distance * radius;
+  }).attr("x2", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const targetNode = data.nodes.find((n) => n.id === link.target);
+    const radius = targetNode.isPipelineParent ? squareSize / Math.sqrt(2) : configValues.nodeRadius;
+    const dx = sourcePos.x - targetPos.x;
+    const dy = sourcePos.y - targetPos.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    return targetPos.x + dx / distance * radius;
+  }).attr("y2", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const targetNode = data.nodes.find((n) => n.id === link.target);
+    const radius = targetNode.isPipelineParent ? squareSize / Math.sqrt(2) : configValues.nodeRadius;
+    const dx = sourcePos.x - targetPos.x;
+    const dy = sourcePos.y - targetPos.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    return targetPos.y + dy / distance * radius;
+  }).attr("stroke", theme.linkStroke).attr("stroke-width", 1).attr("stroke-dasharray", (link) => link.dashed ? "6 6" : null).attr("marker-end", (link) => {
+    if (link.flow === "forward" || link.flow === "bidirectional") {
+      return `url(#link-arrow-end-${id})`;
+    }
+    return null;
+  }).attr("marker-start", (link) => {
+    if (link.flow === "backward" || link.flow === "bidirectional") {
+      return `url(#link-arrow-start-${id})`;
+    }
+    return null;
+  });
+  linksGroup.selectAll("text").data(validLinks.filter((link) => link.label)).enter().append("text").attr("class", "wardley-link-label").attr("x", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const midX = (sourcePos.x + targetPos.x) / 2;
+    const dy = targetPos.y - sourcePos.y;
+    const dx = targetPos.x - sourcePos.x;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const offset = 8;
+    const perpX = dy / distance;
+    return midX + perpX * offset;
+  }).attr("y", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const midY = (sourcePos.y + targetPos.y) / 2;
+    const dx = targetPos.x - sourcePos.x;
+    const dy = targetPos.y - sourcePos.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const offset = 8;
+    const perpY = -dx / distance;
+    return midY + perpY * offset;
+  }).attr("fill", theme.axisTextColor).attr("font-size", configValues.labelFontSize).attr("text-anchor", "middle").attr("dominant-baseline", "middle").attr("transform", (link) => {
+    const sourcePos = positions.get(link.source);
+    const targetPos = positions.get(link.target);
+    const midX = (sourcePos.x + targetPos.x) / 2;
+    const midY = (sourcePos.y + targetPos.y) / 2;
+    const dx = targetPos.x - sourcePos.x;
+    const dy = targetPos.y - sourcePos.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const offset = 8;
+    const perpX = dy / distance;
+    const perpY = -dx / distance;
+    const labelX = midX + perpX * offset;
+    const labelY = midY + perpY * offset;
+    let angle = Math.atan2(dy, dx) * 180 / Math.PI;
+    if (angle > 90 || angle < -90) {
+      angle += 180;
+    }
+    return `rotate(${angle} ${labelX} ${labelY})`;
+  }).text((link) => link.label);
+  const trendGroup = root.append("g").attr("class", "wardley-trends");
+  const trendsWithPositions = data.trends.map((trend) => {
+    const origin = positions.get(trend.nodeId);
+    if (!origin) {
+      return null;
+    }
+    const targetX = projectX(trend.targetX);
+    const targetY = projectY(trend.targetY);
+    const dx = targetX - origin.x;
+    const dy = targetY - origin.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const shortenBy = configValues.nodeRadius + 2;
+    const adjustedX2 = distance > shortenBy ? targetX - dx / distance * shortenBy : targetX;
+    const adjustedY2 = distance > shortenBy ? targetY - dy / distance * shortenBy : targetY;
+    return {
+      origin,
+      targetX,
+      targetY,
+      adjustedX2,
+      adjustedY2
+    };
+  }).filter((trend) => trend !== null);
+  trendGroup.selectAll("line").data(trendsWithPositions).enter().append("line").attr("class", "wardley-trend").attr("x1", (trend) => trend.origin.x).attr("y1", (trend) => trend.origin.y).attr("x2", (trend) => trend.adjustedX2).attr("y2", (trend) => trend.adjustedY2).attr("stroke", theme.evolutionStroke).attr("stroke-width", 1).attr("stroke-dasharray", "4 4").attr("marker-end", `url(#arrow-${id})`);
+  const nodesGroup = root.append("g").attr("class", "wardley-nodes");
+  const nodeEnter = nodesGroup.selectAll("g").data(data.nodes).enter().append("g").attr(
+    "class",
+    (node) => ["wardley-node", node.className ? `wardley-node--${node.className}` : ""].filter(Boolean).join(" ")
+  );
+  nodeEnter.filter((node) => node.sourceStrategy === "outsource").append("circle").attr("class", "wardley-outsource-overlay").attr("cx", (node) => positions.get(node.id).x).attr("cy", (node) => positions.get(node.id).y).attr("r", configValues.nodeRadius * 2).attr("fill", "#666").attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  nodeEnter.filter((node) => node.sourceStrategy === "buy").append("circle").attr("class", "wardley-buy-overlay").attr("cx", (node) => positions.get(node.id).x).attr("cy", (node) => positions.get(node.id).y).attr("r", configValues.nodeRadius * 2).attr("fill", "#ccc").attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  nodeEnter.filter((node) => node.sourceStrategy === "build").append("circle").attr("class", "wardley-build-overlay").attr("cx", (node) => positions.get(node.id).x).attr("cy", (node) => positions.get(node.id).y).attr("r", configValues.nodeRadius * 2).attr("fill", "#eee").attr("stroke", "#000").attr("stroke-width", 1);
+  const marketNodes = nodeEnter.filter((node) => node.sourceStrategy === "market");
+  marketNodes.append("circle").attr("class", "wardley-market-overlay").attr("cx", (node) => positions.get(node.id).x).attr("cy", (node) => positions.get(node.id).y).attr("r", configValues.nodeRadius * 2).attr("fill", "white").attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  nodeEnter.filter(
+    (node) => !node.isPipelineParent && node.sourceStrategy !== "market" && node.className !== "anchor"
+  ).append("circle").attr("cx", (node) => positions.get(node.id).x).attr("cy", (node) => positions.get(node.id).y).attr("r", configValues.nodeRadius).attr("fill", theme.componentFill).attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  const smallCircleRadius = configValues.nodeRadius * 0.7;
+  const triangleRadius = configValues.nodeRadius * 1.2;
+  marketNodes.append("line").attr("class", "wardley-market-line").attr("x1", (node) => positions.get(node.id).x).attr("y1", (node) => positions.get(node.id).y - triangleRadius).attr("x2", (node) => positions.get(node.id).x - triangleRadius * Math.cos(Math.PI / 6)).attr("y2", (node) => positions.get(node.id).y + triangleRadius * Math.sin(Math.PI / 6)).attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  marketNodes.append("line").attr("class", "wardley-market-line").attr("x1", (node) => positions.get(node.id).x - triangleRadius * Math.cos(Math.PI / 6)).attr("y1", (node) => positions.get(node.id).y + triangleRadius * Math.sin(Math.PI / 6)).attr("x2", (node) => positions.get(node.id).x + triangleRadius * Math.cos(Math.PI / 6)).attr("y2", (node) => positions.get(node.id).y + triangleRadius * Math.sin(Math.PI / 6)).attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  marketNodes.append("line").attr("class", "wardley-market-line").attr("x1", (node) => positions.get(node.id).x + triangleRadius * Math.cos(Math.PI / 6)).attr("y1", (node) => positions.get(node.id).y + triangleRadius * Math.sin(Math.PI / 6)).attr("x2", (node) => positions.get(node.id).x).attr("y2", (node) => positions.get(node.id).y - triangleRadius).attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  marketNodes.append("circle").attr("class", "wardley-market-dot").attr("cx", (node) => positions.get(node.id).x).attr("cy", (node) => positions.get(node.id).y - triangleRadius).attr("r", smallCircleRadius).attr("fill", "white").attr("stroke", theme.componentStroke).attr("stroke-width", 2);
+  marketNodes.append("circle").attr("class", "wardley-market-dot").attr("cx", (node) => positions.get(node.id).x - triangleRadius * Math.cos(Math.PI / 6)).attr("cy", (node) => positions.get(node.id).y + triangleRadius * Math.sin(Math.PI / 6)).attr("r", smallCircleRadius).attr("fill", "white").attr("stroke", theme.componentStroke).attr("stroke-width", 2);
+  marketNodes.append("circle").attr("class", "wardley-market-dot").attr("cx", (node) => positions.get(node.id).x + triangleRadius * Math.cos(Math.PI / 6)).attr("cy", (node) => positions.get(node.id).y + triangleRadius * Math.sin(Math.PI / 6)).attr("r", smallCircleRadius).attr("fill", "white").attr("stroke", theme.componentStroke).attr("stroke-width", 2);
+  nodeEnter.filter((node) => node.isPipelineParent === true).append("rect").attr("x", (node) => positions.get(node.id).x - squareSize / 2).attr("y", (node) => positions.get(node.id).y - squareSize / 2).attr("width", squareSize).attr("height", squareSize).attr("fill", theme.componentFill).attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+  nodeEnter.filter((node) => node.inertia === true).append("line").attr("class", "wardley-inertia").attr("x1", (node) => {
+    const pos = positions.get(node.id);
+    let offset = node.isPipelineParent ? squareSize / 2 + 15 : configValues.nodeRadius + 15;
+    if (node.sourceStrategy) {
+      offset += configValues.nodeRadius + 10;
+    }
+    return pos.x + offset;
+  }).attr("y1", (node) => {
+    const pos = positions.get(node.id);
+    const lineHeight = node.isPipelineParent ? squareSize : configValues.nodeRadius * 2;
+    return pos.y - lineHeight / 2;
+  }).attr("x2", (node) => {
+    const pos = positions.get(node.id);
+    let offset = node.isPipelineParent ? squareSize / 2 + 15 : configValues.nodeRadius + 15;
+    if (node.sourceStrategy) {
+      offset += configValues.nodeRadius + 10;
+    }
+    return pos.x + offset;
+  }).attr("y2", (node) => {
+    const pos = positions.get(node.id);
+    const lineHeight = node.isPipelineParent ? squareSize : configValues.nodeRadius * 2;
+    return pos.y + lineHeight / 2;
+  }).attr("stroke", theme.componentStroke).attr("stroke-width", 6);
+  nodeEnter.append("text").attr("x", (node) => {
+    const pos = positions.get(node.id);
+    if (node.className === "anchor") {
+      return node.labelOffsetX !== void 0 ? pos.x + node.labelOffsetX : pos.x;
+    }
+    let defaultOffset = configValues.nodeLabelOffset;
+    if (node.sourceStrategy && node.labelOffsetX === void 0) {
+      defaultOffset += 10;
+    }
+    const customOffset = node.labelOffsetX ?? defaultOffset;
+    return pos.x + customOffset;
+  }).attr("y", (node) => {
+    const pos = positions.get(node.id);
+    if (node.className === "anchor") {
+      return node.labelOffsetY !== void 0 ? pos.y + node.labelOffsetY : pos.y - 3;
+    }
+    let defaultOffset = -configValues.nodeLabelOffset;
+    if (node.sourceStrategy && node.labelOffsetY === void 0) {
+      defaultOffset -= 10;
+    }
+    const customOffset = node.labelOffsetY ?? defaultOffset;
+    return pos.y + customOffset;
+  }).attr("class", "wardley-node-label").attr("fill", (node) => {
+    if (node.className === "evolved") {
+      return theme.evolutionStroke;
+    }
+    if (node.className === "anchor") {
+      return "#000";
+    }
+    return theme.componentLabelColor;
+  }).attr("font-size", configValues.labelFontSize).attr("font-weight", (node) => node.className === "anchor" ? "bold" : "normal").attr("text-anchor", (node) => node.className === "anchor" ? "middle" : "start").attr("dominant-baseline", (node) => node.className === "anchor" ? "middle" : "auto").text((node) => node.label);
+  if (data.annotations.length > 0) {
+    const annotationsGroup = root.append("g").attr("class", "wardley-annotations");
+    data.annotations.forEach((annotation) => {
+      const projectedCoords = annotation.coordinates.map((coord) => ({
+        x: projectX(coord.x),
+        y: projectY(coord.y)
+      }));
+      if (projectedCoords.length > 1) {
+        for (let i = 0; i < projectedCoords.length - 1; i++) {
+          annotationsGroup.append("line").attr("class", "wardley-annotation-line").attr("x1", projectedCoords[i].x).attr("y1", projectedCoords[i].y).attr("x2", projectedCoords[i + 1].x).attr("y2", projectedCoords[i + 1].y).attr("stroke", theme.axisColor).attr("stroke-width", 1.5).attr("stroke-dasharray", "4 4");
+        }
+      }
+      projectedCoords.forEach((coord) => {
+        const annotationNode = annotationsGroup.append("g").attr("class", "wardley-annotation");
+        annotationNode.append("circle").attr("cx", coord.x).attr("cy", coord.y).attr("r", 10).attr("fill", "white").attr("stroke", theme.axisColor).attr("stroke-width", 1.5);
+        annotationNode.append("text").attr("x", coord.x).attr("y", coord.y).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("font-size", 10).attr("fill", theme.axisTextColor).attr("font-weight", "bold").text(annotation.number);
+      });
+    });
+    if (data.annotationsBox) {
+      let boxX = projectX(data.annotationsBox.x);
+      let boxY = projectY(data.annotationsBox.y);
+      const padding = 10;
+      const lineHeight = 16;
+      const fontSize = 11;
+      const textBoxGroup = annotationsGroup.append("g").attr("class", "wardley-annotations-box");
+      const sortedAnnotations = [...data.annotations].filter((a) => a.text).sort((a, b) => a.number - b.number);
+      const textElements = [];
+      sortedAnnotations.forEach((annotation, idx) => {
+        const text2 = textBoxGroup.append("text").attr("x", boxX + padding).attr("y", boxY + padding + (idx + 1) * lineHeight).attr("font-size", fontSize).attr("fill", theme.axisTextColor).attr("text-anchor", "start").attr("dominant-baseline", "middle").text(`${annotation.number}. ${annotation.text}`);
+        textElements.push(text2);
+      });
+      if (textElements.length > 0) {
+        let maxWidth = 0;
+        let maxHeight = 0;
+        textElements.forEach((text2) => {
+          const textNode = text2.node();
+          const textWidth = textNode.getComputedTextLength();
+          maxWidth = Math.max(maxWidth, textWidth);
+          const bbox = textNode.getBBox();
+          maxHeight = Math.max(maxHeight, bbox.height);
+        });
+        const boxWidth = maxWidth + padding * 2 + 105;
+        const boxHeight = sortedAnnotations.length * lineHeight + padding * 2 + maxHeight / 2;
+        const minX = configValues.padding;
+        const maxX = width - configValues.padding - boxWidth;
+        const minY = configValues.padding;
+        const maxY = height - configValues.padding - boxHeight;
+        boxX = Math.max(minX, Math.min(boxX, maxX));
+        boxY = Math.max(minY, Math.min(boxY, maxY));
+        textElements.forEach((text2, idx) => {
+          text2.attr("x", boxX + padding).attr("y", boxY + padding + (idx + 1) * lineHeight);
+        });
+        textBoxGroup.insert("rect", "text").attr("x", boxX).attr("y", boxY).attr("width", boxWidth).attr("height", boxHeight).attr("fill", "white").attr("stroke", theme.axisColor).attr("stroke-width", 1.5).attr("rx", 4).attr("ry", 4);
+      }
+    }
+  }
+  if (data.notes.length > 0) {
+    const notesGroup = root.append("g").attr("class", "wardley-notes");
+    data.notes.forEach((note) => {
+      const noteX = projectX(note.x);
+      const noteY = projectY(note.y);
+      notesGroup.append("text").attr("x", noteX).attr("y", noteY).attr("text-anchor", "start").attr("font-size", 11).attr("fill", theme.axisTextColor).attr("font-weight", "bold").text(note.text);
+    });
+  }
+  if (data.accelerators.length > 0) {
+    const acceleratorsGroup = root.append("g").attr("class", "wardley-accelerators");
+    data.accelerators.forEach((accelerator) => {
+      const accX = projectX(accelerator.x);
+      const accY = projectY(accelerator.y);
+      const arrowWidth = 60;
+      const arrowHeight = 30;
+      const arrowHeadWidth = 20;
+      const arrowPath = `
+        M ${accX} ${accY - arrowHeight / 2}
+        L ${accX + arrowWidth - arrowHeadWidth} ${accY - arrowHeight / 2}
+        L ${accX + arrowWidth - arrowHeadWidth} ${accY - arrowHeight / 2 - 8}
+        L ${accX + arrowWidth} ${accY}
+        L ${accX + arrowWidth - arrowHeadWidth} ${accY + arrowHeight / 2 + 8}
+        L ${accX + arrowWidth - arrowHeadWidth} ${accY + arrowHeight / 2}
+        L ${accX} ${accY + arrowHeight / 2}
+        Z
+      `;
+      acceleratorsGroup.append("path").attr("d", arrowPath).attr("fill", "white").attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+      acceleratorsGroup.append("text").attr("x", accX + arrowWidth / 2).attr("y", accY + arrowHeight / 2 + 15).attr("text-anchor", "middle").attr("font-size", 10).attr("fill", theme.axisTextColor).attr("font-weight", "bold").text(accelerator.name);
+    });
+  }
+  if (data.deaccelerators.length > 0) {
+    const deacceleratorsGroup = root.append("g").attr("class", "wardley-deaccelerators");
+    data.deaccelerators.forEach((deaccelerator) => {
+      const decX = projectX(deaccelerator.x);
+      const decY = projectY(deaccelerator.y);
+      const arrowWidth = 60;
+      const arrowHeight = 30;
+      const arrowHeadWidth = 20;
+      const arrowPath = `
+        M ${decX + arrowWidth} ${decY - arrowHeight / 2}
+        L ${decX + arrowHeadWidth} ${decY - arrowHeight / 2}
+        L ${decX + arrowHeadWidth} ${decY - arrowHeight / 2 - 8}
+        L ${decX} ${decY}
+        L ${decX + arrowHeadWidth} ${decY + arrowHeight / 2 + 8}
+        L ${decX + arrowHeadWidth} ${decY + arrowHeight / 2}
+        L ${decX + arrowWidth} ${decY + arrowHeight / 2}
+        Z
+      `;
+      deacceleratorsGroup.append("path").attr("d", arrowPath).attr("fill", "white").attr("stroke", theme.componentStroke).attr("stroke-width", 1);
+      deacceleratorsGroup.append("text").attr("x", decX + arrowWidth / 2).attr("y", decY + arrowHeight / 2 + 15).attr("text-anchor", "middle").attr("font-size", 10).attr("fill", theme.axisTextColor).attr("font-weight", "bold").text(deaccelerator.name);
+    });
+  }
+}, "draw");
+var wardleyRenderer_default = {
+  draw
+};
+var styles = /* @__PURE__ */ __name(({
+  wardley
+} = {}) => {
+  const defaultThemeVariables = getThemeVariables3();
+  const currentConfig = getConfig();
+  const themeVariables = cleanAndMerge(defaultThemeVariables, currentConfig.themeVariables);
+  const w = cleanAndMerge(themeVariables.wardley, wardley);
+  return `
+  .wardley-background {
+    fill: ${w.backgroundColor};
+  }
+  .wardley-axes line, .wardley-axes path {
+    stroke: ${w.axisColor};
+  }
+  .wardley-axis-label {
+    fill: ${w.axisTextColor};
+  }
+  .wardley-stage-label {
+    fill: ${w.axisTextColor};
+  }
+  .wardley-grid line {
+    stroke: ${w.gridColor};
+  }
+  .wardley-node circle {
+    fill: ${w.componentFill};
+    stroke: ${w.componentStroke};
+  }
+  .wardley-node-label {
+    fill: ${w.componentLabelColor};
+  }
+  .wardley-link {
+    stroke: ${w.linkStroke};
+  }
+  .wardley-link--dashed {
+    stroke-dasharray: 4 4;
+  }
+  .wardley-link-label {
+    fill: ${w.axisTextColor};
+  }
+  .wardley-trend line {
+    stroke: ${w.evolutionStroke};
+  }
+  .wardley-annotation-line {
+    stroke: ${w.annotationStroke};
+  }
+  .wardley-annotation circle {
+    fill: ${w.annotationFill};
+    stroke: ${w.annotationStroke};
+  }
+  .wardley-annotation text {
+    fill: ${w.annotationTextColor};
+  }
+  .wardley-annotations-box rect {
+    fill: ${w.annotationFill};
+    stroke: ${w.annotationStroke};
+  }
+  .wardley-annotations-box text {
+    fill: ${w.annotationTextColor};
+  }
+  .wardley-pipeline-box {
+    stroke: ${w.componentStroke};
+  }
+  .wardley-notes text {
+    fill: ${w.axisTextColor};
+  }
+  `;
+}, "styles");
+var diagram = {
+  parser,
+  db: wardleyDb_default,
+  renderer: wardleyRenderer_default,
+  styles
+};
+export {
+  diagram
+};