compasso 0.2.0 → 0.3.0

package/dist/chunk-JP4N42AY.js

@@ -0,0 +1,497 @@
+import { estimateTextWidth, clampLabel, legendBlock, xmlEscape, FONT_FAMILY, LEGEND_SWATCH_W } from './chunk-O3BT2O42.js';
+
+// src/phylo/labels.ts
+var PHYLO_TITLE_LABELS_EN = {
+  branchLength: "branch length",
+  support: "support",
+  clade: "clade",
+  tip: "tip",
+  root: "root"
+};
+var PHYLO_SVG_LABELS_EN = {
+  support: "Support value (bootstrap/posterior)",
+  scaleBar: "Scale: substitutions per site",
+  alignedTip: "Aligned tip (true position dotted)",
+  ariaLabel: {
+    cladogram: "Phylogenetic tree (cladogram)",
+    phylogram: "Phylogenetic tree (phylogram)"
+  }
+};
+
+// src/phylo/validate.ts
+var PhyloValidationError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid phylo tree: ${issues.map((i) => i.message).join("; ")}`);
+    this.name = "PhyloValidationError";
+    this.issues = issues;
+  }
+};
+function sortIssues(issues) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const issue of issues) unique.set(`${issue.code} ${issue.message}`, issue);
+  return [...unique.values()].sort(
+    (a, b) => a.code !== b.code ? a.code < b.code ? -1 : 1 : a.message < b.message ? -1 : a.message > b.message ? 1 : 0
+  );
+}
+function phyloIssues(input) {
+  if (input.nodes.length === 0 && input.edges.length === 0) return [];
+  const issues = [];
+  const push = (code, message) => {
+    issues.push({ code, message });
+  };
+  const nodeById = /* @__PURE__ */ new Map();
+  const dupNodeIds = /* @__PURE__ */ new Set();
+  for (const n of input.nodes) {
+    if (nodeById.has(n.id)) dupNodeIds.add(n.id);
+    else nodeById.set(n.id, n);
+  }
+  for (const id of [...dupNodeIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate node id ${id}`);
+  }
+  const dupEdgeIds = /* @__PURE__ */ new Set();
+  const seenEdgeIds = /* @__PURE__ */ new Set();
+  for (const e of input.edges) {
+    if (seenEdgeIds.has(e.id)) dupEdgeIds.add(e.id);
+    else seenEdgeIds.add(e.id);
+  }
+  for (const id of [...dupEdgeIds].sort((a, b) => a - b)) {
+    push("duplicate-id", `duplicate edge id ${id}`);
+  }
+  if (issues.length > 0) {
+    return sortIssues(issues);
+  }
+  if (!nodeById.has(input.rootId)) {
+    push("unknown-root", `rootId ${input.rootId} is not a declared node`);
+  }
+  const incomingByChild = /* @__PURE__ */ new Map();
+  for (const e of [...input.edges].sort((a, b) => a.id - b.id)) {
+    const knownParent = nodeById.has(e.parentId);
+    const knownChild = nodeById.has(e.childId);
+    if (!knownParent) push("unknown-endpoint", `edge ${e.id} parentId ${e.parentId} is not a declared node`);
+    if (!knownChild) push("unknown-endpoint", `edge ${e.id} childId ${e.childId} is not a declared node`);
+    if (e.length !== null && (!Number.isFinite(e.length) || e.length < 0)) {
+      push("negative-length", `edge ${e.id} has non-finite or negative length ${e.length}`);
+    }
+    if (knownParent && knownChild) {
+      const arr = incomingByChild.get(e.childId) ?? [];
+      arr.push(e.parentId);
+      incomingByChild.set(e.childId, arr);
+    }
+  }
+  const childIdsWithEdges = /* @__PURE__ */ new Set();
+  for (const e of input.edges) childIdsWithEdges.add(e.childId);
+  for (const [childId, parents] of [...incomingByChild.entries()].sort((a, b) => a[0] - b[0])) {
+    if (parents.length > 1) {
+      push("multiple-parents", `node ${childId} has ${parents.length} parents`);
+    }
+  }
+  const hasChildren = /* @__PURE__ */ new Set();
+  for (const e of input.edges) {
+    if (nodeById.has(e.parentId)) hasChildren.add(e.parentId);
+  }
+  for (const n of [...nodeById.values()].sort((a, b) => a.id - b.id)) {
+    if (n.isTip === true && hasChildren.has(n.id)) {
+      push("tip-with-children", `node ${n.id} is declared a tip but has children`);
+    } else if (n.isTip === false && !hasChildren.has(n.id)) {
+      push("tip-with-children", `node ${n.id} is declared internal but has no children`);
+    }
+  }
+  const GRAPH_BLOCKING = /* @__PURE__ */ new Set([
+    "duplicate-id",
+    "unknown-endpoint",
+    "unknown-root",
+    "multiple-parents"
+  ]);
+  if (!issues.some((i) => GRAPH_BLOCKING.has(i.code))) {
+    const childrenOf = /* @__PURE__ */ new Map();
+    for (const e of [...input.edges].sort((a, b) => a.id - b.id)) {
+      const arr = childrenOf.get(e.parentId) ?? [];
+      arr.push(e.childId);
+      childrenOf.set(e.parentId, arr);
+    }
+    const color = /* @__PURE__ */ new Map();
+    const seenCycles = /* @__PURE__ */ new Set();
+    const dfs = (start) => {
+      const stack = [{ id: start, nextChild: 0 }];
+      color.set(start, 1);
+      while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        const children = childrenOf.get(frame.id) ?? [];
+        if (frame.nextChild >= children.length) {
+          color.set(frame.id, 2);
+          stack.pop();
+          continue;
+        }
+        const child = children[frame.nextChild];
+        frame.nextChild += 1;
+        const c = color.get(child) ?? 0;
+        if (c === 1) {
+          const from = stack.findIndex((f) => f.id === child);
+          const cycle = stack.slice(from).map((f) => f.id);
+          const minIdx = cycle.indexOf(Math.min(...cycle));
+          const rotated = [...cycle.slice(minIdx), ...cycle.slice(0, minIdx)];
+          const key = rotated.join(">");
+          if (!seenCycles.has(key)) {
+            seenCycles.add(key);
+            push("cycle", `cycle: ${[...rotated, rotated[0]].join(" \u2192 ")}`);
+          }
+        } else if (c === 0) {
+          color.set(child, 1);
+          stack.push({ id: child, nextChild: 0 });
+        }
+      }
+    };
+    for (const n of [...nodeById.values()].sort((a, b) => a.id - b.id)) {
+      if ((color.get(n.id) ?? 0) === 0) dfs(n.id);
+    }
+    const reachable = /* @__PURE__ */ new Set();
+    const queue = [input.rootId];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      for (const childId of childrenOf.get(id) ?? []) queue.push(childId);
+    }
+    for (const n of [...nodeById.values()].sort((a, b) => a.id - b.id)) {
+      if (!reachable.has(n.id)) push("disconnected-node", `node ${n.id} is unreachable from the root`);
+    }
+  }
+  return sortIssues(issues);
+}
+function validatePhylo(input) {
+  const issues = phyloIssues(input);
+  if (issues.length > 0) throw new PhyloValidationError(issues);
+}
+
+// src/phylo/layout.ts
+var PHYLO_LABEL_FONT = 12;
+var PHYLO_ROW_SLOT = 22;
+var PHYLO_SUPPORT_FONT = 10;
+var PHYLO_LABEL_GAP = 8;
+var PADDING = 32;
+var PHYLO_LEVEL_W = 72;
+var PHYLO_TIP_R = 2.5;
+var SUPPORT_GAP = 4;
+var SCALEBAR_ZONE = 34;
+var MIN_DRAW_W = PHYLO_LEVEL_W;
+var PHYLO_ZERO_NUDGE = 1;
+var PHYLO_CLADEBAR_ID_BASE = 1e6;
+var PHYLO_BRANCH_ID_BASE = 2e6;
+var PHYLO_EXTENSION_ID_BASE = 3e6;
+var PHYLO_ROOTSTUB_ID_BASE = 4e6;
+var PHYLO_SCALEBAR_ID = 5e6;
+var round = (n) => Math.round(n * 100) / 100;
+function niceScaleStep(maxLen) {
+  if (!(maxLen > 0)) return 0;
+  const target = maxLen / 4;
+  const exp = Math.floor(Math.log10(target));
+  const pow = Math.pow(10, exp);
+  const tol = target * 1e-9;
+  for (const mult of [5, 2, 1]) {
+    const step = mult * pow;
+    if (step <= target + tol) return step;
+  }
+  return 5 * Math.pow(10, exp - 1);
+}
+function trimNumber(n) {
+  if (Number.isInteger(n)) return String(n);
+  return String(Number(n.toPrecision(6))).replace(/0+$/, "").replace(/\.$/, "");
+}
+function nodeTitle(node, isTip, isRoot, inLength, labels) {
+  if (node.title !== void 0) return node.title;
+  const role = isRoot ? labels.root : isTip ? labels.tip : labels.clade;
+  const head = node.label === "" ? role : node.label;
+  const parts = [head];
+  if (inLength !== null) parts.push(`${labels.branchLength}: ${trimNumber(inLength)}`);
+  if (!isTip && node.support !== void 0 && node.support !== null) {
+    parts.push(`${labels.support}: ${trimNumber(node.support)}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function computePhyloLayout(input, opts = {}) {
+  const mode = opts.mode ?? "cladogram";
+  if (input.nodes.length === 0 && input.edges.length === 0) {
+    return { width: PADDING * 2, height: PADDING * 2, mode, nodes: [], elements: [], scaleBar: null, showSupport: false };
+  }
+  validatePhylo(input);
+  const titleLabels = opts.titleLabels ?? PHYLO_TITLE_LABELS_EN;
+  const alignTips = opts.alignTips ?? mode === "cladogram";
+  const showSupport = opts.showSupport ?? false;
+  const wantScaleBar = (opts.scaleBar ?? true) && mode === "phylogram";
+  const nodeById = new Map(input.nodes.map((n) => [n.id, n]));
+  const childrenOf = /* @__PURE__ */ new Map();
+  const inLengthByChild = /* @__PURE__ */ new Map();
+  for (const e of [...input.edges].sort((a, b) => a.id - b.id)) {
+    (childrenOf.get(e.parentId) ?? childrenOf.set(e.parentId, []).get(e.parentId)).push(e.childId);
+    inLengthByChild.set(e.childId, e.length);
+  }
+  const allWork = [];
+  const build = (nodeId, depth, dist) => {
+    const node = nodeById.get(nodeId);
+    const inLength = inLengthByChild.get(nodeId) ?? null;
+    const work = { node, children: [], depth, dist, inLength, cx: 0, cy: 0 };
+    allWork.push(work);
+    for (const childId of childrenOf.get(nodeId) ?? []) {
+      const childLen = inLengthByChild.get(childId);
+      const add = childLen === null || childLen === void 0 ? 0 : Math.max(0, childLen);
+      work.children.push(build(childId, depth + 1, dist + add));
+    }
+    return work;
+  };
+  const root = build(input.rootId, 0, 0);
+  const isTip = (w) => w.children.length === 0;
+  const top = PADDING;
+  let tipIndex = 0;
+  const assignY = (w) => {
+    if (isTip(w)) {
+      w.cy = top + tipIndex * PHYLO_ROW_SLOT + PHYLO_ROW_SLOT / 2;
+      tipIndex += 1;
+      return;
+    }
+    for (const c of w.children) assignY(c);
+    const ys = w.children.map((c) => c.cy);
+    w.cy = (Math.min(...ys) + Math.max(...ys)) / 2;
+  };
+  assignY(root);
+  const tipCount = tipIndex;
+  const maxDepth = allWork.reduce((m, w) => Math.max(m, w.depth), 0);
+  const maxDist = allWork.reduce((m, w) => Math.max(m, w.dist), 0);
+  const supportNodes = allWork.filter(
+    (w) => !isTip(w) && w.node.support !== void 0 && w.node.support !== null
+  );
+  const effectiveShowSupport = showSupport && supportNodes.length > 0;
+  const supportMargin = effectiveShowSupport ? supportNodes.reduce(
+    (m, w) => Math.max(m, estimateTextWidth(trimNumber(w.node.support), PHYLO_SUPPORT_FONT)),
+    0
+  ) + SUPPORT_GAP : 0;
+  const padLeft = PADDING + supportMargin;
+  const tipLabelW = allWork.filter(isTip).reduce((m, w) => Math.max(m, estimateTextWidth(clampLabel(w.node.label, opts.maxLabelChars), PHYLO_LABEL_FONT)), 0);
+  const labelReserve = (tipCount > 0 ? PHYLO_LABEL_GAP + tipLabelW : 0) + PADDING;
+  const phylogramScaled = mode === "phylogram" && maxDist > 0;
+  const drawW = Math.max(MIN_DRAW_W, maxDepth * PHYLO_LEVEL_W);
+  const scale = phylogramScaled ? drawW / maxDist : 0;
+  const xOf = (w) => {
+    if (phylogramScaled) return padLeft + w.dist * scale;
+    return padLeft + w.depth * PHYLO_LEVEL_W;
+  };
+  for (const w of allWork) w.cx = xOf(w);
+  if (phylogramScaled) {
+    const nudge = (w) => {
+      for (const c of w.children) {
+        if (!isTip(c) && c.cx <= w.cx + 1e-6) c.cx = w.cx + PHYLO_ZERO_NUDGE;
+        nudge(c);
+      }
+    };
+    nudge(root);
+  }
+  const tipsAligned = alignTips;
+  const maxTipX = allWork.filter(isTip).reduce((m, w) => Math.max(m, w.cx), padLeft);
+  const alignX = phylogramScaled ? maxTipX : padLeft + maxDepth * PHYLO_LEVEL_W;
+  const tipDrawX = (w) => tipsAligned ? alignX : w.cx;
+  const rightmost = tipsAligned ? alignX : allWork.reduce((m, w) => Math.max(m, w.cx), padLeft);
+  const treeBottom = top + (tipCount > 0 ? tipCount * PHYLO_ROW_SLOT : PHYLO_ROW_SLOT);
+  const scaleBarPx = wantScaleBar && maxDist > 0 ? niceScaleStep(maxDist) * scale : 0;
+  const hasScaleBar = wantScaleBar && maxDist > 0 && scaleBarPx > 0;
+  const width = Math.ceil(rightmost + labelReserve);
+  const height = Math.ceil(treeBottom + (hasScaleBar ? SCALEBAR_ZONE : 0) + PADDING / 2);
+  const nodes = [];
+  const elements = [];
+  const branchTitle = (w) => {
+    if (w.inLength !== null) return `${titleLabels.branchLength}: ${trimNumber(w.inLength)}`;
+    return titleLabels.branchLength;
+  };
+  const ROOT_STUB = 14;
+  const rootDrawX = isTip(root) ? tipDrawX(root) : root.cx;
+  elements.push({
+    edgeId: PHYLO_ROOTSTUB_ID_BASE + root.node.id,
+    kind: "root-stub",
+    points: [
+      { x: round(Math.max(PADDING / 2, rootDrawX - ROOT_STUB)), y: round(root.cy) },
+      { x: round(rootDrawX), y: round(root.cy) }
+    ],
+    dotted: false,
+    length: null,
+    title: titleLabels.root
+  });
+  const emit = (w) => {
+    const tip = isTip(w);
+    const isRoot = w === root;
+    const drawX = tip ? tipDrawX(w) : w.cx;
+    const support = w.node.support === void 0 ? null : w.node.support;
+    const labelLine = tip && w.node.label !== "" ? [clampLabel(w.node.label, opts.maxLabelChars)] : [];
+    nodes.push({
+      nodeId: w.node.id,
+      isTip: tip,
+      cx: round(drawX),
+      cy: round(w.cy),
+      support,
+      labelLines: labelLine,
+      labelLeft: round(drawX + PHYLO_TIP_R + PHYLO_LABEL_GAP),
+      depth: w.depth,
+      title: nodeTitle(w.node, tip, isRoot, w.inLength, titleLabels)
+    });
+    if (tip && tipsAligned && w.cx < alignX - 1e-6) {
+      elements.push({
+        edgeId: PHYLO_EXTENSION_ID_BASE + w.node.id,
+        kind: "extension",
+        points: [
+          { x: round(w.cx), y: round(w.cy) },
+          { x: round(alignX), y: round(w.cy) }
+        ],
+        dotted: true,
+        length: null,
+        title: titleLabels.tip
+      });
+    }
+    if (w.children.length === 0) return;
+    const childYs = w.children.map((c) => c.cy);
+    const barTop = Math.min(...childYs);
+    const barBottom = Math.max(...childYs);
+    if (barBottom - barTop > 1e-6) {
+      elements.push({
+        edgeId: PHYLO_CLADEBAR_ID_BASE + w.node.id,
+        kind: "clade-bar",
+        points: [
+          { x: round(w.cx), y: round(barTop) },
+          { x: round(w.cx), y: round(barBottom) }
+        ],
+        dotted: false,
+        length: null,
+        title: isRoot ? titleLabels.root : titleLabels.clade
+      });
+    }
+    for (const c of w.children) {
+      elements.push({
+        edgeId: PHYLO_BRANCH_ID_BASE + c.node.id,
+        kind: "branch",
+        points: [
+          { x: round(w.cx), y: round(c.cy) },
+          { x: round(c.cx), y: round(c.cy) }
+        ],
+        dotted: false,
+        length: c.inLength,
+        title: branchTitle(c)
+      });
+    }
+    for (const c of w.children) emit(c);
+  };
+  emit(root);
+  let scaleBar = null;
+  if (hasScaleBar) {
+    const stepLen = niceScaleStep(maxDist);
+    const barX = padLeft;
+    const barY = treeBottom + SCALEBAR_ZONE / 2;
+    scaleBar = {
+      length: stepLen,
+      x: round(barX),
+      y: round(barY),
+      pxLength: round(scaleBarPx),
+      valueLabel: trimNumber(stepLen)
+    };
+    elements.push({
+      edgeId: PHYLO_SCALEBAR_ID,
+      kind: "scale-bar",
+      points: [
+        { x: round(barX), y: round(barY) },
+        { x: round(barX + scaleBarPx), y: round(barY) }
+      ],
+      dotted: false,
+      length: stepLen,
+      title: `${titleLabels.branchLength}: ${trimNumber(stepLen)}`
+    });
+  }
+  return { width, height, mode, nodes, elements, scaleBar, showSupport: effectiveShowSupport };
+}
+
+// src/phylo/svg.ts
+var GLYPH_STROKE = "#52525b";
+var LABEL_FILL = "#3f3f46";
+var EDGE_INK = "#71717a";
+var round2 = (n) => Math.round(n * 100) / 100;
+function nodeSvg(n, showSupport) {
+  const pieces = [`<title>${xmlEscape(n.title)}</title>`];
+  pieces.push(`<circle cx="${n.cx}" cy="${n.cy}" r="2.5" fill="${GLYPH_STROKE}"/>`);
+  if (n.labelLines.length > 0) {
+    pieces.push(
+      `<text x="${n.labelLeft}" y="${round2(n.cy + PHYLO_LABEL_FONT * 0.32)}" font-family="${FONT_FAMILY}" font-size="${PHYLO_LABEL_FONT}" fill="${LABEL_FILL}">${xmlEscape(n.labelLines[0])}</text>`
+    );
+  }
+  if (showSupport && !n.isTip && n.support !== null) {
+    pieces.push(
+      `<text x="${round2(n.cx - 4)}" y="${round2(n.cy - 3)}" text-anchor="end" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL}">${xmlEscape(String(n.support))}</text>`
+    );
+  }
+  return `<g data-node-id="n${n.nodeId}">${pieces.join("")}</g>`;
+}
+function elementSvg(el) {
+  const a = el.points[0];
+  const b = el.points[1];
+  const dash = el.dotted ? ` stroke-dasharray="2,3"` : "";
+  const opacity = el.kind === "extension" ? "0.5" : "0.75";
+  return `<g data-edge-id="${el.edgeId}"><title>${xmlEscape(el.title)}</title><line x1="${a.x}" y1="${a.y}" x2="${b.x}" y2="${b.y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="${opacity}"${dash}/></g>`;
+}
+function scaleBarLabelSvg(layout) {
+  const bar = layout.scaleBar;
+  if (bar === null) return "";
+  const tick = (x) => `<line x1="${x}" y1="${round2(bar.y - 3)}" x2="${x}" y2="${round2(bar.y + 3)}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+  return tick(bar.x) + tick(round2(bar.x + bar.pxLength)) + `<text x="${round2(bar.x + bar.pxLength / 2)}" y="${round2(bar.y - 6)}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL}">${xmlEscape(bar.valueLabel)}</text>`;
+}
+function supportSwatch(x, y) {
+  const cx = round2(x + LEGEND_SWATCH_W / 2);
+  return `<circle cx="${cx}" cy="${y}" r="2.5" fill="${GLYPH_STROKE}"/><text x="${round2(cx + 5)}" y="${round2(y + PHYLO_SUPPORT_FONT * 0.32)}" font-family="${FONT_FAMILY}" font-size="${PHYLO_SUPPORT_FONT}" fill="${LABEL_FILL}">95</text>`;
+}
+function scaleSwatch(x, y) {
+  return `<line x1="${round2(x)}" y1="${y}" x2="${round2(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.75"/>`;
+}
+function alignedTipSwatch(x, y) {
+  return `<line x1="${round2(x)}" y1="${y}" x2="${round2(x + LEGEND_SWATCH_W)}" y2="${y}" stroke="${EDGE_INK}" stroke-width="1.5" stroke-opacity="0.5" stroke-dasharray="2,3"/>`;
+}
+function phyloLayoutSvg(layout, opts = {}) {
+  const labels = opts.labels ?? PHYLO_SVG_LABELS_EN;
+  const showSupport = layout.showSupport;
+  const parts = [];
+  for (const el of layout.elements) parts.push(elementSvg(el));
+  parts.push(scaleBarLabelSvg(layout));
+  for (const n of layout.nodes) parts.push(nodeSvg(n, showSupport));
+  let width = layout.width;
+  let height = layout.height;
+  if (opts.legend !== false && layout.nodes.length > 0) {
+    const entries = [];
+    if (showSupport) entries.push({ swatch: supportSwatch, label: labels.support });
+    if (layout.scaleBar !== null) entries.push({ swatch: scaleSwatch, label: labels.scaleBar });
+    if (layout.elements.some((e) => e.kind === "extension")) {
+      entries.push({ swatch: alignedTipSwatch, label: labels.alignedTip });
+    }
+    const block = legendBlock(entries, layout.height);
+    if (block.svg !== "") {
+      parts.push(block.svg);
+      width = Math.max(width, block.width);
+      height = block.height;
+    }
+  }
+  const w = Math.ceil(width);
+  const h = Math.ceil(height);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${w} ${h}" width="${w}" height="${h}" role="img" aria-label="${xmlEscape(labels.ariaLabel[layout.mode])}">` + parts.join("") + `</svg>`;
+}
+
+// src/phylo/render.ts
+function phyloSvg(input, opts = {}) {
+  const layout = computePhyloLayout(input, {
+    ...opts.mode !== void 0 ? { mode: opts.mode } : {},
+    ...opts.alignTips !== void 0 ? { alignTips: opts.alignTips } : {},
+    ...opts.showSupport !== void 0 ? { showSupport: opts.showSupport } : {},
+    ...opts.scaleBar !== void 0 ? { scaleBar: opts.scaleBar } : {},
+    ...opts.maxLabelChars !== void 0 ? { maxLabelChars: opts.maxLabelChars } : {},
+    ...opts.titleLabels !== void 0 ? { titleLabels: opts.titleLabels } : {}
+  });
+  const svg = phyloLayoutSvg(layout, {
+    ...opts.legend === false ? { legend: false } : {},
+    ...opts.svgLabels !== void 0 ? { labels: opts.svgLabels } : {}
+  });
+  return { svg, layout };
+}
+
+export { PHYLO_BRANCH_ID_BASE, PHYLO_CLADEBAR_ID_BASE, PHYLO_EXTENSION_ID_BASE, PHYLO_LABEL_FONT, PHYLO_LABEL_GAP, PHYLO_ROOTSTUB_ID_BASE, PHYLO_ROW_SLOT, PHYLO_SCALEBAR_ID, PHYLO_SUPPORT_FONT, PHYLO_SVG_LABELS_EN, PHYLO_TITLE_LABELS_EN, PhyloValidationError, computePhyloLayout, niceScaleStep, phyloIssues, phyloLayoutSvg, phyloSvg, validatePhylo };
+//# sourceMappingURL=chunk-JP4N42AY.js.map
+//# sourceMappingURL=chunk-JP4N42AY.js.map