@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-CKNVO24D.js

@@ -0,0 +1,54 @@
+import {
+  buildMapProjection
+} from "./chunk-IPWPWM6R.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+
+// src/map/dimensions.ts
+import { geoPath } from "d3-geo";
+var FIT_PAD = 24;
+var TITLE_GAP = 16;
+var ASPECT_MAX = 3;
+var ASPECT_MIN = 0.9;
+var GLOBAL_HEIGHT_BOOST = 1.12;
+var MIN_MAP_BAND = 200;
+var FALLBACK_ASPECT = 1.5;
+var REF = 1e3;
+function mapContentAspect(resolved, data, ref = REF) {
+  const { projection, fitTarget } = buildMapProjection(resolved, data);
+  projection.fitSize([ref, ref], fitTarget);
+  const b = geoPath(projection).bounds(fitTarget);
+  const w = b[1][0] - b[0][0];
+  const h = b[1][1] - b[0][1];
+  const aspect = w / h;
+  return Number.isFinite(aspect) && aspect > 0 ? aspect : FALLBACK_ASPECT;
+}
+function mapExportDimensions(resolved, data, baseWidth = 1200, aspectOverride) {
+  const useOverride = aspectOverride !== void 0 && Number.isFinite(aspectOverride) && aspectOverride > 0;
+  const raw = useOverride ? aspectOverride : mapContentAspect(resolved, data);
+  const isGlobal = !useOverride && buildMapProjection(resolved, data).fitIsGlobal;
+  const target = isGlobal ? raw / GLOBAL_HEIGHT_BOOST : raw;
+  const clamped = useOverride ? raw : Math.max(ASPECT_MIN, Math.min(ASPECT_MAX, target));
+  const width = baseWidth;
+  let height = Math.round(width / clamped);
+  let chromeReserve = 0;
+  if (resolved.title && resolved.pois.length > 0) {
+    const bannerBottom = (resolved.subtitle ? TITLE_Y + TITLE_FONT_SIZE : TITLE_Y) + TITLE_FONT_SIZE / 2;
+    chromeReserve += Math.max(FIT_PAD, bannerBottom + TITLE_GAP) - FIT_PAD;
+  }
+  let floored = false;
+  if (height - chromeReserve < MIN_MAP_BAND) {
+    height = Math.round(chromeReserve + MIN_MAP_BAND);
+    floored = true;
+  }
+  const preferContain = useOverride ? floored : clamped !== target || floored;
+  return { width, height, preferContain };
+}
+
+export {
+  mapContentAspect,
+  mapExportDimensions
+};
+//# sourceMappingURL=chunk-CKNVO24D.js.map

package/dist/chunk-CUVHQHZ7.js

@@ -0,0 +1,391 @@
+import {
+  computeNodeText,
+  layoutMindmap
+} from "./chunk-T2OE3YQB.js";
+import {
+  renderInlineText
+} from "./chunk-3HDBAXF5.js";
+import {
+  extractExportSvg,
+  runInExportContainer
+} from "./chunk-Y5QGVTVC.js";
+import {
+  COLLAPSE_BAR_HEIGHT,
+  EDGE_STROKE_WIDTH,
+  NODE_STROKE_WIDTH
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  getMaxLegendReservedHeight
+} from "./chunk-YAA6IID3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  LEGEND_GROUP_GAP
+} from "./chunk-QOOUC2J5.js";
+import {
+  parseMindmap
+} from "./chunk-EB6FPQUP.js";
+import {
+  preprocessDescriptionLine
+} from "./chunk-IYULMRBE.js";
+import {
+  contrastText,
+  shapeFill
+} from "./chunk-P6T66CCZ.js";
+import {
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+
+// src/mindmap/renderer.ts
+import * as d3Selection from "d3-selection";
+var DIAGRAM_PADDING = 20;
+var TITLE_HEIGHT = 30;
+var SINGLE_LABEL_HEIGHT = 28;
+var LABEL_LINE_HEIGHT = 18;
+var DESC_LINE_HEIGHT = 14;
+var NODE_RADIUS = 6;
+var ROOT_STROKE_WIDTH = 2.5;
+function nodeFill(palette, isDark, nodeColor, solid) {
+  const color = nodeColor ?? palette.primary;
+  return shapeFill(palette, color, isDark, {
+    ...solid !== void 0 && { solid }
+  });
+}
+function nodeStroke(palette, nodeColor) {
+  return nodeColor ?? palette.primary;
+}
+var DEPTH_COLOR_KEYS = [
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "teal",
+  "cyan"
+];
+function depthColor(depth, palette) {
+  const key = DEPTH_COLOR_KEYS[depth];
+  if (key && key in palette.colors) {
+    return palette.colors[key];
+  }
+  return palette.colors.gray;
+}
+function renderMindmap(container, parsed, layout, palette, isDark, onClickItem, exportDims, onToggleNode, hideDescriptions, activeTagGroup, options) {
+  const isExport = !!exportDims;
+  const containerWidth = exportDims?.width ?? (container.getBoundingClientRect().width || 800);
+  const containerHeight = exportDims?.height ?? (container.getBoundingClientRect().height || 600);
+  d3Selection.select(container).selectAll("*").remove();
+  const svg = d3Selection.select(container).append("svg").attr("width", containerWidth).attr("height", containerHeight).attr("viewBox", `0 0 ${containerWidth} ${containerHeight}`).attr("preserveAspectRatio", "xMidYMin meet").style("font-family", FONT_FAMILY);
+  const appHosted = options?.controlsHost === "app";
+  const hasControls = !!options?.onToggleColorByDepth || !!options?.onToggleDescriptions;
+  const hasLegend = parsed.tagGroups.length > 0 || hasControls && !appHosted;
+  const fixedLegend = !isExport && hasLegend;
+  const legendReserve = fixedLegend ? getMaxLegendReservedHeight(
+    {
+      groups: parsed.tagGroups,
+      position: { placement: "top-center", titleRelation: "below-title" },
+      mode: "preview"
+    },
+    containerWidth
+  ) + LEGEND_GROUP_GAP : 0;
+  const showTitle = !!parsed.title && parsed.options["no-title"] !== "on";
+  const fixedTitle = !isExport && showTitle;
+  const titleReserve = fixedTitle ? TITLE_HEIGHT : 0;
+  const availWidth = containerWidth;
+  const availHeight = containerHeight - DIAGRAM_PADDING * 2 - legendReserve - titleReserve;
+  let ctx = isExport ? ScaleContext.identity() : ScaleContext.fromBox(
+    availWidth,
+    layout.width,
+    availHeight,
+    layout.height
+  );
+  let renderLayout = layout;
+  if (ctx.factor < 1) {
+    const hiddenCounts = /* @__PURE__ */ new Map();
+    for (const n of layout.nodes) {
+      if (n.hiddenCount != null && n.hiddenCount > 0) {
+        hiddenCounts.set(n.id, n.hiddenCount);
+      }
+    }
+    const relayout = (c) => layoutMindmap(parsed, palette, {
+      interactive: !isExport,
+      ...hiddenCounts.size > 0 && { hiddenCounts },
+      activeTagGroup: activeTagGroup ?? null,
+      ...hideDescriptions !== void 0 && { hideDescriptions },
+      ctx: c
+    });
+    renderLayout = relayout(ctx);
+    for (let i = 0; i < 3 && !ctx.isBelowFloor; i++) {
+      const refit = Math.min(
+        availWidth / renderLayout.width,
+        availHeight / renderLayout.height
+      );
+      if (refit >= 0.999) break;
+      ctx = ScaleContext.fromFactor(ctx.factor * refit);
+      renderLayout = relayout(ctx);
+    }
+  }
+  const fitScale = isExport ? 1 : Math.min(
+    1,
+    renderLayout.width > 0 ? availWidth / renderLayout.width : 1,
+    renderLayout.height > 0 ? availHeight / renderLayout.height : 1
+  );
+  const scaledWidth = renderLayout.width * fitScale;
+  const scaledHeight = renderLayout.height * fitScale;
+  const offsetX = Math.max(0, (availWidth - scaledWidth) / 2);
+  const offsetY = DIAGRAM_PADDING + legendReserve + titleReserve + Math.max(0, (availHeight - scaledHeight) / 2);
+  const mainG = svg.append("g").attr(
+    "transform",
+    `translate(${offsetX}, ${offsetY})${fitScale < 1 ? ` scale(${fitScale})` : ""}`
+  );
+  if (ctx.isBelowFloor) {
+    svg.attr("width", "100%");
+  }
+  if (showTitle) {
+    const titleParent = fixedTitle ? svg : mainG;
+    const titleX = fixedTitle ? containerWidth / 2 : renderLayout.width / 2;
+    const titleY = fixedTitle ? DIAGRAM_PADDING + TITLE_FONT_SIZE : TITLE_FONT_SIZE;
+    const titleText = titleParent.append("text").attr("x", titleX).attr("y", titleY).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).attr("class", "chart-title").text(parsed.title);
+    if (parsed.titleLineNumber) {
+      titleText.attr("data-line-number", parsed.titleLineNumber);
+    }
+    if (onClickItem && parsed.titleLineNumber) {
+      titleText.style("cursor", "pointer").on("click", () => onClickItem(parsed.titleLineNumber));
+    }
+  }
+  if (fixedLegend) {
+    const legendG = svg.append("g").attr("class", "mindmap-legend-fixed").attr("transform", `translate(0, ${DIAGRAM_PADDING + titleReserve})`);
+    const usedValues = /* @__PURE__ */ new Map();
+    for (const node of renderLayout.nodes) {
+      for (const tg of parsed.tagGroups) {
+        const key = tg.name.toLowerCase();
+        const val = node.metadata[key];
+        if (val) {
+          if (!usedValues.has(key)) usedValues.set(key, /* @__PURE__ */ new Set());
+          usedValues.get(key).add(val.toLowerCase());
+        }
+      }
+    }
+    const toggles = [];
+    if (options?.onToggleDescriptions) {
+      toggles.push({
+        id: "descriptions",
+        type: "toggle",
+        label: "Descriptions",
+        active: !hideDescriptions,
+        onToggle: (active) => options.onToggleDescriptions(active)
+      });
+    }
+    if (options?.onToggleColorByDepth) {
+      toggles.push({
+        id: "depth-colors",
+        type: "toggle",
+        label: "Depth Colors",
+        active: options.colorByDepth ?? false,
+        onToggle: options.onToggleColorByDepth
+      });
+    }
+    const controlsToggles = toggles.length > 0 ? { toggles } : void 0;
+    const legendConfig = {
+      groups: parsed.tagGroups.map((tg) => {
+        const used = usedValues.get(tg.name.toLowerCase());
+        return {
+          name: tg.name,
+          ...tg.alias !== void 0 && { alias: tg.alias },
+          entries: tg.entries.filter((e) => used?.has(e.value.toLowerCase())).map((e) => ({ value: e.value, color: e.color }))
+        };
+      }),
+      position: { placement: "top-center", titleRelation: "below-title" },
+      mode: options?.exportMode ? "export" : "preview",
+      ...controlsToggles !== void 0 && { controlsGroup: controlsToggles },
+      ...options?.controlsHost !== void 0 && {
+        controlsHost: options.controlsHost
+      }
+    };
+    const legendPalette = {
+      text: palette.text,
+      textMuted: palette.textMuted,
+      bg: palette.bg,
+      surface: palette.surface,
+      primary: palette.primary
+    };
+    const legendCallbacks = {
+      ...options?.onToggleControlsExpand !== void 0 && {
+        onControlsExpand: options.onToggleControlsExpand
+      },
+      onControlsToggle: (id, active) => {
+        if (id === "depth-colors" && options?.onToggleColorByDepth) {
+          options.onToggleColorByDepth(active);
+        }
+        if (id === "descriptions" && options?.onToggleDescriptions) {
+          options.onToggleDescriptions(active);
+        }
+      }
+    };
+    renderIntegratedLegend(legendG, {
+      ...legendConfig,
+      palette: legendPalette,
+      isDark,
+      width: containerWidth,
+      activeGroup: options?.colorByDepth ? null : activeTagGroup !== void 0 ? activeTagGroup : parsed.options["active-tag"] ?? null,
+      hiddenAttributes: /* @__PURE__ */ new Set(),
+      ...options?.controlsExpanded !== void 0 && {
+        controlsExpanded: options.controlsExpanded
+      },
+      callbacks: legendCallbacks
+    });
+  }
+  for (const edge of renderLayout.edges) {
+    mainG.append("path").attr("class", "mindmap-edge").attr("d", edge.path).attr("fill", "none").attr("stroke", palette.textMuted).attr("stroke-width", EDGE_STROKE_WIDTH).attr("stroke-opacity", 0.5);
+  }
+  for (const node of renderLayout.nodes) {
+    const isRoot = node.radius === 0 && renderLayout.nodes.indexOf(node) === 0;
+    const strokeW = isRoot ? ROOT_STROKE_WIDTH : NODE_STROKE_WIDTH;
+    const effectiveColor = options?.colorByDepth ? depthColor(node.depth, palette) : node.color;
+    const fill = nodeFill(
+      palette,
+      isDark,
+      effectiveColor,
+      parsed.options["solid-fill"] === "on"
+    );
+    const stroke = nodeStroke(palette, effectiveColor);
+    const onFillText = contrastText(
+      fill,
+      palette.textOnFillLight,
+      palette.textOnFillDark
+    );
+    const nodeG = mainG.append("g").attr("class", "mindmap-node").attr("data-line-number", node.lineNumber);
+    if (activeTagGroup) {
+      const tagKey = tagAttrKey(activeTagGroup);
+      const metaValue = node.metadata[tagKey];
+      if (metaValue) {
+        nodeG.attr(`data-tag-${tagKey}`, metaValue.toLowerCase());
+      }
+    }
+    if (node.hasChildren) {
+      nodeG.attr("data-node-toggle", node.id).attr("tabindex", "0").attr("role", "button").attr(
+        "aria-expanded",
+        node.hiddenCount != null && node.hiddenCount > 0 ? "false" : "true"
+      ).attr("aria-label", node.label);
+    }
+    nodeG.append("rect").attr("x", node.x).attr("y", node.y).attr("width", node.width).attr("height", node.height).attr("rx", NODE_RADIUS).attr("ry", NODE_RADIUS).attr("fill", fill).attr("stroke", stroke).attr("stroke-width", strokeW);
+    const collapsed = node.hiddenCount != null && node.hiddenCount > 0;
+    const showDesc = !hideDescriptions && !!node.description && !collapsed;
+    const textLayout = computeNodeText(
+      node.label,
+      node.description,
+      node.depth,
+      node.width,
+      hideDescriptions || collapsed
+    );
+    const {
+      labelLines,
+      labelFontSize: fontSize,
+      descLines,
+      descFontSize
+    } = textLayout;
+    const labelLineCount = labelLines.length;
+    const labelZoneH = labelLineCount <= 1 ? SINGLE_LABEL_HEIGHT : LABEL_LINE_HEIGHT * labelLineCount;
+    const labelZoneHeight = showDesc ? labelZoneH : node.height;
+    const centerX = node.x + node.width / 2;
+    if (labelLineCount <= 1) {
+      const labelY = node.y + labelZoneHeight / 2 + fontSize * 0.35;
+      nodeG.append("text").attr("x", centerX).attr("y", labelY).attr("text-anchor", "middle").attr("font-size", fontSize).attr("font-weight", isRoot ? "bold" : "normal").attr("fill", onFillText).text(labelLines[0]);
+    } else {
+      const blockH = LABEL_LINE_HEIGHT * (labelLineCount - 1);
+      const firstBaselineY = node.y + labelZoneHeight / 2 - blockH / 2 + fontSize * 0.35;
+      const textEl = nodeG.append("text").attr("x", centerX).attr("text-anchor", "middle").attr("font-size", fontSize).attr("font-weight", isRoot ? "bold" : "normal").attr("fill", onFillText);
+      for (let i = 0; i < labelLines.length; i++) {
+        textEl.append("tspan").attr("x", centerX).attr("y", firstBaselineY + i * LABEL_LINE_HEIGHT).text(labelLines[i]);
+      }
+    }
+    if (labelLines.length > 1 || labelLines[0] !== node.label) {
+      nodeG.append("title").text(node.label);
+    }
+    if (showDesc && descLines.length > 0) {
+      const separatorY = node.y + labelZoneH;
+      nodeG.append("line").attr("x1", node.x).attr("y1", separatorY).attr("x2", node.x + node.width).attr("y2", separatorY).attr("stroke", stroke).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
+      if (descLines.length <= 1) {
+        const descY = separatorY + 4 + descFontSize;
+        const processed = preprocessDescriptionLine(descLines[0]);
+        const textEl = nodeG.append("text").attr("x", centerX).attr("y", descY).attr("text-anchor", "middle").attr("font-size", descFontSize).attr("fill", onFillText);
+        renderInlineText(textEl, processed, palette, descFontSize);
+      } else {
+        const descStartY = separatorY + 4 + descFontSize;
+        for (let i = 0; i < descLines.length; i++) {
+          const processed = preprocessDescriptionLine(descLines[i]);
+          const textEl = nodeG.append("text").attr("x", centerX).attr("y", descStartY + i * DESC_LINE_HEIGHT).attr("text-anchor", "middle").attr("font-size", descFontSize).attr("fill", onFillText);
+          renderInlineText(textEl, processed, palette, descFontSize);
+        }
+      }
+    }
+    if (!isExport && node.hiddenCount != null && node.hiddenCount > 0) {
+      const clipId = `collapse-clip-${node.id}`;
+      const defs = mainG.append("defs");
+      defs.append("clipPath").attr("id", clipId).append("rect").attr("x", node.x).attr("y", node.y).attr("width", node.width).attr("height", node.height).attr("rx", NODE_RADIUS).attr("ry", NODE_RADIUS);
+      nodeG.append("rect").attr("class", "collapse-bar").attr("x", node.x).attr("y", node.y + node.height - COLLAPSE_BAR_HEIGHT).attr("width", node.width).attr("height", COLLAPSE_BAR_HEIGHT).attr("fill", stroke).attr("clip-path", `url(#${clipId})`);
+    }
+    if (onClickItem) {
+      nodeG.style("cursor", "pointer").on("click", (event) => {
+        if (node.hasChildren && onToggleNode) {
+          event.stopPropagation();
+          onToggleNode(node.id);
+        } else {
+          onClickItem(node.lineNumber);
+        }
+      });
+    }
+    if (!isExport) {
+      nodeG.on("mouseenter", function() {
+        d3Selection.select(this).attr("opacity", 0.7);
+      }).on("mouseleave", function() {
+        d3Selection.select(this).attr("opacity", 1);
+      });
+    }
+  }
+}
+function renderMindmapForExport(content, theme, palette) {
+  const parsed = parseMindmap(content, palette);
+  if (parsed.error) return "";
+  const isDark = theme === "dark";
+  const hideDescriptions = parsed.options["no-descriptions"] === "true";
+  const layout = layoutMindmap(parsed, palette, {
+    interactive: false,
+    hideDescriptions
+  });
+  const titleOffset = parsed.title && parsed.options["no-title"] !== "on" ? TITLE_HEIGHT : 0;
+  const exportWidth = layout.width + DIAGRAM_PADDING * 2;
+  const exportHeight = layout.height + DIAGRAM_PADDING * 2 + titleOffset;
+  return runInExportContainer(exportWidth, exportHeight, (container) => {
+    renderMindmap(
+      container,
+      parsed,
+      layout,
+      palette,
+      isDark,
+      void 0,
+      { width: exportWidth, height: exportHeight },
+      void 0,
+      hideDescriptions
+    );
+    return extractExportSvg(container, theme);
+  });
+}
+
+export {
+  renderMindmap,
+  renderMindmapForExport
+};
+//# sourceMappingURL=chunk-CUVHQHZ7.js.map

package/dist/chunk-CXK4DZH3.js

@@ -0,0 +1,114 @@
+// src/diagnostics.ts
+function makeDgmoError(line, message, severity = "error", code) {
+  return code !== void 0 ? { line, message, severity, code } : { line, message, severity };
+}
+function emit(spec, line, params = {}, opts = {}) {
+  const message = typeof spec.message === "function" ? spec.message(params) : spec.message;
+  const err = {
+    line,
+    message,
+    severity: spec.severity,
+    code: spec.code
+  };
+  if (opts.column !== void 0) err.column = opts.column;
+  return err;
+}
+function dedupeDiagnostics(diagnostics) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const d of diagnostics) {
+    const key = `${d.line}\0${d.column ?? ""}\0${d.severity}\0${d.code ?? ""}\0${d.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(d);
+  }
+  return out;
+}
+function formatDgmoError(err) {
+  return err.line > 0 ? `Line ${err.line}: ${err.message}` : err.message;
+}
+function makeFail(result) {
+  return (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+    return result;
+  };
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array(n + 1).fill(0).map((_, i) => i);
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const tmp = dp[j];
+      dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+function suggest(input, candidates) {
+  if (!input || candidates.length === 0) return null;
+  const lower = input.toLowerCase();
+  const threshold = Math.max(2, Math.floor(lower.length / 3));
+  let best = null;
+  let bestDist = Infinity;
+  for (const c of candidates) {
+    const dist = levenshtein(lower, c.toLowerCase());
+    if (dist < bestDist && dist <= threshold && dist > 0) {
+      bestDist = dist;
+      best = c;
+    }
+  }
+  return best ? `Did you mean '${best}'?` : null;
+}
+var NAME_DIAGNOSTIC_CODES = {
+  /**
+   * Warning: two source-distinct names normalized to the same key
+   * (case- or whitespace-only difference). The first occurrence wins
+   * for display; subsequent occurrences fold into it. Suppressible
+   * per-line via `# allow-merge` annotation when intentional.
+   *
+   * Note: the `I_` prefix is intentionally preserved for stability —
+   * callers may have pinned this string. The diagnostic emits at
+   * `warning` severity (no `info` severity exists in DgmoError).
+   */
+  NAME_MERGED: "I_NAME_MERGED"
+};
+function nameMergedMessage(args) {
+  return `merged '${args.incomingDisplay}' (line ${args.incomingLine}) into '${args.existingDisplay}' (line ${args.existingLine}) \u2014 names differ only in case/whitespace`;
+}
+var METADATA_DIAGNOSTIC_CODES = {
+  /**
+   * Error: a `tag` declaration appears after the first non-tag
+   * content line. The reserved-key registry is finalized before
+   * content-line mode begins; downstream-declared tag aliases
+   * cannot retroactively apply to earlier lines.
+   */
+  TAG_DECLARED_AFTER_CONTENT: "E_TAG_DECLARED_AFTER_CONTENT",
+  /**
+   * Warning: a metadata pair has an empty value (`Foo c:`). The
+   * pair is dropped from the entity's metadata.
+   */
+  EMPTY_METADATA_VALUE: "W_EMPTY_METADATA_VALUE"
+};
+function emptyMetadataValueMessage(key) {
+  return `Metadata key '${key}:' has no value \u2014 the pair is dropped. Provide a value or remove the key.`;
+}
+
+export {
+  makeDgmoError,
+  emit,
+  dedupeDiagnostics,
+  formatDgmoError,
+  makeFail,
+  suggest,
+  NAME_DIAGNOSTIC_CODES,
+  nameMergedMessage,
+  METADATA_DIAGNOSTIC_CODES,
+  emptyMetadataValueMessage
+};
+//# sourceMappingURL=chunk-CXK4DZH3.js.map