@diagrammo/dgmo 0.6.3 → 0.7.1

package/src/palettes/index.ts

@@ -22,15 +22,17 @@ export {
   contrastText,
 } from './color-utils';
 
-// Re-export palette definitions
-export { nordPalette } from './nord';
-export { solarizedPalette } from './solarized';
+// Re-export palette definitions (alphabetical)
+export { boldPalette } from './bold';
 export { catppuccinPalette } from './catppuccin';
-export { rosePinePalette } from './rose-pine';
+export { draculaPalette } from './dracula';
 export { gruvboxPalette } from './gruvbox';
-export { tokyoNightPalette } from './tokyo-night';
+export { monokaiPalette } from './monokai';
+export { nordPalette } from './nord';
 export { oneDarkPalette } from './one-dark';
-export { boldPalette } from './bold';
+export { rosePinePalette } from './rose-pine';
+export { solarizedPalette } from './solarized';
+export { tokyoNightPalette } from './tokyo-night';
 
 // Re-export Mermaid bridge
 export { buildMermaidThemeVars, buildThemeCSS } from './mermaid-bridge';

package/src/palettes/monokai.ts

@@ -0,0 +1,60 @@
+import type { PaletteConfig } from './types';
+import { registerPalette } from './registry';
+
+// ============================================================
+// Monokai Palette Definition
+// Based on Monokai / Monokai Pro color scheme
+// ============================================================
+
+export const monokaiPalette: PaletteConfig = {
+  id: 'monokai',
+  name: 'Monokai',
+  light: {
+    bg: '#fafaf8',
+    surface: '#f0efe8',
+    overlay: '#e6e5de',
+    border: '#d4d3cc',
+    text: '#272822', // classic Monokai bg as text
+    textMuted: '#75715e', // comment
+    primary: '#49483e', // line highlight
+    secondary: '#f92672', // pink
+    accent: '#a6e22e', // green
+    destructive: '#f92672', // pink/red
+    colors: {
+      red: '#f92672', // Monokai pink-red
+      orange: '#fd971f',
+      yellow: '#e6db74',
+      green: '#a6e22e',
+      blue: '#5c7eab', // derived true blue
+      purple: '#ae81ff',
+      teal: '#4ea8a6', // muted from cyan
+      cyan: '#66d9ef',
+      gray: '#75715e', // comment
+    },
+  },
+  dark: {
+    bg: '#272822', // classic background
+    surface: '#2d2e27',
+    overlay: '#3e3d32', // line highlight
+    border: '#49483e',
+    text: '#f8f8f2', // foreground
+    textMuted: '#a6a28c', // brightened comment
+    primary: '#a6e22e', // green
+    secondary: '#66d9ef', // cyan
+    accent: '#f92672', // pink
+    destructive: '#f92672', // pink/red
+    colors: {
+      red: '#f92672',
+      orange: '#fd971f',
+      yellow: '#e6db74',
+      green: '#a6e22e',
+      blue: '#5c7eab', // derived true blue
+      purple: '#ae81ff',
+      teal: '#4ea8a6', // muted from cyan
+      cyan: '#66d9ef',
+      gray: '#75715e', // comment
+    },
+  },
+};
+
+registerPalette(monokaiPalette);

package/src/palettes/registry.ts

@@ -86,7 +86,9 @@ export function getPalette(id: string): PaletteConfig {
   return PALETTE_REGISTRY.get(id) ?? PALETTE_REGISTRY.get(DEFAULT_PALETTE_ID)!;
 }
 
-/** List all registered palettes (for the selector UI). */
+/** List all registered palettes alphabetically (for the selector UI). */
 export function getAvailablePalettes(): PaletteConfig[] {
-  return Array.from(PALETTE_REGISTRY.values());
+  return Array.from(PALETTE_REGISTRY.values()).sort((a, b) =>
+    a.name.localeCompare(b.name)
+  );
 }

package/src/sequence/parser.ts

@@ -6,7 +6,7 @@ import { inferParticipantType } from './participant-inference';
 import type { DgmoError } from '../diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
 import { parseArrow } from '../utils/arrows';
-import { measureIndent, extractColor, parsePipeMetadata } from '../utils/parsing';
+import { measureIndent, extractColor, parsePipeMetadata, MULTIPLE_PIPE_WARNING } from '../utils/parsing';
 import type { TagGroup } from '../utils/tag-groups';
 import { matchTagBlockHeading, validateTagValues } from '../utils/tag-groups';
 
@@ -237,12 +237,13 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
   const aliasMap = new Map<string, string>();
 
   /** Split pipe metadata from a line: "core | k: v" → { core, meta } */
-  const splitPipe = (text: string): { core: string; meta?: Record<string, string> } => {
+  const splitPipe = (text: string, ln?: number): { core: string; meta?: Record<string, string> } => {
     const idx = text.indexOf('|');
     if (idx < 0) return { core: text };
     const core = text.substring(0, idx).trimEnd();
     const segments = text.substring(idx).split('|');
-    const meta = parsePipeMetadata(segments, aliasMap);
+    const warnFn = ln != null ? () => pushWarning(ln, MULTIPLE_PIPE_WARNING) : undefined;
+    const meta = parsePipeMetadata(segments, aliasMap, warnFn);
     return Object.keys(meta).length > 0 ? { core, meta } : { core };
   };
 
@@ -287,7 +288,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       if (gpipeIdx >= 0) {
         const nameAndColor = groupName.substring(0, gpipeIdx).trimEnd();
         const segments = groupName.substring(gpipeIdx).split('|');
-        const meta = parsePipeMetadata(segments, aliasMap);
+        const meta = parsePipeMetadata(segments, aliasMap, () => pushWarning(lineNumber, MULTIPLE_PIPE_WARNING));
         if (Object.keys(meta).length > 0) groupMeta = meta;
         // Re-extract color from name part
         const colorSuffix = nameAndColor.match(/^(.+?)\(([^)]+)\)$/);
@@ -444,7 +445,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     }
 
     // Parse "Name is a type [aka Alias]" declarations (always top-level)
-    const { core: isACore, meta: isAMeta } = splitPipe(trimmed);
+    const { core: isACore, meta: isAMeta } = splitPipe(trimmed, lineNumber);
     const isAMatch = isACore.match(IS_A_PATTERN);
     if (isAMatch) {
       contentStarted = true;
@@ -491,7 +492,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     }
 
     // Parse standalone "Name position N" (no "is a" type)
-    const { core: posCore, meta: posMeta } = splitPipe(trimmed);
+    const { core: posCore, meta: posMeta } = splitPipe(trimmed, lineNumber);
     const posOnlyMatch = posCore.match(POSITION_ONLY_PATTERN);
     if (posOnlyMatch) {
       contentStarted = true;
@@ -523,7 +524,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
 
     // Colored participant declaration — "Name(color)" at any level
     // Color syntax is deprecated — emit warning and register without color
-    const { core: colorCore, meta: colorMeta } = splitPipe(trimmed);
+    const { core: colorCore, meta: colorMeta } = splitPipe(trimmed, lineNumber);
     const coloredMatch = colorCore.match(COLORED_PARTICIPANT_PATTERN);
     if (coloredMatch && !ARROW_PATTERN.test(colorCore)) {
       const id = coloredMatch[1];
@@ -554,7 +555,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     // Bare participant name — either inside an active group (indented) or top-level declaration
     // Supports pipe metadata: "  API | c: Gateway" or "Tapin2 | l:Park"
     {
-      const { core: bareCore, meta: bareMeta } = splitPipe(trimmed);
+      const { core: bareCore, meta: bareMeta } = splitPipe(trimmed, lineNumber);
       const inGroup = activeGroup && measureIndent(raw) > 0;
       if (/^\S+$/.test(bareCore) && !ARROW_PATTERN.test(bareCore) && (inGroup || !contentStarted || bareMeta)) {
         contentStarted = true;
@@ -600,7 +601,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     }
 
     // Split pipe metadata before arrow parsing (arrows use $ anchor)
-    const { core: arrowCore, meta: arrowMeta } = splitPipe(trimmed);
+    const { core: arrowCore, meta: arrowMeta } = splitPipe(trimmed, lineNumber);
 
     // Parse message lines first — arrows take priority over keywords
     // Reject "async" keyword prefix — use ~> instead

package/src/sequence/renderer.ts

@@ -1281,10 +1281,12 @@ export function renderSequenceDiagram(
 
   // Compute cumulative Y positions for each step, with section dividers as stable anchors
   const titleOffset = title ? TITLE_HEIGHT : 0;
+  const LEGEND_FIXED_GAP = 8;
+  const legendTopSpace = parsed.tagGroups.length > 0 ? LEGEND_HEIGHT + LEGEND_FIXED_GAP : 0;
   const groupOffset =
     groups.length > 0 ? GROUP_PADDING_TOP + GROUP_LABEL_SIZE : 0;
   const participantStartY =
-    TOP_MARGIN + titleOffset + PARTICIPANT_Y_OFFSET + groupOffset;
+    TOP_MARGIN + titleOffset + legendTopSpace + PARTICIPANT_Y_OFFSET + groupOffset;
   const lifelineStartY0 = participantStartY + PARTICIPANT_BOX_HEIGHT;
   const hasActors = participants.some((p) => p.type === 'actor');
   const messageStartOffset = MESSAGE_START_OFFSET + (hasActors ? 20 : 0);
@@ -1390,8 +1392,7 @@ export function renderSequenceDiagram(
     PARTICIPANT_BOX_HEIGHT +
     Math.max(lifelineLength, 40) +
     40;
-  const legendSpace = parsed.tagGroups.length > 0 ? LEGEND_HEIGHT : 0;
-  const totalHeight = contentHeight + legendSpace;
+  const totalHeight = contentHeight;
 
   const containerWidth = options?.exportWidth ?? container.getBoundingClientRect().width;
   const svgWidth = Math.max(totalWidth, containerWidth);
@@ -1570,7 +1571,7 @@ export function renderSequenceDiagram(
 
   // Render legend pills for tag groups
   if (parsed.tagGroups.length > 0) {
-    const legendY = contentHeight;
+    const legendY = TOP_MARGIN + titleOffset;
     const groupBg = isDark
       ? mix(palette.surface, palette.bg, 50)
       : mix(palette.surface, palette.bg, 30);

package/src/sharing.ts

@@ -10,6 +10,7 @@ export interface DiagramViewState {
   activeTagGroup?: string;
   collapsedGroups?: string[];
   swimlaneTagGroup?: string;
+  collapsedLanes?: string[];
   palette?: string;
   theme?: 'light' | 'dark';
 }
@@ -59,6 +60,10 @@ export function encodeDiagramUrl(
     hash += `&swim=${encodeURIComponent(options.viewState.swimlaneTagGroup)}`;
   }
 
+  if (options?.viewState?.collapsedLanes?.length) {
+    hash += `&cl=${encodeURIComponent(options.viewState.collapsedLanes.join(','))}`;
+  }
+
   if (options?.viewState?.palette && options.viewState.palette !== 'nord') {
     hash += `&pal=${encodeURIComponent(options.viewState.palette)}`;
   }
@@ -115,6 +120,9 @@ export function decodeDiagramUrl(hash: string): DecodedDiagramUrl {
     if (key === 'swim' && val) {
       viewState.swimlaneTagGroup = val;
     }
+    if (key === 'cl' && val) {
+      viewState.collapsedLanes = val.split(',').filter(Boolean);
+    }
     if (key === 'pal' && val) viewState.palette = val;
     if (key === 'th' && (val === 'light' || val === 'dark')) viewState.theme = val;
   }

package/src/sitemap/parser.ts

@@ -11,6 +11,7 @@ import {
   measureIndent,
   extractColor,
   parsePipeMetadata,
+  MULTIPLE_PIPE_WARNING,
   CHART_TYPE_RE,
   TITLE_RE,
   OPTION_RE,
@@ -360,7 +361,7 @@ export function parseSitemap(
     } else if (metadataMatch && indentStack.length === 0) {
       // Could be a node label containing ':'
       if (indent === 0) {
-        const node = parseNodeLabel(trimmed, lineNumber, palette, ++nodeCounter, aliasMap);
+        const node = parseNodeLabel(trimmed, lineNumber, palette, ++nodeCounter, aliasMap, pushWarning);
         attachNode(node, indent, indentStack, result);
         labelToNode.set(node.label.toLowerCase(), node);
       } else {
@@ -368,7 +369,7 @@ export function parseSitemap(
       }
     } else {
       // Node label — possibly with pipe-delimited metadata
-      const node = parseNodeLabel(trimmed, lineNumber, palette, ++nodeCounter, aliasMap);
+      const node = parseNodeLabel(trimmed, lineNumber, palette, ++nodeCounter, aliasMap, pushWarning);
       attachNode(node, indent, indentStack, result);
       labelToNode.set(node.label.toLowerCase(), node);
     }
@@ -430,11 +431,12 @@ function parseNodeLabel(
   palette: PaletteColors | undefined,
   counter: number,
   aliasMap: Map<string, string> = new Map(),
+  warnFn?: (line: number, msg: string) => void,
 ): SitemapNode {
   const segments = trimmed.split('|').map((s) => s.trim());
   const rawLabel = segments[0];
   const { label, color } = extractColor(rawLabel, palette);
-  const metadata = parsePipeMetadata(segments, aliasMap);
+  const metadata = parsePipeMetadata(segments, aliasMap, warnFn ? () => warnFn(lineNumber, MULTIPLE_PIPE_WARNING) : undefined);
 
   return {
     id: `node-${counter}`,

package/src/sitemap/renderer.ts

@@ -127,9 +127,9 @@ export function renderSitemap(
   const fixedTitle = fixedLegend && !!parsed.title;
   const fixedTitleH = fixedTitle ? TITLE_HEIGHT : 0;
   const legendReserveH = fixedLegend ? LEGEND_HEIGHT + LEGEND_FIXED_GAP : 0;
-  // Space reserved above content (title only), and below content (legend)
-  const fixedReserveTop = fixedTitleH;
-  const fixedReserveBottom = legendReserveH;
+  // Space reserved above content (title + legend)
+  const fixedReserveTop = fixedTitleH + legendReserveH;
+  const fixedReserveBottom = 0;
   // Title inside scaled group only when legend is NOT fixed
   const titleOffset = !fixedTitle && parsed.title ? TITLE_HEIGHT : 0;
 
@@ -543,7 +543,7 @@ export function renderSitemap(
     const legendParent = svg
       .append('g')
       .attr('class', 'sitemap-legend-fixed')
-      .attr('transform', `translate(0, ${height - DIAGRAM_PADDING - LEGEND_HEIGHT})`);
+      .attr('transform', `translate(0, ${DIAGRAM_PADDING + fixedTitleH})`);
     if (activeTagGroup) {
       legendParent.attr('data-legend-active', activeTagGroup.toLowerCase());
     }

package/src/utils/duration.ts

@@ -0,0 +1,212 @@
+// ============================================================
+// Duration & Business Day Arithmetic
+// ============================================================
+
+import type { Duration, DurationUnit, GanttHolidays, Offset, Weekday } from '../gantt/types';
+
+// ── Weekday constants ─────────────────────────────────────
+
+/** JS Date.getDay() → Weekday mapping (0=Sun, 1=Mon, ..., 6=Sat) */
+const JS_DAY_TO_WEEKDAY: Weekday[] = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+/**
+ * Check if a date is a workday (not a weekend and not a holiday).
+ */
+export function isWorkday(
+  date: Date,
+  workweek: Weekday[],
+  holidaySet: Set<string>,
+): boolean {
+  const dayName = JS_DAY_TO_WEEKDAY[date.getDay()];
+  if (!workweek.includes(dayName)) return false;
+  if (holidaySet.has(formatDateKey(date))) return false;
+  return true;
+}
+
+/**
+ * Format a Date as YYYY-MM-DD for holiday set lookups.
+ */
+export function formatDateKey(date: Date): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+/**
+ * Build a Set of holiday date strings for efficient lookup.
+ * Expands date ranges into individual dates.
+ */
+export function buildHolidaySet(holidays: GanttHolidays): Set<string> {
+  const set = new Set<string>();
+
+  for (const h of holidays.dates) {
+    set.add(h.date);
+  }
+
+  for (const range of holidays.ranges) {
+    const start = new Date(range.startDate + 'T00:00:00');
+    const end = new Date(range.endDate + 'T00:00:00');
+    const current = new Date(start);
+    while (current <= end) {
+      set.add(formatDateKey(current));
+      current.setDate(current.getDate() + 1);
+    }
+  }
+
+  return set;
+}
+
+/**
+ * Add business days to a start date, skipping weekends and holidays.
+ *
+ * For fractional business days, rounds to the nearest whole day first.
+ * Handles both positive amounts (forward) and zero (returns start date).
+ */
+export function addBusinessDays(
+  startDate: Date,
+  count: number,
+  workweek: Weekday[],
+  holidaySet: Set<string>,
+  direction: 1 | -1 = 1,
+): Date {
+  const days = Math.round(Math.abs(count));
+  if (days === 0) return new Date(startDate);
+
+  const current = new Date(startDate);
+  let remaining = days;
+
+  while (remaining > 0) {
+    current.setDate(current.getDate() + direction);
+    if (isWorkday(current, workweek, holidaySet)) {
+      remaining--;
+    }
+  }
+
+  return current;
+}
+
+/**
+ * Add a gantt duration to a start date, producing an end date.
+ *
+ * Calendar units (d, w, m, q, y) ignore holidays.
+ * Business day units (bd) skip weekends and holidays.
+ */
+export function addGanttDuration(
+  startDate: Date,
+  duration: Duration,
+  holidays: GanttHolidays,
+  holidaySet: Set<string>,
+  direction: 1 | -1 = 1,
+): Date {
+  const { amount, unit } = duration;
+
+  switch (unit) {
+    case 'bd':
+      return addBusinessDays(startDate, amount, holidays.workweek, holidaySet, direction);
+
+    case 'd': {
+      const result = new Date(startDate);
+      result.setDate(result.getDate() + Math.round(amount) * direction);
+      return result;
+    }
+
+    case 'w': {
+      const result = new Date(startDate);
+      result.setDate(result.getDate() + Math.round(amount * 7) * direction);
+      return result;
+    }
+
+    case 'm': {
+      const result = new Date(startDate);
+      const wholeMonths = direction === -1 ? Math.round(amount) : Math.floor(amount);
+      const fractionalDays = direction === -1 ? 0 : Math.round((amount - wholeMonths) * 30);
+      result.setMonth(result.getMonth() + wholeMonths * direction);
+      if (fractionalDays > 0) {
+        result.setDate(result.getDate() + fractionalDays * direction);
+      }
+      return result;
+    }
+
+    case 'q': {
+      const result = new Date(startDate);
+      const totalMonths = amount * 3;
+      const wholeMonths = direction === -1 ? Math.round(totalMonths) : Math.floor(totalMonths);
+      const fractionalDays = direction === -1 ? 0 : Math.round((totalMonths - wholeMonths) * 30);
+      result.setMonth(result.getMonth() + wholeMonths * direction);
+      if (fractionalDays > 0) {
+        result.setDate(result.getDate() + fractionalDays * direction);
+      }
+      return result;
+    }
+
+    case 'y': {
+      const result = new Date(startDate);
+      const wholeYears = direction === -1 ? Math.round(amount) : Math.floor(amount);
+      const fractionalMonths = direction === -1 ? 0 : Math.round((amount - wholeYears) * 12);
+      result.setFullYear(result.getFullYear() + wholeYears * direction);
+      if (fractionalMonths > 0) {
+        result.setMonth(result.getMonth() + fractionalMonths * direction);
+      }
+      return result;
+    }
+  }
+}
+
+/**
+ * Parse a duration string like "3bd" or "5d".
+ */
+export function parseDuration(s: string): Duration | null {
+  const match = s.trim().match(/^(\d+(?:\.\d+)?)(d|bd|w|m|q|y)$/);
+  if (!match) return null;
+  return { amount: parseFloat(match[1]), unit: match[2] as DurationUnit };
+}
+
+/**
+ * Parse an offset string like "5bd", "-3bd", or "0d".
+ * Returns null if the format is invalid.
+ * Explicit '+' prefix (e.g. "+5bd") returns null — caller should warn.
+ */
+export function parseOffset(value: string): Offset | null {
+  const trimmed = value.trim();
+  let direction: 1 | -1 = 1;
+  let remainder = trimmed;
+
+  if (trimmed.startsWith('-')) {
+    direction = -1;
+    remainder = trimmed.slice(1);
+  } else if (trimmed.startsWith('+')) {
+    return null; // explicit + is not supported
+  }
+
+  const duration = parseDuration(remainder);
+  if (!duration) return null;
+  return { duration, direction };
+}
+
+/**
+ * Parse a date string (YYYY-MM-DD, YYYY-MM, or YYYY) into a Date object.
+ * Always returns midnight local time on the first available day.
+ */
+export function parseGanttDate(s: string): Date {
+  const parts = s.split('-').map(p => parseInt(p, 10));
+  const year = parts[0];
+  const month = parts.length >= 2 ? parts[1] - 1 : 0; // JS months are 0-based
+  const day = parts.length >= 3 ? parts[2] : 1;
+  return new Date(year, month, day);
+}
+
+/**
+ * Format a Date as YYYY-MM-DD string.
+ */
+export function formatGanttDate(date: Date): string {
+  return formatDateKey(date);
+}
+
+/**
+ * Calculate the difference in calendar days between two dates.
+ */
+export function daysBetween(a: Date, b: Date): number {
+  const msPerDay = 86400000;
+  return Math.round((b.getTime() - a.getTime()) / msPerDay);
+}

package/src/utils/legend-constants.ts

@@ -16,6 +16,7 @@ export const LEGEND_ENTRY_TRAIL = 8;
 export const LEGEND_GROUP_GAP = 12;
 export const LEGEND_EYE_SIZE = 14;
 export const LEGEND_EYE_GAP = 6;
+export const LEGEND_ICON_W = 20;
 
 // Eye icon SVG paths (14×14 viewBox)
 // Present only in org and sitemap legends (metadata visibility toggle)

package/src/utils/parsing.ts

@@ -118,23 +118,34 @@ export function parseSeriesNames(
   return { series, names, nameColors, newIndex };
 }
 
-/** Parse pipe-delimited metadata from segments after the first (name) segment. */
+/** Warning message for multiple pipes on a single line. */
+export const MULTIPLE_PIPE_WARNING =
+  'Use a single "|" to start metadata, then separate items with commas.';
+
+/**
+ * Parse metadata from segments after the first (name) segment.
+ * A single `|` separates the label from metadata; items after the pipe are comma-delimited.
+ * Multiple pipes are treated as commas for backward compatibility but trigger a warning.
+ */
 export function parsePipeMetadata(
   segments: string[],
   aliasMap: Map<string, string> = new Map(),
+  warnMultiplePipes?: () => void,
 ): Record<string, string> {
+  if (segments.length > 2 && warnMultiplePipes) {
+    warnMultiplePipes();
+  }
   const metadata: Record<string, string> = {};
-  for (let j = 1; j < segments.length; j++) {
-    for (const part of segments[j].split(',')) {
-      const trimmedPart = part.trim();
-      if (!trimmedPart) continue;
-      const colonIdx = trimmedPart.indexOf(':');
-      if (colonIdx > 0) {
-        const rawKey = trimmedPart.substring(0, colonIdx).trim().toLowerCase();
-        const key = aliasMap.get(rawKey) ?? rawKey;
-        const value = trimmedPart.substring(colonIdx + 1).trim();
-        metadata[key] = value;
-      }
+  const raw = segments.slice(1).join(',');
+  for (const part of raw.split(',')) {
+    const trimmedPart = part.trim();
+    if (!trimmedPart) continue;
+    const colonIdx = trimmedPart.indexOf(':');
+    if (colonIdx > 0) {
+      const rawKey = trimmedPart.substring(0, colonIdx).trim().toLowerCase();
+      const key = aliasMap.get(rawKey) ?? rawKey;
+      const value = trimmedPart.substring(colonIdx + 1).trim();
+      metadata[key] = value;
     }
   }
   return metadata;