@diagrammo/dgmo 0.52.0 → 0.54.0

package/dist/chunk-EQOMY4PY.js

@@ -0,0 +1,404 @@
+import {
+  formatLocalISODate
+} from "./chunk-3TYUXC7D.js";
+import {
+  isTagBlockHeading,
+  matchTagBlockHeading
+} from "./chunk-AHTTKERF.js";
+import {
+  makeDgmoError
+} from "./chunk-4W2PE66Q.js";
+
+// src/pert/share-normalize.ts
+var START_DATE_NOW_RE = /^(\s*start-date\s+)now(\s*)$/i;
+function splitTrailingComment(line) {
+  const m = line.match(/^(.*?)(\s+#.*)$/);
+  if (!m) return { code: line, comment: "" };
+  return { code: m[1], comment: m[2] };
+}
+function normalizePertSourceForShare(dsl) {
+  const today = formatLocalISODate(/* @__PURE__ */ new Date());
+  const lines = dsl.split("\n");
+  const out = [];
+  for (const line of lines) {
+    const { code, comment } = splitTrailingComment(line);
+    const m = code.match(START_DATE_NOW_RE);
+    if (m) {
+      out.push(`${m[1]}${today}${m[2]}${comment}`);
+    } else {
+      out.push(line);
+    }
+  }
+  return out.join("\n");
+}
+
+// src/org/resolver.ts
+var MAX_DEPTH = 10;
+var IMPORT_RE = /^(\s+)import:?\s+(.+\.dgmo)\s*$/i;
+var TAGS_RE = /^tags:?\s+(.+\.dgmo)\s*$/i;
+var HEADER_RE = /^(org|kanban|title\s*:)/i;
+var KNOWN_HEADER_OPTIONS = /* @__PURE__ */ new Set([
+  "direction-tb",
+  "direction-lr",
+  "sub-node-label",
+  "hide",
+  "show-sub-node-count",
+  "color-off",
+  "fill-tint",
+  "fill-solid",
+  "fill-outline",
+  "active-tag"
+]);
+function dirname(filePath) {
+  const last = filePath.lastIndexOf("/");
+  return last > 0 ? filePath.substring(0, last) : "/";
+}
+function resolvePath(base, relative) {
+  const parts = dirname(base).split("/");
+  for (const seg of relative.split("/")) {
+    if (seg === "..") {
+      if (parts.length > 1) parts.pop();
+    } else if (seg !== "." && seg !== "") {
+      parts.push(seg);
+    }
+  }
+  return parts.join("/") || "/";
+}
+function extractTagGroups(lines) {
+  const blocks = [];
+  let current = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const headingMatch = matchTagBlockHeading(trimmed);
+    if (headingMatch) {
+      const name = headingMatch.name.toLowerCase();
+      current = { name, lines: [line] };
+      blocks.push(current);
+    } else if (current) {
+      if (trimmed === "" || trimmed.startsWith("//")) {
+        current = null;
+      } else if (line.match(/^\s+/)) {
+        current.lines.push(line);
+      } else {
+        current = null;
+      }
+    }
+  }
+  return blocks;
+}
+function parseFileHeader(lines) {
+  const tagGroups = extractTagGroups(lines);
+  const tagGroupLineSet = /* @__PURE__ */ new Set();
+  for (const group of tagGroups) {
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] === group.lines[0]) {
+        for (let j = 0; j < group.lines.length; j++) {
+          tagGroupLineSet.add(i + j);
+        }
+        break;
+      }
+    }
+  }
+  let tagsDirective = null;
+  const contentLines = [];
+  const contentLineIndices = [];
+  let headerDone = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (tagGroupLineSet.has(i)) continue;
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (!headerDone && (trimmed === "" || trimmed.startsWith("//"))) continue;
+    if (!headerDone) {
+      if (HEADER_RE.test(trimmed)) continue;
+      const tagsMatch = trimmed.match(TAGS_RE);
+      if (tagsMatch) {
+        tagsDirective = tagsMatch[1].trim();
+        continue;
+      }
+      if (!rawLine.match(/^\s/) && !isTagBlockHeading(trimmed) && !trimmed.includes("|")) {
+        const firstToken = trimmed.split(/\s/)[0].toLowerCase();
+        if (KNOWN_HEADER_OPTIONS.has(firstToken)) {
+          continue;
+        }
+      }
+      headerDone = true;
+    }
+    contentLines.push(rawLine);
+    contentLineIndices.push(i);
+  }
+  return { contentLines, contentLineIndices, tagGroups, tagsDirective };
+}
+async function resolveOrgImports(content, filePath, readFileFn) {
+  const diagnostics = [];
+  const result = await resolveFile(
+    content,
+    filePath,
+    readFileFn,
+    diagnostics,
+    /* @__PURE__ */ new Set([filePath]),
+    0
+  );
+  return {
+    content: result.content,
+    diagnostics,
+    lineMap: result.lineMap,
+    importSourceMap: result.importSourceMap
+  };
+}
+async function resolveFile(content, filePath, readFileFn, diagnostics, ancestorChain, depth) {
+  const lines = content.split("\n");
+  const headerLines = [];
+  let tagsDirective = null;
+  const inlineTagGroups = extractTagGroups(lines);
+  const bodyStartIndex = findBodyStart(lines);
+  let tagsLineNumber = 0;
+  for (let i = 0; i < bodyStartIndex; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (trimmed === "" || trimmed.startsWith("//")) {
+      headerLines.push({ text: rawLine, originalLine: i + 1 });
+      continue;
+    }
+    if (isTagBlockHeading(trimmed)) continue;
+    if (/^\s/.test(rawLine)) continue;
+    const tagsMatch = trimmed.match(TAGS_RE);
+    if (tagsMatch) {
+      tagsDirective = tagsMatch[1].trim();
+      tagsLineNumber = i + 1;
+      continue;
+    }
+    headerLines.push({ text: rawLine, originalLine: i + 1 });
+  }
+  let tagsFileGroups = [];
+  if (tagsDirective) {
+    const tagsPath = resolvePath(filePath, tagsDirective);
+    try {
+      const tagsContent = await readFileFn(tagsPath);
+      const tagsLines = tagsContent.split("\n");
+      tagsFileGroups = extractTagGroups(tagsLines);
+    } catch {
+      diagnostics.push(
+        makeDgmoError(tagsLineNumber, `Tags file not found: ${tagsDirective}`)
+      );
+    }
+  }
+  const bodyLines = lines.slice(bodyStartIndex);
+  const resolvedBodyLines = [];
+  const importedTagGroups = [];
+  for (let i = 0; i < bodyLines.length; i++) {
+    const line = bodyLines[i];
+    const lineNumber = bodyStartIndex + i + 1;
+    const importMatch = line.match(IMPORT_RE);
+    if (!importMatch) {
+      const trimmed = line.trim();
+      if (isTagBlockHeading(trimmed) || inlineTagGroups.length > 0 && isTagGroupEntry(line, bodyLines, i)) {
+        continue;
+      }
+      resolvedBodyLines.push({
+        text: line,
+        originalLine: lineNumber,
+        importSource: null
+      });
+      continue;
+    }
+    const indent = importMatch[1];
+    const importRelPath = importMatch[2].trim();
+    const importAbsPath = resolvePath(filePath, importRelPath);
+    if (depth >= MAX_DEPTH) {
+      diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Import depth limit exceeded (${MAX_DEPTH}): ${importRelPath}`
+        )
+      );
+      continue;
+    }
+    if (ancestorChain.has(importAbsPath)) {
+      const chain = [...ancestorChain, importAbsPath].map((p) => p.split("/").pop()).join(" -> ");
+      diagnostics.push(
+        makeDgmoError(lineNumber, `Circular import detected: ${chain}`)
+      );
+      continue;
+    }
+    let importedContent;
+    try {
+      importedContent = await readFileFn(importAbsPath);
+    } catch {
+      diagnostics.push(
+        makeDgmoError(lineNumber, `Import file not found: ${importRelPath}`)
+      );
+      continue;
+    }
+    const nestedChain = new Set(ancestorChain);
+    nestedChain.add(importAbsPath);
+    const resolved = await resolveFile(
+      importedContent,
+      importAbsPath,
+      readFileFn,
+      diagnostics,
+      nestedChain,
+      depth + 1
+    );
+    const resolvedLines = resolved.content.split("\n");
+    const parsed = parseFileHeader(resolvedLines);
+    for (const group of parsed.tagGroups) {
+      importedTagGroups.push(group);
+    }
+    const importedContentLines = [];
+    for (let j = 0; j < parsed.contentLines.length; j++) {
+      const cText = parsed.contentLines[j];
+      const cIndex = parsed.contentLineIndices[j];
+      if (cText.trim() !== "") {
+        importedContentLines.push({
+          text: cText,
+          index: cIndex
+        });
+      }
+    }
+    let lastNonEmpty = importedContentLines.length - 1;
+    while (lastNonEmpty >= 0 && importedContentLines[lastNonEmpty].text.trim() === "") {
+      lastNonEmpty--;
+    }
+    const trimmedImported = importedContentLines.slice(0, lastNonEmpty + 1);
+    for (const entry of trimmedImported) {
+      const resolvedLineNum = entry.index + 1;
+      let importSource = null;
+      if (resolved.importSourceMap[resolvedLineNum]) {
+        importSource = resolved.importSourceMap[resolvedLineNum];
+      } else {
+        const origLine = resolved.lineMap[resolvedLineNum];
+        if (origLine != null) {
+          importSource = { filePath: importAbsPath, sourceLine: origLine };
+        }
+      }
+      if (entry.text.trim() === "") {
+        resolvedBodyLines.push({
+          text: "",
+          originalLine: lineNumber,
+          importSource
+        });
+      } else {
+        resolvedBodyLines.push({
+          text: indent + entry.text,
+          originalLine: lineNumber,
+          importSource
+        });
+      }
+    }
+  }
+  const mergedGroups = mergeTagGroups(
+    inlineTagGroups,
+    tagsFileGroups,
+    importedTagGroups
+  );
+  const outputLines = [];
+  const lineMap = [null];
+  const importSourceMap = [null];
+  for (const entry of headerLines) {
+    outputLines.push(entry.text);
+    lineMap.push(entry.originalLine);
+    importSourceMap.push(null);
+  }
+  if (mergedGroups.length > 0) {
+    if (outputLines.length > 0 && // In-bounds by length guard.
+    outputLines[outputLines.length - 1].trim() !== "") {
+      outputLines.push("");
+      lineMap.push(null);
+      importSourceMap.push(null);
+    }
+    for (const group of mergedGroups) {
+      const inlineMatch = inlineTagGroups.find((g) => g.name === group.name);
+      for (const line of group.lines) {
+        outputLines.push(line);
+        if (inlineMatch) {
+          const srcIdx = lines.indexOf(line);
+          lineMap.push(srcIdx >= 0 ? srcIdx + 1 : null);
+        } else {
+          lineMap.push(null);
+        }
+        importSourceMap.push(null);
+      }
+      outputLines.push("");
+      lineMap.push(null);
+      importSourceMap.push(null);
+    }
+  }
+  if (resolvedBodyLines.length > 0 && outputLines.length > 0 && // In-bounds by length guard.
+  outputLines[outputLines.length - 1].trim() !== "") {
+    outputLines.push("");
+    lineMap.push(null);
+    importSourceMap.push(null);
+  }
+  for (const entry of resolvedBodyLines) {
+    outputLines.push(entry.text);
+    lineMap.push(entry.originalLine);
+    importSourceMap.push(entry.importSource);
+  }
+  return { content: outputLines.join("\n"), lineMap, importSourceMap };
+}
+function findBodyStart(lines) {
+  let inTagGroup = false;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (trimmed === "" || trimmed.startsWith("//")) {
+      if (inTagGroup) inTagGroup = false;
+      continue;
+    }
+    if (isTagBlockHeading(trimmed)) {
+      inTagGroup = true;
+      continue;
+    }
+    if (inTagGroup && rawLine.match(/^\s+/)) {
+      continue;
+    }
+    if (inTagGroup) {
+      inTagGroup = false;
+    }
+    if (HEADER_RE.test(trimmed)) continue;
+    if (TAGS_RE.test(trimmed)) continue;
+    if (!rawLine.match(/^\s/) && !trimmed.includes("|") && !isTagBlockHeading(trimmed)) {
+      const firstToken = trimmed.split(/\s/)[0].toLowerCase();
+      if (KNOWN_HEADER_OPTIONS.has(firstToken)) {
+        continue;
+      }
+    }
+    return i;
+  }
+  return lines.length;
+}
+function isTagGroupEntry(line, allLines, index) {
+  if (!line.match(/^\s+/)) return false;
+  for (let i = index - 1; i >= 0; i--) {
+    const prevRaw = allLines[i];
+    const prev = prevRaw.trim();
+    if (prev === "" || prev.startsWith("//")) continue;
+    if (isTagBlockHeading(prev)) return true;
+    if (prevRaw.match(/^\s+/)) continue;
+    return false;
+  }
+  return false;
+}
+function mergeTagGroups(inline, tagsFile, imported) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const group of inline) {
+    seen.set(group.name, group);
+  }
+  for (const group of tagsFile) {
+    if (!seen.has(group.name)) {
+      seen.set(group.name, group);
+    }
+  }
+  for (const group of imported) {
+    if (!seen.has(group.name)) {
+      seen.set(group.name, group);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+export {
+  normalizePertSourceForShare,
+  resolveOrgImports
+};
+//# sourceMappingURL=chunk-EQOMY4PY.js.map

package/dist/{chunk-USZW2HHU.js → chunk-EQW6HOP4.js}

@@ -128,9 +128,10 @@ function addGanttDuration(startDate, duration, holidays, holidaySet, direction =
   }
 }
 function parseDuration(s) {
-  const match = s.trim().match(/^(\d+(?:\.\d+)?)(min|bd|d|w|m|q|y|h|s)$/);
+  const match = s.trim().match(/^(\d+(?:\.\d+)?)(min|bd|sp|d|w|m|q|y|h|s)$/);
   if (!match) return null;
-  return { amount: parseFloat(match[1]), unit: match[2] };
+  const unit = match[2] === "sp" ? "s" : match[2];
+  return { amount: parseFloat(match[1]), unit };
 }
 function parseOffset(value) {
   const trimmed = value.trim();
@@ -194,4 +195,4 @@ export {
   parseOffsetPrefix,
   parseGanttDate
 };
-//# sourceMappingURL=chunk-USZW2HHU.js.map
+//# sourceMappingURL=chunk-EQW6HOP4.js.map

package/dist/{chunk-HBPDFCQY.js → chunk-F7XM366V.js}

@@ -1,6 +1,9 @@
 import {
   tryStripDescriptionKeyword
 } from "./chunk-IYULMRBE.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
 import {
   AUTO_TAG_COLOR_SENTINEL,
   finalizeAutoTagColors,
@@ -10,10 +13,7 @@ import {
   tagAttrKey,
   validateTagGroupNames,
   validateTagValues
-} from "./chunk-HHKO6SKY.js";
-import {
-  normalizeName
-} from "./chunk-NOTA6TEI.js";
+} from "./chunk-AHTTKERF.js";
 import {
   ALL_CHART_TYPES,
   OPTION_NOCOLON_RE,
@@ -25,13 +25,13 @@ import {
   tryParseSharedOption,
   warnUnknownMetaKeys,
   withTagAliases
-} from "./chunk-BRENJ2BQ.js";
+} from "./chunk-3FRO35WW.js";
 import {
   formatDgmoError,
   makeDgmoError,
   makeFail,
   suggest
-} from "./chunk-CXK4DZH3.js";
+} from "./chunk-4W2PE66Q.js";
 
 // src/sitemap/parser.ts
 var CONTAINER_RE = /^\[([^\]]+)\]\s*(.*)$/;
@@ -176,8 +176,9 @@ function parseSitemap(content, palette) {
       continue;
     }
     if (!contentStarted && !currentTagGroup && measureIndent(line) === 0 && !trimmed.includes("|") && !trimmed.includes("->") && !trimmed.includes(":")) {
-      if (/^direction-tb$/i.test(trimmed)) {
-        result.direction = "TB";
+      const dirBool = trimmed.match(/^direction-(lr|tb)$/i);
+      if (dirBool) {
+        result.direction = dirBool[1].toUpperCase();
         continue;
       }
       if (tryParseSharedOption(trimmed, options)) {
@@ -519,4 +520,4 @@ export {
   looksLikeSitemap,
   parseSitemap
 };
-//# sourceMappingURL=chunk-HBPDFCQY.js.map
+//# sourceMappingURL=chunk-F7XM366V.js.map

package/dist/{chunk-DYWQFQJP.js → chunk-FFVFZLRT.js}

@@ -2,7 +2,7 @@ import {
   computeQuadrantPointLabels,
   rectCircleOverlap,
   rectsOverlap
-} from "./chunk-VL2O2F3W.js";
+} from "./chunk-VHO3YBTB.js";
 import {
   EXPORT_HEIGHT,
   EXPORT_WIDTH,
@@ -11,28 +11,34 @@ import {
   initD3Chart,
   renderChartTitle,
   resolveExportPalette
-} from "./chunk-QBZYACOG.js";
+} from "./chunk-ADYKAKE3.js";
 import {
   computeLegendLayout
-} from "./chunk-YAA6IID3.js";
+} from "./chunk-J7HQPVYH.js";
 import {
   FONT_FAMILY
 } from "./chunk-6KFWC4CO.js";
+import {
+  getExtendedChartLegendGroups,
+  getSimpleChartLegendGroups,
+  parseChart,
+  parseExtendedChart
+} from "./chunk-AQEYUVGJ.js";
+import {
+  EMPHASIS_DIM_OPACITY,
+  EMPHASIS_DIM_TEXT_OPACITY,
+  resolveEmphasis
+} from "./chunk-2CW5ZTNH.js";
 import {
   LEGEND_DOT_R,
   LEGEND_ENTRY_FONT_SIZE,
   LEGEND_HEIGHT,
-  LEGEND_PILL_FONT_SIZE
-} from "./chunk-QOOUC2J5.js";
+  LEGEND_PILL_FONT_SIZE,
+  legendChromeColors
+} from "./chunk-Q5IHQ4NW.js";
 import {
   measureText
-} from "./chunk-WCT3NYCV.js";
-import {
-  getExtendedChartLegendGroups,
-  getSimpleChartLegendGroups,
-  parseChart,
-  parseExtendedChart
-} from "./chunk-EMLPOL77.js";
+} from "./chunk-4ASYQ347.js";
 import {
   contrastText,
   getSegmentColors,
@@ -42,10 +48,10 @@ import {
   mix,
   shapeFill,
   themeBaseBg
-} from "./chunk-WBM7ZNDI.js";
+} from "./chunk-JYDMBWRP.js";
 import {
   tagAttrKey
-} from "./chunk-HHKO6SKY.js";
+} from "./chunk-AHTTKERF.js";
 
 // src/utils/legend-svg.ts
 function esc(s) {
@@ -90,8 +96,7 @@ function renderLegendSvg(groups, options) {
   if (!layout.activeCapsule && layout.pills.length === 0) {
     return { svg: "", height: 0, width: 0 };
   }
-  const groupBg = isDark ? mix(palette.surface, palette.bg, 50) : mix(palette.surface, palette.bg, 30);
-  const pillBorder = mix(palette.textMuted, palette.bg, 50);
+  const { groupBg, pillBorder } = legendChromeColors(palette, isDark);
   const parts = [];
   let bottom = 0;
   let left = Infinity;
@@ -145,7 +150,9 @@ function fmtNum(n) {
 function reserveHeader(svg, chart, colors, palette, isDark, hasTitle, width) {
   return injectLegendGroups(
     svg,
-    getSimpleChartLegendGroups(chart, colors),
+    // `no-legend` (#48) → pass no groups; injectLegendGroups then returns the
+    // title-only top inset, so the legend band collapses rather than blanking.
+    chart.noLegend ? [] : getSimpleChartLegendGroups(chart, colors),
     palette,
     isDark,
     hasTitle,
@@ -1167,11 +1174,31 @@ function renderScatter(svg, chart, width, height, colors, palette, isDark, textC
 // src/charts-d3/sankey.ts
 var NODE_W = 20;
 var NODE_GAP = 14;
+var RIBBON_FILL_OPACITY = 0.6;
 function renderSankey(svg, chart, width, height, colors, bgColor, textColor, topInset) {
   const links = chart.links ?? [];
   if (links.length === 0) return;
   const solid = chart.fillMode === "solid";
   const names = Array.from(new Set(links.flatMap((l) => [l.source, l.target])));
+  const walk = (seeds, up) => {
+    const seen = new Set(seeds);
+    for (let pass = 0; pass < names.length; pass++) {
+      let grew = false;
+      for (const l of links) {
+        const from = up ? l.target : l.source;
+        const to = up ? l.source : l.target;
+        if (seen.has(from) && !seen.has(to)) {
+          seen.add(to);
+          grew = true;
+        }
+      }
+      if (!grew) break;
+    }
+    return seen;
+  };
+  const flowClosure = (seeds) => /* @__PURE__ */ new Set([...walk(seeds, true), ...walk(seeds, false)]);
+  const { dimmed } = resolveEmphasis(chart.emphasis, names, flowClosure);
+  const linkDimmed = (l) => dimmed.has(l.source) || dimmed.has(l.target);
   const node = /* @__PURE__ */ new Map();
   names.forEach(
     (name, i) => node.set(name, {
@@ -1269,7 +1296,10 @@ function renderSankey(svg, chart, width, height, colors, bgColor, textColor, top
     const ribbon = svg.append("path").attr(
       "d",
       `M${sx},${sy} C${cx0},${sy} ${cx0},${ty} ${tx},${ty} L${tx},${ty + th} C${cx0},${ty + th} ${cx0},${sy + th} ${sx},${sy + th} Z`
-    ).attr("fill", color).attr("fill-opacity", 0.6);
+    ).attr("fill", color).attr(
+      "fill-opacity",
+      linkDimmed(l) ? RIBBON_FILL_OPACITY * EMPHASIS_DIM_OPACITY : RIBBON_FILL_OPACITY
+    );
     tagDatum(ribbon, {
       line: l.lineNumber,
       // U+241F (symbol-for-unit-separator) — collision-proof AND XML-legal;
@@ -1284,7 +1314,9 @@ function renderSankey(svg, chart, width, height, colors, bgColor, textColor, top
     const nodeLine = links.find(
       (l) => l.source === n.name || l.target === n.name
     )?.lineNumber;
+    const nodeDim = dimmed.has(n.name);
     const nr = svg.append("rect").attr("x", n.x).attr("y", n.y).attr("width", NODE_W).attr("height", Math.max(1, n.h)).attr("fill", solid ? n.raw : mix(n.raw, bgColor, 75)).attr("stroke", n.raw).attr("stroke-width", 1);
+    if (nodeDim) nr.attr("opacity", EMPHASIS_DIM_OPACITY);
     tagDatum(nr, {
       ...nodeLine !== void 0 && { line: nodeLine },
       key: `node:${n.name}`,
@@ -1293,7 +1325,8 @@ function renderSankey(svg, chart, width, height, colors, bgColor, textColor, top
       color: n.raw
     });
     const lastLayer = n.rank === maxRank;
-    svg.append("text").attr("x", lastLayer ? n.x - 6 : n.x + NODE_W + 6).attr("y", n.y + n.h / 2 + 4).attr("text-anchor", lastLayer ? "end" : "start").attr("fill", textColor).attr("font-size", 13).attr("font-family", FONT_FAMILY).text(n.name);
+    const label = svg.append("text").attr("x", lastLayer ? n.x - 6 : n.x + NODE_W + 6).attr("y", n.y + n.h / 2 + 4).attr("text-anchor", lastLayer ? "end" : "start").attr("fill", textColor).attr("font-size", 13).attr("font-family", FONT_FAMILY).text(n.name);
+    if (nodeDim) label.attr("opacity", EMPHASIS_DIM_TEXT_OPACITY);
   }
 }
 
@@ -1440,7 +1473,7 @@ function renderFunction(svg, chart, width, height, colors, textColor, mutedColor
   }
   const gen = d3line2().defined((p) => isFinite(p[1]) && p[1] >= yLo - 1 && p[1] <= yHi + 1).x((p) => x(p[0])).y((p) => y(p[1]));
   for (const c of curves) {
-    const path = svg.append("path").attr("d", gen(c.pts) ?? "").attr("fill", "none").attr("stroke", c.color).attr("stroke-width", 2.5).attr("stroke-linejoin", "round");
+    const path = svg.append("path").attr("d", gen(c.pts) ?? "").attr("fill", "none").attr("stroke", c.color).attr("stroke-width", 1.75).attr("stroke-linejoin", "round").attr("data-series-name", c.name);
     tagDatum(path, { line: c.line, key: c.name, name: c.name, color: c.color });
   }
   drawXAxisTitle(
@@ -1559,7 +1592,7 @@ function renderInto(s, content, palette, isDark, width, height, textColor, muted
         );
         return true;
       case "radar": {
-        const groups = getSimpleChartLegendGroups(std, colors);
+        const groups = std.noLegend ? [] : getSimpleChartLegendGroups(std, colors);
         const top = injectLegendGroups(
           s,
           groups,
@@ -1629,7 +1662,7 @@ function renderInto(s, content, palette, isDark, width, height, textColor, muted
       );
       return true;
     case "scatter": {
-      const groups = getExtendedChartLegendGroups(ext, seriesColors);
+      const groups = ext.noLegend ? [] : getExtendedChartLegendGroups(ext, seriesColors);
       const top = injectLegendGroups(
         s,
         groups,
@@ -1678,7 +1711,7 @@ function renderInto(s, content, palette, isDark, width, height, textColor, muted
       );
       return true;
     case "function": {
-      const groups = getExtendedChartLegendGroups(ext, seriesColors);
+      const groups = ext.noLegend ? [] : getExtendedChartLegendGroups(ext, seriesColors);
       const top = injectLegendGroups(
         s,
         groups,
@@ -1711,4 +1744,4 @@ export {
   supportsD3DataChart,
   renderDataChartD3
 };
-//# sourceMappingURL=chunk-DYWQFQJP.js.map
+//# sourceMappingURL=chunk-FFVFZLRT.js.map