@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-UZ7EZW3B.js

@@ -0,0 +1,40 @@
+import {
+  collapseTree
+} from "./chunk-BS7SV7C3.js";
+
+// src/mindmap/collapse.ts
+function cloneNode(node) {
+  return {
+    id: node.id,
+    label: node.label,
+    ...node.description !== void 0 && {
+      description: [...node.description]
+    },
+    metadata: { ...node.metadata },
+    children: node.children.map(cloneNode),
+    parentId: node.parentId,
+    lineNumber: node.lineNumber,
+    ...node.color !== void 0 && { color: node.color },
+    ...node.collapsed !== void 0 && { collapsed: node.collapsed }
+  };
+}
+var MINDMAP_SHAPE = {
+  getId: (node) => node.id,
+  getChildren: (node) => node.children,
+  clone: cloneNode,
+  setChildren: (node, children) => {
+    node.children = children;
+  },
+  countsAsHidden: () => true
+};
+function collapseMindmapTree(roots, collapsedIds) {
+  if (collapsedIds.size === 0) {
+    return { roots: [...roots], hiddenCounts: /* @__PURE__ */ new Map() };
+  }
+  return collapseTree(roots, collapsedIds, MINDMAP_SHAPE);
+}
+
+export {
+  collapseMindmapTree
+};
+//# sourceMappingURL=chunk-UZ7EZW3B.js.map

package/dist/chunk-VOKGH627.js

@@ -0,0 +1,37 @@
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+
+// src/utils/card.ts
+function renderNodeCard(container, opts) {
+  const rect = container.append("rect").attr("x", 0).attr("y", 0).attr("width", opts.width).attr("height", opts.height).attr("rx", opts.rx).attr("fill", opts.fill).attr("stroke", opts.stroke).attr("stroke-width", opts.strokeWidth);
+  if (opts.dashed) {
+    rect.attr("stroke-dasharray", "6 3");
+  }
+  container.append("text").attr("x", opts.width / 2).attr("y", opts.headerHeight / 2 + opts.labelFontSize / 2 - 2).attr("text-anchor", "middle").attr("fill", opts.labelColor).attr("font-size", opts.labelFontSize).attr("font-weight", "bold").text(opts.label);
+  const meta = opts.meta;
+  if (!meta || meta.rows.length === 0) return;
+  container.append("line").attr("x1", 0).attr("y1", opts.headerHeight).attr("x2", opts.width).attr("y2", opts.headerHeight).attr("stroke", meta.separatorColor).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
+  const keyX = meta.keyX ?? 10;
+  const maxKeyWidth = Math.max(
+    ...meta.rows.map(([key]) => measureText(`${key}: `, meta.fontSize))
+  );
+  const valueX = keyX + maxKeyWidth;
+  const metaStartY = opts.headerHeight + meta.separatorGap + meta.fontSize;
+  for (let i = 0; i < meta.rows.length; i++) {
+    const [displayKey, value] = meta.rows[i];
+    const rowY = metaStartY + i * meta.lineHeight;
+    container.append("text").attr("x", keyX).attr("y", rowY).attr("fill", meta.textColor).attr("font-size", meta.fontSize).text(`${displayKey}: `);
+    container.append("text").attr("x", valueX).attr("y", rowY).attr("fill", meta.textColor).attr("font-size", meta.fontSize).text(value);
+  }
+}
+function renderCollapseBar(container, opts) {
+  container.append("clipPath").attr("id", opts.clipId).append("rect").attr("width", opts.width).attr("height", opts.height).attr("rx", opts.rx);
+  container.append("rect").attr("x", opts.inset).attr("y", opts.height - opts.barHeight).attr("width", opts.width - opts.inset * 2).attr("height", opts.barHeight).attr("fill", opts.fill).attr("clip-path", `url(#${opts.clipId})`).attr("class", opts.className);
+}
+
+export {
+  renderNodeCard,
+  renderCollapseBar
+};
+//# sourceMappingURL=chunk-VOKGH627.js.map

package/dist/chunk-WBRZJOEC.js

@@ -0,0 +1,204 @@
+import {
+  buildPlacedNotes
+} from "./chunk-JED6ZDEE.js";
+import {
+  noteCanvasShift
+} from "./chunk-6EK55ART.js";
+import {
+  measureText
+} from "./chunk-WCT3NYCV.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+
+// src/class/layout.ts
+import dagre from "@dagrejs/dagre";
+var MIN_WIDTH = 140;
+var PADDING_X = 24;
+var HEADER_BASE = 36;
+var CLASS_FONT_SIZE = 13;
+var MEMBER_FONT_SIZE = 11;
+var MODIFIER_BADGE = 16;
+var MEMBER_LINE_HEIGHT = 18;
+var COMPARTMENT_PADDING_Y = 8;
+var SEPARATOR_HEIGHT = 1;
+function computeNodeDimensions(node) {
+  const fields = node.members.filter((m) => !m.isMethod);
+  const methods = node.members.filter((m) => m.isMethod);
+  const isEnum = node.modifier === "enum";
+  let maxTextWidth = measureText(node.name, CLASS_FONT_SIZE);
+  if (node.modifier) {
+    maxTextWidth = Math.max(
+      maxTextWidth,
+      measureText(`\xAB${node.modifier}\xBB`, MEMBER_FONT_SIZE)
+    );
+  }
+  for (const m of node.members) {
+    let memberText = m.name;
+    if (m.isMethod) {
+      memberText += `(${m.params ?? ""})`;
+      if (m.type) memberText += `: ${m.type}`;
+    } else if (m.type) {
+      memberText += `: ${m.type}`;
+    }
+    memberText = `+ ${memberText}`;
+    maxTextWidth = Math.max(
+      maxTextWidth,
+      measureText(memberText, MEMBER_FONT_SIZE)
+    );
+  }
+  const width = Math.max(MIN_WIDTH, maxTextWidth + PADDING_X);
+  const headerHeight = HEADER_BASE + (node.modifier ? MODIFIER_BADGE : 0);
+  let fieldsHeight;
+  if (isEnum) {
+    const enumValues = node.members;
+    if (enumValues.length > 0) {
+      fieldsHeight = COMPARTMENT_PADDING_Y * 2 + enumValues.length * MEMBER_LINE_HEIGHT + SEPARATOR_HEIGHT;
+    } else {
+      fieldsHeight = SEPARATOR_HEIGHT + COMPARTMENT_PADDING_Y;
+    }
+  } else {
+    if (fields.length > 0) {
+      fieldsHeight = COMPARTMENT_PADDING_Y * 2 + fields.length * MEMBER_LINE_HEIGHT + SEPARATOR_HEIGHT;
+    } else {
+      fieldsHeight = SEPARATOR_HEIGHT + COMPARTMENT_PADDING_Y;
+    }
+  }
+  let methodsHeight = 0;
+  if (!isEnum) {
+    if (methods.length > 0) {
+      methodsHeight = COMPARTMENT_PADDING_Y * 2 + methods.length * MEMBER_LINE_HEIGHT + SEPARATOR_HEIGHT;
+    } else {
+      methodsHeight = SEPARATOR_HEIGHT + COMPARTMENT_PADDING_Y;
+    }
+  }
+  const height = headerHeight + fieldsHeight + methodsHeight;
+  return { width, height, headerHeight, fieldsHeight, methodsHeight };
+}
+function layoutClassDiagram(parsed, options) {
+  if (parsed.classes.length === 0) {
+    return { nodes: [], edges: [], width: 0, height: 0 };
+  }
+  const g = new dagre.graphlib.Graph();
+  g.setGraph({
+    rankdir: "TB",
+    nodesep: 60,
+    ranksep: 80,
+    edgesep: 20
+  });
+  g.setDefaultEdgeLabel(() => ({}));
+  const dimMap = /* @__PURE__ */ new Map();
+  for (const node of parsed.classes) {
+    const dims = computeNodeDimensions(node);
+    dimMap.set(node.id, dims);
+    g.setNode(node.id, {
+      label: node.name,
+      width: dims.width,
+      height: dims.height
+    });
+  }
+  for (const rel of parsed.relationships) {
+    g.setEdge(rel.source, rel.target, { label: rel.label ?? "" });
+  }
+  dagre.layout(g);
+  const notesSuppressed = parsed.options?.["no-notes"] === "on";
+  const noteByNode = notesSuppressed || !parsed.notes ? /* @__PURE__ */ new Map() : resolveNotes(
+    parsed.notes,
+    parsed.classes.map((c) => ({ id: c.id, label: c.name }))
+  );
+  const placedNotes = buildPlacedNotes(
+    parsed.classes.map((node) => {
+      const pos = g.node(node.id);
+      return {
+        id: node.id,
+        x: pos.x,
+        y: pos.y,
+        width: pos.width,
+        height: pos.height
+      };
+    }),
+    noteByNode,
+    "TB",
+    options?.collapsedNotes
+  );
+  const layoutNodes = parsed.classes.map((node) => {
+    const pos = g.node(node.id);
+    const dims = dimMap.get(node.id);
+    const note = placedNotes.get(node.id);
+    return {
+      ...node,
+      x: pos.x,
+      y: pos.y,
+      width: dims.width,
+      height: dims.height,
+      headerHeight: dims.headerHeight,
+      fieldsHeight: dims.fieldsHeight,
+      methodsHeight: dims.methodsHeight,
+      ...note && { note }
+    };
+  });
+  const layoutEdges = parsed.relationships.map((rel) => {
+    const edgeData = g.edge(rel.source, rel.target);
+    const layoutEdge = {
+      source: rel.source,
+      target: rel.target,
+      type: rel.type,
+      points: edgeData?.points ?? [],
+      ...rel.label !== void 0 && { label: rel.label },
+      lineNumber: rel.lineNumber
+    };
+    return layoutEdge;
+  });
+  let bbMinX = Infinity;
+  let bbMinY = Infinity;
+  let bbMaxX = -Infinity;
+  let bbMaxY = -Infinity;
+  const extend = (l, t, r, b) => {
+    if (l < bbMinX) bbMinX = l;
+    if (t < bbMinY) bbMinY = t;
+    if (r > bbMaxX) bbMaxX = r;
+    if (b > bbMaxY) bbMaxY = b;
+  };
+  for (const node of layoutNodes) {
+    extend(
+      node.x - node.width / 2,
+      node.y - node.height / 2,
+      node.x + node.width / 2,
+      node.y + node.height / 2
+    );
+    if (node.note && !node.note.collapsed) {
+      extend(
+        node.x + node.note.x,
+        node.y + node.note.y,
+        node.x + node.note.x + node.note.width,
+        node.y + node.note.y + node.note.height
+      );
+    }
+  }
+  if (!Number.isFinite(bbMinX)) {
+    bbMinX = 0;
+    bbMinY = 0;
+    bbMaxX = 0;
+    bbMaxY = 0;
+  }
+  const { shiftX, shiftY } = noteCanvasShift(bbMinX, bbMinY);
+  const shifted = shiftX !== 0 || shiftY !== 0;
+  const finalNodes = shifted ? layoutNodes.map((n) => ({ ...n, x: n.x + shiftX, y: n.y + shiftY })) : layoutNodes;
+  const finalEdges = shifted ? layoutEdges.map((e) => ({
+    ...e,
+    points: e.points.map((pt) => ({ x: pt.x + shiftX, y: pt.y + shiftY }))
+  })) : layoutEdges;
+  const totalWidth = bbMaxX + shiftX + 40;
+  const totalHeight = bbMaxY + shiftY + 40;
+  return {
+    nodes: finalNodes,
+    edges: finalEdges,
+    width: totalWidth,
+    height: totalHeight
+  };
+}
+
+export {
+  layoutClassDiagram
+};
+//# sourceMappingURL=chunk-WBRZJOEC.js.map

package/dist/chunk-WCSOJFU3.js

@@ -0,0 +1,380 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  cascadeTagMetadata,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  TREEMAP_REGISTRY,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  peelRampColors,
+  splitNameAndMeta,
+  stripQuotes,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  emit,
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/treemap/diagnostics.ts
+var TREEMAP_DX = {
+  NEGATIVE_VALUE: {
+    code: "E_TREEMAP_NEGATIVE_VALUE",
+    severity: "error",
+    chartType: "treemap",
+    title: "Negative leaf value",
+    message: (p) => `Leaf "${p.label ?? "X"}" has a negative value (${p.value ?? -5}) \u2014 treemap sizes must be \u2265 0`,
+    hint: "Segment magnitude must be zero or greater \u2014 use a value of 0 or more.",
+    example: "treemap T\nA\n  Bad -5"
+  },
+  LEAF_NO_VALUE: {
+    code: "W_TREEMAP_LEAF_NO_VALUE",
+    severity: "warning",
+    chartType: "treemap",
+    title: "Leaf has no value",
+    message: (p) => `Leaf "${p.label ?? "Lonely"}" has no value \u2014 it renders with zero size`,
+    hint: "Add a trailing number (e.g. `Lonely 40`) so the leaf gets a size.",
+    example: "treemap T\nA\n  Lonely"
+  },
+  BRANCH_VALUE_IGNORED: {
+    code: "W_TREEMAP_BRANCH_VALUE_IGNORED",
+    severity: "warning",
+    chartType: "treemap",
+    title: "Branch value ignored",
+    message: (p) => `"${p.label ?? "Operations"}" is a branch \u2014 its trailing number is ignored; the size is the auto-sum of its children`,
+    hint: "Remove the trailing number from a branch \u2014 a parent's size is the sum of its children.",
+    example: "treemap T\nOperations 999\n  Cloud 110\n  Support 70"
+  }
+};
+var TREEMAP_DIAGNOSTICS = Object.values(TREEMAP_DX);
+
+// src/treemap/parser.ts
+var VALUE_TOKEN_RE = /^(.+?)\s+(-?\d[\d_.]*)$/;
+function isFullyQuoted(s) {
+  return s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"));
+}
+function parseTreemap(content, palette) {
+  const options = {
+    heatColors: [],
+    noValues: false,
+    noPercent: false,
+    noHeaders: false,
+    noLegend: false,
+    solidFill: false,
+    radial: false
+  };
+  const result = {
+    type: "treemap",
+    title: null,
+    titleLineNumber: null,
+    roots: [],
+    tagGroups: [],
+    hasHeat: false,
+    defaultColorMode: "branch",
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const pushError = (line, message, code) => {
+    const diag = makeDgmoError(line, message, "error", code);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const pushWarning = (line, message, code) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning", code));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let nodeCounter = 0;
+  let currentTagGroup = null;
+  const aliasMap = /* @__PURE__ */ new Map();
+  const indentStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!contentStarted) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine && result.titleLineNumber === null && i === 0) {
+        if (firstLine.chartType !== "treemap") {
+          let msg = `Expected chart type "treemap", got "${firstLine.chartType}"`;
+          const hint = suggest(firstLine.chartType, ["treemap"]);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        result.title = firstLine.title ?? null;
+        result.titleLineNumber = lineNumber;
+        continue;
+      }
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      if (contentStarted) {
+        pushError(
+          lineNumber,
+          "Tag groups must appear before treemap content",
+          "E_TAG_DECLARED_AFTER_CONTENT"
+        );
+        continue;
+      }
+      currentTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      if (tagBlockMatch.alias) {
+        aliasMap.set(
+          tagBlockMatch.alias.toLowerCase(),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      aliasMap.set(
+        tagAttrKey(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      result.tagGroups.push(currentTagGroup);
+      continue;
+    }
+    if (currentTagGroup && !contentStarted) {
+      const indent2 = measureIndent(line);
+      if (indent2 > 0) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    if (!contentStarted && measureIndent(line) === 0) {
+      if (handleDirective(trimmed, options, result, pushWarning, lineNumber)) {
+        continue;
+      }
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    const indent = measureIndent(line);
+    const node = parseNodeLine(
+      trimmed,
+      lineNumber,
+      ++nodeCounter,
+      aliasMap,
+      result.diagnostics
+    );
+    if (node.heat !== void 0) result.hasHeat = true;
+    attachNode(node, indent, indentStack, result);
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  const allNodes = [];
+  const collectAll = (nodes) => {
+    for (const n of nodes) {
+      allNodes.push(n);
+      collectAll(n.children);
+    }
+  };
+  collectAll(result.roots);
+  for (const n of allNodes) {
+    const node = n;
+    const isBranch = node.children.length > 0;
+    if (isBranch) {
+      if (node.value !== void 0) {
+        result.diagnostics.push(
+          emit(TREEMAP_DX.BRANCH_VALUE_IGNORED, node.lineNumber, {
+            label: node.label
+          })
+        );
+        delete node.value;
+      }
+    } else if (node.value === void 0) {
+      result.diagnostics.push(
+        emit(TREEMAP_DX.LEAF_NO_VALUE, node.lineNumber, {
+          label: node.label
+        })
+      );
+      node.value = 0;
+    } else if (node.value < 0) {
+      result.diagnostics.push(
+        emit(TREEMAP_DX.NEGATIVE_VALUE, node.lineNumber, {
+          label: node.label,
+          value: node.value
+        })
+      );
+    }
+  }
+  if (result.hasHeat || options.heatLabel !== void 0) {
+    result.hasHeat = true;
+  }
+  if (result.tagGroups.length > 0) {
+    validateTagValues(allNodes, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning);
+    cascadeTagMetadata(result.roots, result.tagGroups);
+  }
+  result.defaultColorMode = resolveDefaultColorMode(result);
+  if (result.roots.length === 0 && !result.error) {
+    const diag = makeDgmoError(1, "No nodes found in treemap");
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+function handleDirective(trimmed, options, result, pushWarning, lineNumber) {
+  const depthMatch = trimmed.match(/^depth\s+(-?\d+)\s*$/i);
+  if (depthMatch) {
+    const n = parseInt(depthMatch[1], 10);
+    if (n >= 1) options.maxDepth = n;
+    else pushWarning(lineNumber, '"depth" must be \u2265 1 \u2014 ignored');
+    return true;
+  }
+  if (/^other-below\b/i.test(trimmed)) {
+    pushWarning(
+      lineNumber,
+      '"other-below" is no longer supported \u2014 remove this line'
+    );
+    return true;
+  }
+  const heatMatch = trimmed.match(/^heat\s+(.+)$/i);
+  if (heatMatch) {
+    const { label, low, high } = peelRampColors(heatMatch[1].trim());
+    options.heatLabel = label || "Value";
+    const colors = [];
+    if (low !== void 0) colors.push(low);
+    if (high !== void 0) colors.push(high);
+    options.heatColors = colors;
+    result.hasHeat = true;
+    return true;
+  }
+  const noMatch = trimmed.match(/^no-(values|percent|headers|legend)\s*$/i);
+  if (noMatch) {
+    const key = noMatch[1].toLowerCase();
+    if (key === "values") options.noValues = true;
+    else if (key === "percent") options.noPercent = true;
+    else if (key === "headers") options.noHeaders = true;
+    else if (key === "legend") options.noLegend = true;
+    return true;
+  }
+  if (/^solid-fill\s*$/i.test(trimmed)) {
+    options.solidFill = true;
+    return true;
+  }
+  if (/^radial\s*$/i.test(trimmed)) {
+    options.radial = true;
+    return true;
+  }
+  return false;
+}
+function resolveDefaultColorMode(result) {
+  if (result.tagGroups.length > 0) return "tag";
+  if (result.hasHeat) return "heat";
+  return "branch";
+}
+function parseNodeLine(trimmed, lineNumber, counter, aliasMap, diagnostics) {
+  const registry = withTagAliases(TREEMAP_REGISTRY, new Set(aliasMap.keys()));
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    aliasMap,
+    void 0,
+    diagnostics,
+    lineNumber
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => diagnostics.push(makeDgmoError(lineNumber, msg, "warning")),
+    split.name
+  );
+  const metadata = { ...split.meta };
+  let heat;
+  if ("heat" in metadata) {
+    const h = parseFloat(metadata["heat"].replace(/_/g, ""));
+    if (Number.isFinite(h)) heat = h;
+    delete metadata["heat"];
+  }
+  const rawName = split.name;
+  let label;
+  let value;
+  if (isFullyQuoted(rawName)) {
+    label = stripQuotes(rawName);
+  } else {
+    const vm = rawName.match(VALUE_TOKEN_RE);
+    if (vm) {
+      const labelPart = vm[1].trim();
+      const token = vm[2];
+      const cleaned = token.replace(/_/g, "");
+      const parsed = parseFloat(cleaned);
+      if (Number.isFinite(parsed)) {
+        value = parsed;
+        label = isFullyQuoted(labelPart) ? stripQuotes(labelPart) : labelPart;
+      } else {
+        label = rawName;
+      }
+    } else {
+      label = rawName;
+    }
+  }
+  return {
+    id: `treemap-node-${counter}`,
+    label,
+    ...value !== void 0 && { value },
+    ...heat !== void 0 && { heat },
+    metadata,
+    children: [],
+    lineNumber
+  };
+}
+function attachNode(node, indent, indentStack, result) {
+  while (indentStack.length > 0) {
+    const top = indentStack[indentStack.length - 1];
+    if (top.indent < indent) break;
+    indentStack.pop();
+  }
+  if (indentStack.length > 0) {
+    const parent = indentStack[indentStack.length - 1].node;
+    parent.children.push(node);
+  } else {
+    result.roots.push(node);
+  }
+  indentStack.push({ node, indent });
+}
+
+export {
+  TREEMAP_DIAGNOSTICS,
+  parseTreemap
+};
+//# sourceMappingURL=chunk-WCSOJFU3.js.map