@diagrammo/dgmo 0.53.0 → 0.55.0

package/dist/{chunk-6DCOIN4W.js → chunk-A2ARDILY.js}

@@ -1,3 +1,16 @@
+import {
+  RECOGNIZED_COLOR_NAMES,
+  invalidColorDiagnostic,
+  resolveColor,
+  resolveColorWithDiagnostic
+} from "./chunk-ZKPPI6BF.js";
+import {
+  METADATA_DIAGNOSTIC_CODES,
+  emptyMetadataValueMessage,
+  makeDgmoError,
+  suggest
+} from "./chunk-4W2PE66Q.js";
+
 // src/directives-registry.ts
 var DIRECTIVES_REGISTRY = [
   // ── Universal date handling (§ BL-121) ───────────────────
@@ -128,6 +141,15 @@ var DIRECTIVES_REGISTRY = [
   // most types via GLOBAL_BOOLEANS in utils/parsing; gantt derives its boolean
   // Set from here, and map from `map: true`.
   { token: "no-legend", category: "directive", gantt: ["boolean"], map: true },
+  // `legend-inline`: universal §1.9 boolean (decision #50) — the top-center-
+  // legend data charts (bar/line/radar/scatter/function) render the title and
+  // legend on one line; every other chart accepts it as a harmless no-op.
+  {
+    token: "legend-inline",
+    category: "directive",
+    gantt: ["boolean"],
+    map: true
+  },
   // ══════════════════════════════════════════════════════════
   // Highlight-only vocab (no extractable parser Set).
   // ══════════════════════════════════════════════════════════
@@ -240,6 +262,23 @@ var DIRECTIVES_REGISTRY = [
   // ── Color / notes (cross-chart) ──────────────────────────
   { token: "color", category: "directive" },
   { token: "no-notes", category: "directive" },
+  // ── Emphasis family (§1.11, decision #49) ────────────────
+  // `highlight <Name>…` / `dim <Name>…` — the figure/ground axis, orthogonal
+  // to color (§1.5) and to the chart-wide `fill-*` family (§1.9). Both are
+  // chart-level directives taking a name list, validated inline by each
+  // adopting parser (no extractable Set), so the registry is their single
+  // declaration site for highlighting.
+  //
+  // `highlight` shipped on `family` long before this entry existed and was
+  // never registered — it had completions but highlighted as plain text. Both
+  // tokens are registered together so the whole family lights up at once.
+  //
+  // Supported on `sankey` and `family` today; every further chart type is a
+  // separate decision. Registering them globally is correct regardless: the
+  // Lezer specializer is context-free (it cannot know the chart type), and the
+  // same is already true of every other chart-scoped token here.
+  { token: "highlight", category: "directive" },
+  { token: "dim", category: "directive" },
   // ── RACI ─────────────────────────────────────────────────
   { token: "roles", category: "directive" },
   // ── Cycle ────────────────────────────────────────────────
@@ -249,7 +288,7 @@ var DIRECTIVES_REGISTRY = [
   { token: "persona", category: "directive" },
   // ── Function ─────────────────────────────────────────────
   { token: "x", category: "directive" },
-  { token: "shade", category: "directive" },
+  { token: "fill", category: "directive" },
   // ── Wordcloud ────────────────────────────────────────────
   { token: "max", category: "directive" },
   { token: "size", category: "directive" },
@@ -343,6 +382,7 @@ function tokensWhere(pred) {
   for (const e of DIRECTIVES_REGISTRY) if (pred(e)) out.add(e.token);
   return out;
 }
+var ALL_REGISTRY_TOKENS = tokensWhere(() => true);
 var INFRA_TOP_LEVEL_OPTION_SET = tokensWhere(
   (e) => !!e.infra?.includes("top-level")
 );
@@ -376,6 +416,694 @@ var REGISTRY_NON_HIGHLIGHT_TOKENS = tokensWhere(
   (e) => !!e.noHighlight
 );
 
+// src/utils/reserved-key-registry.ts
+function staticRegistry(keys) {
+  return { keys: new Set(keys), tagAliases: /* @__PURE__ */ new Set() };
+}
+function withTagAliases(base, aliases) {
+  return { keys: base.keys, tagAliases: aliases };
+}
+function isReservedKey(registry, key) {
+  return registry.keys.has(key) || registry.tagAliases.has(key);
+}
+var SEQUENCE_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "role",
+  "collapsed",
+  // Participant layout-order override (§2.2). Colon-keyed `position: N`.
+  "position"
+]);
+var INFRA_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "collapsed",
+  "icon"
+]);
+var MAP_REGISTRY = staticRegistry([
+  "heat",
+  "size",
+  "width",
+  "label",
+  "style",
+  // `clock` (BL-122): the time-card control. Bare (`poi Denver clock`) → a card
+  // with the zone auto-derived from the place; valued (`clock: Europe/Oslo`) →
+  // that IANA id or fixed offset (`clock: UTC+9`) as the zone, for bare-coord
+  // pins or to override a city. Reserved so the valued form peels off the POI
+  // name cleanly; the BARE flag is peeled separately in handlePoi (no colon).
+  "clock"
+  // `surface:` was removed in the 2026-06-02 defaults-on review — it is no longer
+  // a recognized metadata key (the route/edge surface feature was cut; §24B.7).
+  // A stray `surface: water` is no longer captured as a reserved key.
+]);
+var ORG_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "role",
+  "location",
+  "email",
+  "phone"
+]);
+var C4_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "tech",
+  "type",
+  "collapsed"
+]);
+var ER_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "domain"
+]);
+var EVENT_LINE_REGISTRY = staticRegistry([
+  "color"
+]);
+var KANBAN_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "wip",
+  "assignee",
+  "due",
+  "collapsed"
+  // `[Column] collapsed: true` view-state marker
+]);
+var SITEMAP_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "status"
+]);
+var GANTT_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "duration",
+  "offset",
+  "progress",
+  "start",
+  "collapsed"
+  // `[Group] collapsed: true` view-state marker
+]);
+var PERT_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "confidence",
+  "collapsed"
+]);
+var BOXES_AND_LINES_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "heat"
+]);
+var STATE_REGISTRY = staticRegistry([]);
+var SKETCH_REGISTRY = staticRegistry([
+  "shape",
+  "at",
+  "collapsed"
+]);
+var TIMELINE_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "duration"
+]);
+var MINDMAP_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "collapsed"
+]);
+var TECH_RADAR_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "quadrant",
+  "ring",
+  "trend"
+]);
+var CYCLE_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "width",
+  "span"
+]);
+var JOURNEY_MAP_REGISTRY = staticRegistry([
+  "color",
+  "description",
+  "score",
+  "emotion",
+  "pain",
+  "opportunity",
+  "thought"
+]);
+var PYRAMID_REGISTRY = staticRegistry([
+  "color",
+  "description"
+]);
+var RING_REGISTRY = staticRegistry([
+  "color",
+  "description"
+]);
+var TREEMAP_REGISTRY = staticRegistry(["heat"]);
+var RACI_REGISTRY = staticRegistry([
+  "color",
+  "description"
+]);
+var FAMILY_PERSON_REGISTRY = staticRegistry([
+  "sex",
+  "b",
+  "d",
+  "bp",
+  "dp",
+  "occupation",
+  "military",
+  "education",
+  "religion",
+  "burial"
+]);
+var FAMILY_UNION_REGISTRY = staticRegistry(["m"]);
+
+// src/utils/parsing.ts
+var RECOGNIZED_COLOR_SET = new Set(
+  RECOGNIZED_COLOR_NAMES
+);
+var ALL_CHART_TYPES = /* @__PURE__ */ new Set([
+  // data charts
+  "bar",
+  "line",
+  "pie",
+  "polar-area",
+  "radar",
+  "scatter",
+  "sankey",
+  "function",
+  "heatmap",
+  "funnel",
+  // visualizations
+  "slope",
+  "wordcloud",
+  "arc",
+  "timeline",
+  "event-line",
+  "venn",
+  "quadrant",
+  // diagrams
+  "body",
+  "sequence",
+  "flowchart",
+  "class",
+  "er",
+  "org",
+  "kanban",
+  "c4",
+  "state",
+  "sitemap",
+  "infra",
+  "gantt",
+  "pert",
+  "boxes-and-lines",
+  "swimlane",
+  "version-control",
+  "mindmap",
+  "wireframe",
+  "tech-radar",
+  "cycle",
+  "journey-map",
+  "pyramid",
+  "ring",
+  "treemap",
+  "block",
+  "goal",
+  "countdown",
+  "clock",
+  "sketch",
+  "raci",
+  "map",
+  "family",
+  "bracket"
+]);
+function measureIndent(line) {
+  let indent = 0;
+  for (const ch of line) {
+    if (ch === " ") indent++;
+    else if (ch === "	") indent += 4;
+    else break;
+  }
+  return indent;
+}
+function extractColor(label, palette, diagnostics, line) {
+  const lastSpaceIdx = Math.max(
+    label.lastIndexOf(" "),
+    label.lastIndexOf("	")
+  );
+  if (lastSpaceIdx < 0) return { label };
+  const trailing = label.substring(lastSpaceIdx + 1);
+  if (!RECOGNIZED_COLOR_SET.has(trailing)) {
+    if (diagnostics && line !== void 0) {
+      const diag = invalidColorDiagnostic(trailing, line);
+      if (diag) diagnostics.push(diag);
+    }
+    return { label };
+  }
+  let color;
+  if (diagnostics && line !== void 0) {
+    color = resolveColorWithDiagnostic(trailing, line, diagnostics, palette);
+  } else {
+    color = resolveColor(trailing, palette) ?? void 0;
+  }
+  return {
+    label: label.substring(0, lastSpaceIdx).trimEnd(),
+    ...color !== void 0 && { color }
+  };
+}
+var OPTION_NOCOLON_RE = /^([a-z][a-z0-9-]*)\s+(.+)$/i;
+var GLOBAL_BOOLEANS = /* @__PURE__ */ new Set([
+  "fill-tint",
+  "fill-solid",
+  "fill-outline",
+  "no-title",
+  "no-notes",
+  "no-legend",
+  "legend-inline"
+]);
+function legendSuppressed(options) {
+  return options["no-legend"] === "on";
+}
+function legendInlineRequested(options) {
+  return options["legend-inline"] === "on";
+}
+var FILL_FAMILY_TOKENS = /* @__PURE__ */ new Set([
+  "fill-tint",
+  "fill-solid",
+  "fill-outline"
+]);
+function fillModeFromToken(token) {
+  switch (token.trim().toLowerCase()) {
+    case "fill-solid":
+      return "solid";
+    case "fill-outline":
+      return "outline";
+    case "fill-tint":
+      return "tint";
+    default:
+      return null;
+  }
+}
+function fillModeFromOptions(options) {
+  if (options["fill-solid"] === "on") return "solid";
+  if (options["fill-outline"] === "on") return "outline";
+  return void 0;
+}
+function recognizeGlobalBoolean(token) {
+  const t = token.trim().toLowerCase();
+  return GLOBAL_BOOLEANS.has(t) ? t : null;
+}
+function tryParseSharedOption(line, options) {
+  const key = recognizeGlobalBoolean(line);
+  if (key) {
+    if (FILL_FAMILY_TOKENS.has(key)) {
+      for (const t of FILL_FAMILY_TOKENS) delete options[t];
+    }
+    options[key] = "on";
+    return true;
+  }
+  return false;
+}
+function parseFirstLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("//")) return null;
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx === -1) {
+    const ct = trimmed.toLowerCase();
+    return ALL_CHART_TYPES.has(ct) ? { chartType: ct, title: void 0 } : null;
+  }
+  const firstToken = trimmed.substring(0, spaceIdx).toLowerCase();
+  if (!ALL_CHART_TYPES.has(firstToken)) return null;
+  return {
+    chartType: firstToken,
+    title: trimmed.substring(spaceIdx + 1).trim() || void 0
+  };
+}
+var CHART_TYPE_TOKEN_RE = /^[A-Za-z][A-Za-z0-9-]*$/;
+var TITLE_LIKE_RE = /^[A-Za-z][A-Za-z\s'&,.\-—–]*$/;
+function detectBadChartTypeDeclaration(line, knownOptionKeys) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.includes(":")) return null;
+  const spaceIdx = trimmed.indexOf(" ");
+  const token = spaceIdx === -1 ? trimmed : trimmed.substring(0, spaceIdx);
+  if (!CHART_TYPE_TOKEN_RE.test(token)) return null;
+  const lower = token.toLowerCase();
+  if (knownOptionKeys.has(lower) || ALL_REGISTRY_TOKENS.has(lower)) return null;
+  if (spaceIdx === -1) return /\d/.test(token) ? null : token;
+  const rest = trimmed.substring(spaceIdx + 1).trim();
+  if (!rest || !TITLE_LIKE_RE.test(rest)) return null;
+  return token;
+}
+function normalizeNumericToken(token) {
+  if (!token.includes(",") && !token.includes("_")) return null;
+  if (token.includes(",") && token.includes("_")) return null;
+  let sign = "";
+  let unsigned = token;
+  if (unsigned.startsWith("-")) {
+    sign = "-";
+    unsigned = unsigned.substring(1);
+  }
+  if (!unsigned) return null;
+  if (unsigned.includes(",")) {
+    if (/^\d{1,3}(,\d{3})+$/.test(unsigned))
+      return sign + unsigned.replace(/,/g, "");
+    if (/^\d{1,3}(,\d{3})+\.\d+$/.test(unsigned))
+      return sign + unsigned.replace(/,/g, "");
+    return null;
+  }
+  if (/^\d+(_\d+)+$/.test(unsigned)) return sign + unsigned.replace(/_/g, "");
+  if (/^\d+(_\d+)*\.\d+$/.test(unsigned) && unsigned.includes("_"))
+    return sign + unsigned.replace(/_/g, "");
+  return null;
+}
+function stripQuotes(token) {
+  if (token.length >= 2) {
+    if (token[0] === '"' && token[token.length - 1] === '"' || token[0] === "'" && token[token.length - 1] === "'") {
+      return token.substring(1, token.length - 1);
+    }
+  }
+  return token;
+}
+function tokenizeQuoteAware(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] === " " || input[i] === "	") {
+      i++;
+      continue;
+    }
+    if (input[i] === '"' || input[i] === "'") {
+      const quote = input[i];
+      const start2 = i;
+      i++;
+      while (i < input.length && input[i] !== quote) i++;
+      if (i < input.length) i++;
+      tokens.push(input.substring(start2, i));
+      continue;
+    }
+    const start = i;
+    while (i < input.length && input[i] !== " " && input[i] !== "	") i++;
+    tokens.push(input.substring(start, i));
+  }
+  return tokens;
+}
+function collectIndentedValues(lines, startIndex) {
+  const values = [];
+  const lineNumbers = [];
+  let j = startIndex + 1;
+  for (; j < lines.length; j++) {
+    const raw = lines[j];
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("//")) continue;
+    if (raw[0] !== " " && raw[0] !== "	") break;
+    values.push(trimmed.replace(/,\s*$/, ""));
+    lineNumbers.push(j + 1);
+  }
+  return { values, lineNumbers, newIndex: j - 1 };
+}
+function parseSeriesNames(value, lines, lineIndex, palette, diagnostics) {
+  let rawNames;
+  let series;
+  let newIndex = lineIndex;
+  let nameLineNumbers = [];
+  if (value) {
+    series = value;
+    rawNames = value.split(",").map((s) => s.trim()).filter(Boolean);
+    nameLineNumbers = rawNames.map(() => lineIndex + 1);
+  } else {
+    const collected = collectIndentedValues(lines, lineIndex);
+    newIndex = collected.newIndex;
+    rawNames = collected.values;
+    nameLineNumbers = collected.lineNumbers;
+    series = rawNames.join(", ");
+  }
+  const isHeader = (s) => {
+    const tok = s.split(/\s+/, 1)[0];
+    if (tok === "y-label") return "left";
+    if (tok === "y-right-label") return "right";
+    return null;
+  };
+  if (rawNames.some((r) => isHeader(r) !== null)) {
+    const names2 = [];
+    const nameColors2 = [];
+    const axes = [];
+    const memberLineNumbers = [];
+    let leftLabel;
+    let rightLabel;
+    let currentAxis = "left";
+    for (let i = 0; i < rawNames.length; i++) {
+      const raw = rawNames[i];
+      const side = isHeader(raw);
+      if (side !== null) {
+        const label = raw.slice(raw.indexOf(" ") + 1).trim();
+        currentAxis = side;
+        if (side === "left") leftLabel = label || leftLabel;
+        else rightLabel = label || rightLabel;
+        continue;
+      }
+      const extracted = extractColor(
+        raw,
+        palette,
+        diagnostics,
+        nameLineNumbers[i]
+      );
+      names2.push(extracted.label);
+      nameColors2.push(extracted.color);
+      axes.push(currentAxis);
+      memberLineNumbers.push(nameLineNumbers[i]);
+    }
+    return {
+      series: names2.join(", "),
+      names: names2,
+      nameColors: nameColors2,
+      nameLineNumbers: memberLineNumbers,
+      newIndex,
+      axes,
+      ...leftLabel !== void 0 && { leftLabel },
+      ...rightLabel !== void 0 && { rightLabel }
+    };
+  }
+  const names = [];
+  const nameColors = [];
+  for (let i = 0; i < rawNames.length; i++) {
+    const raw = rawNames[i];
+    const extracted = extractColor(
+      raw,
+      palette,
+      diagnostics,
+      nameLineNumbers[i]
+    );
+    nameColors.push(extracted.color);
+    names.push(extracted.label);
+  }
+  if (names.length === 1) {
+    series = names[0];
+  }
+  return { series, names, nameColors, nameLineNumbers, newIndex };
+}
+function peelTrailingColorName(label) {
+  const lastSpaceIdx = Math.max(
+    label.lastIndexOf(" "),
+    label.lastIndexOf("	")
+  );
+  if (lastSpaceIdx < 0) return { label };
+  const trailing = label.substring(lastSpaceIdx + 1);
+  if (!RECOGNIZED_COLOR_SET.has(trailing)) return { label };
+  return {
+    label: label.substring(0, lastSpaceIdx).trimEnd(),
+    colorName: trailing
+  };
+}
+function peelTrailingCollapsedFlag(text) {
+  const t = text.trimEnd();
+  if (t === "collapsed") return { rest: "", collapsed: true };
+  if (/[ \t]collapsed$/.test(t)) {
+    return {
+      rest: t.slice(0, t.length - "collapsed".length).trimEnd().replace(/,\s*$/, ""),
+      collapsed: true
+    };
+  }
+  return { rest: text, collapsed: false };
+}
+function peelRampColors(label) {
+  const peelOne = (s) => {
+    const idx = Math.max(s.lastIndexOf(" "), s.lastIndexOf("	"));
+    if (idx < 0) return { rest: s };
+    const trailing = s.substring(idx + 1);
+    if (!RECOGNIZED_COLOR_SET.has(trailing)) return { rest: s };
+    return { rest: s.substring(0, idx).trimEnd(), color: trailing };
+  };
+  const first = peelOne(label);
+  if (first.color === void 0) return { label };
+  const second = peelOne(first.rest);
+  if (second.color === void 0) {
+    return { label: first.rest, high: first.color };
+  }
+  return { label: second.rest, low: second.color, high: first.color };
+}
+var RESERVED_KEY_RE = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var AS_ALIAS_RE = /\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})$/;
+function scanTokens(line) {
+  const tokens = [];
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === " " || line[i] === "	") {
+      i++;
+      continue;
+    }
+    if (line[i] === '"' || line[i] === "'") {
+      const quote = line[i];
+      const start2 = i;
+      i++;
+      while (i < line.length && line[i] !== quote) i++;
+      if (i < line.length) i++;
+      tokens.push({
+        text: line.substring(start2, i),
+        start: start2,
+        end: i,
+        quoted: true
+      });
+      continue;
+    }
+    const start = i;
+    while (i < line.length && line[i] !== " " && line[i] !== "	") i++;
+    tokens.push({
+      text: line.substring(start, i),
+      start,
+      end: i,
+      quoted: false
+    });
+  }
+  return tokens;
+}
+function findMetadataCutOffset(line, tokens, registry) {
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok.quoted) continue;
+    const inlineColon = tok.text.indexOf(":");
+    if (inlineColon > 0) {
+      const keyPart = tok.text.substring(0, inlineColon);
+      if (RESERVED_KEY_RE.test(keyPart) && isReservedKey(registry, keyPart.toLowerCase())) {
+        return tok.start;
+      }
+    } else if (inlineColon < 0) {
+      if (RESERVED_KEY_RE.test(tok.text) && isReservedKey(registry, tok.text.toLowerCase())) {
+        const tail = line.substring(tok.end).replace(/^[ \t]+/, "");
+        if (tail.startsWith(":")) {
+          return tok.start;
+        }
+      }
+    }
+  }
+  return -1;
+}
+function parseMetadataRegion(region, aliasMap, diagnostics, line) {
+  const meta = {};
+  let i = 0;
+  while (i < region.length) {
+    while (i < region.length && (region[i] === " " || region[i] === "	" || region[i] === ","))
+      i++;
+    if (i >= region.length) break;
+    const keyStart = i;
+    while (i < region.length && region[i] !== ":" && region[i] !== ",") i++;
+    if (i >= region.length || region[i] !== ":") break;
+    const rawKey = region.substring(keyStart, i).trim().toLowerCase();
+    if (!rawKey) break;
+    i++;
+    while (i < region.length && (region[i] === " " || region[i] === "	")) i++;
+    let value;
+    if (i < region.length && (region[i] === '"' || region[i] === "'")) {
+      const quote = region[i];
+      i++;
+      const vStart = i;
+      while (i < region.length && region[i] !== quote) i++;
+      value = region.substring(vStart, i);
+      if (i < region.length) i++;
+      while (i < region.length && (region[i] === " " || region[i] === "	"))
+        i++;
+    } else {
+      const vStart = i;
+      while (i < region.length && region[i] !== ",") i++;
+      value = region.substring(vStart, i).trim();
+    }
+    const key = aliasMap.get(rawKey) ?? rawKey;
+    if (!value) {
+      if (diagnostics && line !== void 0) {
+        diagnostics.push(
+          makeDgmoError(
+            line,
+            emptyMetadataValueMessage(rawKey),
+            "warning",
+            METADATA_DIAGNOSTIC_CODES.EMPTY_METADATA_VALUE
+          )
+        );
+      }
+      continue;
+    }
+    meta[key] = value;
+  }
+  return meta;
+}
+function cutUnionMetadata(line, registry) {
+  return findMetadataCutOffset(line, scanTokens(line), registry);
+}
+function splitNameAndMeta(line, registry, aliasMap = /* @__PURE__ */ new Map(), palette, diagnostics, lineNumber, options = {}) {
+  const tokens = scanTokens(line);
+  const cutOffset = findMetadataCutOffset(line, tokens, registry);
+  let nameRegion;
+  let metaRegion;
+  if (cutOffset === -1) {
+    nameRegion = line.trim();
+    metaRegion = "";
+  } else {
+    nameRegion = line.substring(0, cutOffset).trimEnd();
+    metaRegion = line.substring(cutOffset);
+  }
+  const colorResult = peelTrailingColorName(nameRegion);
+  let postColorName = colorResult.label;
+  let alias;
+  if (options.peelAlias !== false) {
+    const aliasMatch = postColorName.match(AS_ALIAS_RE);
+    if (aliasMatch) {
+      alias = aliasMatch[1];
+      postColorName = postColorName.substring(0, aliasMatch.index).trimEnd();
+    }
+  }
+  const meta = metaRegion.length > 0 ? parseMetadataRegion(metaRegion, aliasMap, diagnostics, lineNumber) : {};
+  void palette;
+  return {
+    name: postColorName,
+    meta,
+    ...colorResult.colorName !== void 0 && {
+      color: colorResult.colorName
+    },
+    ...alias !== void 0 && { alias }
+  };
+}
+var POTENTIAL_META_RE = /\b([\w-]+)\s*:/;
+function warnUnknownMetaKeys(meta, registry, warn, nameToScan) {
+  const candidates = Array.from(registry.keys);
+  for (const key of Object.keys(meta)) {
+    if (isReservedKey(registry, key)) continue;
+    const hint = suggest(key, candidates);
+    warn(`Unknown metadata key "${key}".${hint ? " " + hint : ""}`);
+  }
+  if (nameToScan) {
+    const m = nameToScan.match(POTENTIAL_META_RE);
+    if (m) {
+      const key = m[1].toLowerCase();
+      if (!isReservedKey(registry, key)) {
+        const hint = suggest(key, candidates);
+        if (hint) {
+          warn(`Unknown metadata key "${key}". ${hint}`);
+        }
+      }
+    }
+  }
+}
+
 export {
   INFRA_TOP_LEVEL_OPTION_SET,
   INFRA_BEHAVIOR_KEY_SET,
@@ -387,6 +1115,58 @@ export {
   REGISTRY_CONTROL_TOKENS,
   REGISTRY_STATUS_TOKENS,
   REGISTRY_MODIFIER_TOKENS,
-  REGISTRY_COLON_KEY_TOKENS
+  REGISTRY_COLON_KEY_TOKENS,
+  withTagAliases,
+  isReservedKey,
+  SEQUENCE_REGISTRY,
+  INFRA_REGISTRY,
+  MAP_REGISTRY,
+  ORG_REGISTRY,
+  C4_REGISTRY,
+  ER_REGISTRY,
+  EVENT_LINE_REGISTRY,
+  KANBAN_REGISTRY,
+  SITEMAP_REGISTRY,
+  GANTT_REGISTRY,
+  PERT_REGISTRY,
+  BOXES_AND_LINES_REGISTRY,
+  STATE_REGISTRY,
+  SKETCH_REGISTRY,
+  TIMELINE_REGISTRY,
+  MINDMAP_REGISTRY,
+  TECH_RADAR_REGISTRY,
+  CYCLE_REGISTRY,
+  JOURNEY_MAP_REGISTRY,
+  PYRAMID_REGISTRY,
+  RING_REGISTRY,
+  TREEMAP_REGISTRY,
+  RACI_REGISTRY,
+  FAMILY_PERSON_REGISTRY,
+  FAMILY_UNION_REGISTRY,
+  ALL_CHART_TYPES,
+  measureIndent,
+  extractColor,
+  OPTION_NOCOLON_RE,
+  GLOBAL_BOOLEANS,
+  legendSuppressed,
+  legendInlineRequested,
+  FILL_FAMILY_TOKENS,
+  fillModeFromToken,
+  fillModeFromOptions,
+  tryParseSharedOption,
+  parseFirstLine,
+  detectBadChartTypeDeclaration,
+  normalizeNumericToken,
+  stripQuotes,
+  tokenizeQuoteAware,
+  collectIndentedValues,
+  parseSeriesNames,
+  peelTrailingColorName,
+  peelTrailingCollapsedFlag,
+  peelRampColors,
+  parseMetadataRegion,
+  cutUnionMetadata,
+  splitNameAndMeta,
+  warnUnknownMetaKeys
 };
-//# sourceMappingURL=chunk-6DCOIN4W.js.map
+//# sourceMappingURL=chunk-A2ARDILY.js.map