@diagrammo/dgmo 0.92.0 → 0.93.0

package/dist/redraw-T324XAF3.js

@@ -0,0 +1,1698 @@
+import {
+  DAY_MS,
+  applyOrdinalTemplate,
+  dayKey,
+  dayStart,
+  formatCompound,
+  formatCount,
+  formatDateShort,
+  formatFooter,
+  formatHuman,
+  formatWordsDetail,
+  now,
+  ordinalFor,
+  sameDay,
+  splitClockSeconds
+} from "./chunk-UCHZJJIT.js";
+
+// src/utils/svg-embed.ts
+function normalizeSvgForEmbed(input, opts = {}) {
+  let svg = input;
+  if ((opts.background ?? "transparent") === "transparent") {
+    svg = stripRootBackground(svg);
+  }
+  const rootMatch = svg.match(/<svg[^>]*>/);
+  const rootTag = rootMatch?.[0] ?? "";
+  if (rootTag && !rootTag.includes("viewBox")) {
+    const wh = rootTag.match(/width="(\d+)"[^>]*height="(\d+)"/);
+    if (wh) {
+      svg = svg.replace(/<svg/, `<svg viewBox="0 0 ${wh[1]} ${wh[2]}"`);
+    }
+  }
+  const tight = computeBBox(svg);
+  if (tight && tight.width > 0 && tight.height > 0) {
+    const pad = 16;
+    const x = tight.x - pad;
+    const y = tight.y - pad;
+    const w = tight.width + pad * 2;
+    const h = tight.height + pad * 2;
+    const canvas = readViewBox(svg);
+    const TOL = 2;
+    const MIN_COVERAGE = 0.5;
+    const trustworthy = !canvas || x >= canvas.x - TOL && y >= canvas.y - TOL && x + w <= canvas.x + canvas.width + TOL && y + h <= canvas.y + canvas.height + TOL && w >= canvas.width * MIN_COVERAGE && h >= canvas.height * MIN_COVERAGE;
+    if (trustworthy) {
+      const vb = `${x} ${y} ${w} ${h}`;
+      svg = svg.replace(/(<svg[^>]*?)viewBox="[^"]*"/, `$1viewBox="${vb}"`);
+    }
+  }
+  svg = svg.replace(/(<svg[^>]*?) width="[^"]*"/g, "$1");
+  svg = svg.replace(/(<svg[^>]*?) height="[^"]*"/g, "$1");
+  svg = svg.replace(/<svg\s{2,}/g, "<svg ");
+  return svg;
+}
+function stripRootBackground(svg) {
+  const rootMatch = svg.match(/<svg\b[^>]*>/);
+  if (!rootMatch) return svg;
+  const rootTag = rootMatch[0];
+  const styleMatch = rootTag.match(/style="([^"]*)"/);
+  const style = styleMatch?.[1] ?? "";
+  const bgMatch = style.match(/background:\s*([^;]+)/);
+  const bgColor = bgMatch ? normalizeColor(bgMatch[1]) : null;
+  const canvas = rootCanvas(rootTag, svg);
+  let out = svg;
+  if (bgMatch) {
+    const cleaned = style.replace(/background:\s*[^;]+;?/i, "").replace(/\s{2,}/g, " ").replace(/;\s*$/, "").trim();
+    const newRoot = (cleaned ? rootTag.replace(/style="[^"]*"/, `style="${cleaned}"`) : rootTag.replace(/\s*style="[^"]*"/, "")).replace(/<svg\s{2,}/, "<svg ");
+    out = out.replace(rootTag, newRoot);
+  }
+  if (bgColor && canvas) {
+    out = out.replace(
+      /<rect\b[^>]*?\/?>(?:\s*<\/rect>)?/g,
+      (m) => isFullCanvasFill(m, bgColor, canvas) ? "" : m
+    );
+  }
+  return out;
+}
+function isFullCanvasFill(tag, bgColor, canvas) {
+  const fm = tag.match(/\bfill="([^"]*)"/);
+  if (!fm || normalizeColor(fm[1]) !== bgColor) return false;
+  const w = numAttr(tag, "width");
+  const h = numAttr(tag, "height");
+  if (w === null || h === null) return false;
+  const x = numAttr(tag, "x") ?? 0;
+  const y = numAttr(tag, "y") ?? 0;
+  const T = 1.5;
+  return Math.abs(x) <= T && Math.abs(y) <= T && Math.abs(w - canvas.w) <= T && Math.abs(h - canvas.h) <= T;
+}
+function rootCanvas(rootTag, svg) {
+  const wm = rootTag.match(/\bwidth="([\d.]+)"/);
+  const hm = rootTag.match(/\bheight="([\d.]+)"/);
+  if (wm && hm) return { w: parseFloat(wm[1]), h: parseFloat(hm[1]) };
+  const vb = readViewBox(svg);
+  return vb ? { w: vb.width, h: vb.height } : null;
+}
+function numAttr(tag, name) {
+  const m = tag.match(new RegExp(`\\b${name}="([^"]*)"`));
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  return Number.isFinite(n) ? n : null;
+}
+function normalizeColor(c) {
+  const s = c.trim().toLowerCase();
+  const hex6 = s.match(/^#([0-9a-f]{6})$/);
+  if (hex6) {
+    const n = parseInt(hex6[1], 16);
+    return `${n >> 16 & 255},${n >> 8 & 255},${n & 255}`;
+  }
+  const hex3 = s.match(/^#([0-9a-f]{3})$/);
+  if (hex3) {
+    const [r, g, b] = hex3[1].split("").map((ch) => parseInt(ch + ch, 16));
+    return `${r},${g},${b}`;
+  }
+  const rgb = s.match(/^rgba?\(\s*(\d+)[,\s]+(\d+)[,\s]+(\d+)/);
+  if (rgb) return `${+rgb[1]},${+rgb[2]},${+rgb[3]}`;
+  return null;
+}
+function readViewBox(svg) {
+  const m = svg.match(/<svg[^>]*?\bviewBox="([^"]+)"/);
+  if (!m) return null;
+  const n = m[1].trim().split(/[\s,]+/).map(Number);
+  if (n.length !== 4 || n.some((v) => !Number.isFinite(v)) || n[2] <= 0 || n[3] <= 0)
+    return null;
+  return { x: n[0], y: n[1], width: n[2], height: n[3] };
+}
+function computeBBox(svg) {
+  const xs = [];
+  const ys = [];
+  function push(x, y) {
+    if (Number.isFinite(x) && Number.isFinite(y)) {
+      xs.push(x);
+      ys.push(y);
+    }
+  }
+  function attr(tag, name) {
+    const m = tag.match(new RegExp(`\\b${name}="([^"]*)"`));
+    if (!m) return null;
+    const n = parseFloat(m[1]);
+    return Number.isFinite(n) ? n : null;
+  }
+  for (const m of svg.matchAll(/<rect\b[^>]*?\/?>/g)) {
+    const tag = m[0];
+    const x = attr(tag, "x");
+    const y = attr(tag, "y");
+    const w = attr(tag, "width");
+    const h = attr(tag, "height");
+    if (x !== null && y !== null && w !== null && h !== null) {
+      push(x, y);
+      push(x + w, y + h);
+    }
+  }
+  for (const m of svg.matchAll(/<line\b[^>]*?\/?>/g)) {
+    const tag = m[0];
+    const x1 = attr(tag, "x1");
+    const y1 = attr(tag, "y1");
+    const x2 = attr(tag, "x2");
+    const y2 = attr(tag, "y2");
+    if (x1 !== null && y1 !== null && x2 !== null && y2 !== null) {
+      push(x1, y1);
+      push(x2, y2);
+    }
+  }
+  for (const m of svg.matchAll(/<circle\b[^>]*?\/?>/g)) {
+    const tag = m[0];
+    const cx = attr(tag, "cx");
+    const cy = attr(tag, "cy");
+    const r = attr(tag, "r");
+    if (cx !== null && cy !== null && r !== null) {
+      push(cx - r, cy - r);
+      push(cx + r, cy + r);
+    }
+  }
+  for (const m of svg.matchAll(/<ellipse\b[^>]*?\/?>/g)) {
+    const tag = m[0];
+    const cx = attr(tag, "cx");
+    const cy = attr(tag, "cy");
+    const rx = attr(tag, "rx");
+    const ry = attr(tag, "ry");
+    if (cx !== null && cy !== null && rx !== null && ry !== null) {
+      push(cx - rx, cy - ry);
+      push(cx + rx, cy + ry);
+    }
+  }
+  for (const m of svg.matchAll(/<text\b([^>]*?)>([\s\S]*?)<\/text>/g)) {
+    const tag = `<text${m[1]}>`;
+    const text = m[2].replace(/<[^>]+>/g, "");
+    const x = attr(tag, "x");
+    const y = attr(tag, "y");
+    if (x !== null && y !== null) {
+      const fontSize = attr(tag, "font-size") ?? (() => {
+        const s = tag.match(/font-size:\s*([\d.]+)/);
+        return s ? parseFloat(s[1]) : 14;
+      })();
+      const w = text.length * fontSize * 0.5;
+      const anchor = tag.match(/\btext-anchor="([^"]*)"/)?.[1] ?? "start";
+      const left = anchor === "middle" ? x - w / 2 : anchor === "end" ? x - w : x;
+      const right = anchor === "middle" ? x + w / 2 : anchor === "end" ? x : x + w;
+      push(left, y - fontSize * 0.9);
+      push(right, y + fontSize * 0.25);
+    }
+  }
+  for (const m of svg.matchAll(/<path\b[^>]*?>/g)) {
+    const tag = m[0];
+    if (tag.includes("data-embed-ignore-bbox")) continue;
+    const dm = tag.match(/\bd="([^"]+)"/);
+    if (!dm) continue;
+    const d = dm[1];
+    const nums = d.match(/-?\d+(?:\.\d+)?/g);
+    if (!nums) continue;
+    for (let i = 0; i + 1 < nums.length; i += 2) {
+      push(parseFloat(nums[i]), parseFloat(nums[i + 1]));
+    }
+  }
+  for (const m of svg.matchAll(
+    /<(?:polygon|polyline)\b[^>]*?\bpoints="([^"]+)"/g
+  )) {
+    const nums = m[1].match(/-?\d+(?:\.\d+)?/g);
+    if (!nums) continue;
+    for (let i = 0; i + 1 < nums.length; i += 2) {
+      push(parseFloat(nums[i]), parseFloat(nums[i + 1]));
+    }
+  }
+  if (xs.length === 0 || ys.length === 0) return null;
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+
+// src/countdown/renderer.ts
+import * as d3Selection from "d3-selection";
+
+// src/fonts.ts
+var FONT_FAMILY = "Inter, system-ui, Avenir, Helvetica, Arial, sans-serif";
+var MONO_FAMILY = "ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace";
+
+// src/colors.ts
+var nord = {
+  // Polar Night (dark)
+  nord0: "#2e3440",
+  nord1: "#3b4252",
+  nord2: "#434c5e",
+  nord3: "#4c566a",
+  // Snow Storm (light)
+  nord4: "#d8dee9",
+  nord5: "#e5e9f0",
+  nord6: "#eceff4",
+  // Frost (accent blues)
+  nord7: "#8fbcbb",
+  nord8: "#88c0d0",
+  nord9: "#81a1c1",
+  nord10: "#5e81ac",
+  // Aurora (colors)
+  nord11: "#bf616a",
+  // red
+  nord12: "#d08770",
+  // orange
+  nord13: "#ebcb8b",
+  // yellow
+  nord14: "#a3be8c",
+  // green
+  nord15: "#b48ead"
+  // purple
+};
+var colorNames = {
+  red: nord.nord11,
+  orange: nord.nord12,
+  yellow: nord.nord13,
+  green: nord.nord14,
+  blue: nord.nord10,
+  purple: nord.nord15,
+  teal: nord.nord7,
+  cyan: nord.nord8,
+  gray: nord.nord3,
+  black: nord.nord0,
+  white: nord.nord6
+};
+var RECOGNIZED_COLOR_NAMES = Object.freeze([
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "teal",
+  "cyan",
+  "gray",
+  "black",
+  "white"
+]);
+var CATEGORICAL_COLOR_ORDER = Object.freeze([
+  "red",
+  "green",
+  "blue",
+  "yellow",
+  "teal",
+  "purple",
+  "orange",
+  "cyan"
+]);
+function isRecognizedColorName(name) {
+  return Object.prototype.hasOwnProperty.call(colorNames, name.toLowerCase());
+}
+function resolveColor(color, palette) {
+  if (!color) return null;
+  if (color.startsWith("#")) return null;
+  const lower = color.toLowerCase();
+  if (!isRecognizedColorName(lower)) return null;
+  if (palette) {
+    const named = palette.colors[lower];
+    if (named) return named;
+  }
+  return colorNames[lower] ?? null;
+}
+var INVALID_CSS_COLOR_HEX = Object.freeze({
+  pink: "#ffc0cb",
+  hotpink: "#ff69b4",
+  deeppink: "#ff1493",
+  lightpink: "#ffb6c1",
+  palevioletred: "#db7093",
+  crimson: "#dc143c",
+  scarlet: "#ff2400",
+  firebrick: "#b22222",
+  darkred: "#8b0000",
+  maroon: "#800000",
+  salmon: "#fa8072",
+  lightsalmon: "#ffa07a",
+  darksalmon: "#e9967a",
+  coral: "#ff7f50",
+  lightcoral: "#f08080",
+  tomato: "#ff6347",
+  orangered: "#ff4500",
+  darkorange: "#ff8c00",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  darkgoldenrod: "#b8860b",
+  khaki: "#f0e68c",
+  darkkhaki: "#bdb76b",
+  amber: "#ffbf00",
+  lavender: "#e6e6fa",
+  violet: "#ee82ee",
+  magenta: "#ff00ff",
+  fuchsia: "#ff00ff",
+  orchid: "#da70d6",
+  plum: "#dda0dd",
+  indigo: "#4b0082",
+  navy: "#000080",
+  midnightblue: "#191970",
+  darkblue: "#00008b",
+  mediumblue: "#0000cd",
+  royalblue: "#4169e1",
+  cornflowerblue: "#6495ed",
+  dodgerblue: "#1e90ff",
+  deepskyblue: "#00bfff",
+  skyblue: "#87ceeb",
+  lightskyblue: "#87cefa",
+  lightblue: "#add8e6",
+  powderblue: "#b0e0e6",
+  steelblue: "#4682b4",
+  slateblue: "#6a5acd",
+  cadetblue: "#5f9ea0",
+  turquoise: "#40e0d0",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  lightgreen: "#90ee90",
+  palegreen: "#98fb98",
+  seagreen: "#2e8b57",
+  mediumseagreen: "#3cb371",
+  forestgreen: "#228b22",
+  darkgreen: "#006400",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  darkolivegreen: "#556b2f",
+  chartreuse: "#7fff00",
+  lawngreen: "#7cfc00",
+  springgreen: "#00ff7f",
+  greenyellow: "#adff2f",
+  brown: "#a52a2a",
+  sienna: "#a0522d",
+  chocolate: "#d2691e",
+  peru: "#cd853f",
+  tan: "#d2b48c",
+  beige: "#f5f5dc",
+  wheat: "#f5deb3",
+  ivory: "#fffff0",
+  silver: "#c0c0c0",
+  lightgray: "#d3d3d3",
+  lightgrey: "#d3d3d3",
+  darkgray: "#a9a9a9",
+  darkgrey: "#a9a9a9",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  slategray: "#708090",
+  slategrey: "#708090",
+  gainsboro: "#dcdcdc",
+  grey: "#808080"
+});
+var seriesColors = [
+  nord.nord10,
+  // blue
+  nord.nord14,
+  // green
+  nord.nord13,
+  // yellow
+  nord.nord12,
+  // orange
+  nord.nord15,
+  // purple
+  nord.nord11,
+  // red
+  nord.nord7,
+  // teal
+  nord.nord8
+  // light blue
+];
+
+// src/palettes/color-utils.ts
+var MIX_CACHE = /* @__PURE__ */ new Map();
+var MIX_CACHE_MAX = 5e3;
+function mix(a, b, pct) {
+  const key = `${a}|${b}|${pct}`;
+  const cached = MIX_CACHE.get(key);
+  if (cached !== void 0) return cached;
+  const parse = (h) => {
+    const r = h.replace("#", "");
+    const f = r.length === 3 ? [...r].map((c2) => c2 + c2).join("") : r;
+    return [
+      parseInt(f.substring(0, 2), 16),
+      parseInt(f.substring(2, 4), 16),
+      parseInt(f.substring(4, 6), 16)
+    ];
+  };
+  const [ar, ag, ab] = parse(a), [br, bg, bb] = parse(b), t = pct / 100;
+  const c = (x, y) => Math.round(x * t + y * (1 - t)).toString(16).padStart(2, "0");
+  const out = `#${c(ar, br)}${c(ag, bg)}${c(ab, bb)}`;
+  if (MIX_CACHE.size >= MIX_CACHE_MAX) MIX_CACHE.clear();
+  MIX_CACHE.set(key, out);
+  return out;
+}
+var APCA = {
+  mainTRC: 2.4,
+  sRco: 0.2126729,
+  sGco: 0.7151522,
+  sBco: 0.072175,
+  normBG: 0.56,
+  normTXT: 0.57,
+  revTXT: 0.62,
+  revBG: 0.65,
+  blkThrs: 0.022,
+  blkClmp: 1.414,
+  scale: 1.14,
+  loOffset: 0.027,
+  deltaYmin: 5e-4,
+  loClip: 0.1
+};
+function apcaY(hex) {
+  const raw = hex.replace("#", "");
+  const full = raw.length === 3 ? [...raw].map((c) => c + c).join("") : raw;
+  const [r, g, b] = [0, 2, 4].map(
+    (i) => (parseInt(full.substring(i, i + 2), 16) / 255) ** APCA.mainTRC
+  );
+  return APCA.sRco * r + APCA.sGco * g + APCA.sBco * b;
+}
+function apcaContrast(text, bg) {
+  const clamp = (y) => y > APCA.blkThrs ? y : y + (APCA.blkThrs - y) ** APCA.blkClmp;
+  const txtY = clamp(apcaY(text));
+  const bgY = clamp(apcaY(bg));
+  if (Math.abs(bgY - txtY) < APCA.deltaYmin) return 0;
+  if (bgY > txtY) {
+    const sapc2 = (bgY ** APCA.normBG - txtY ** APCA.normTXT) * APCA.scale;
+    return sapc2 < APCA.loClip ? 0 : (sapc2 - APCA.loOffset) * 100;
+  }
+  const sapc = (bgY ** APCA.revBG - txtY ** APCA.revTXT) * APCA.scale;
+  return sapc > -APCA.loClip ? 0 : (sapc + APCA.loOffset) * 100;
+}
+function contrastText(bg, lightText, darkText) {
+  return Math.abs(apcaContrast(darkText, bg)) >= Math.abs(apcaContrast(lightText, bg)) ? darkText : lightText;
+}
+function themeBaseBg(palette, isDark) {
+  return isDark ? palette.surface : palette.bg;
+}
+function getSeriesColors(palette) {
+  const c = palette.colors;
+  return CATEGORICAL_COLOR_ORDER.map((name) => c[name]);
+}
+
+// src/utils/safe-href.ts
+var ALLOWED_SCHEMES = ["http", "https", "mailto"];
+var SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
+var LEADING_TRIM_RE = /^[\x00-\x20]+/;
+var URL_STRIP_RE = /[\x09\x0A\x0D]/g;
+function safeHref(url) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.replace(URL_STRIP_RE, "").replace(LEADING_TRIM_RE, "");
+  if (trimmed.length === 0) return null;
+  const match = SCHEME_RE.exec(trimmed);
+  if (!match) {
+    return url;
+  }
+  const scheme = match[1].toLowerCase();
+  if (ALLOWED_SCHEMES.includes(scheme)) {
+    return url;
+  }
+  return null;
+}
+
+// src/utils/inline-markdown.ts
+function parseInlineMarkdown(text) {
+  const spans = [];
+  const regex = /\*\*(.+?)\*\*|__(.+?)__|\*(.+?)\*|_(.+?)_|`(.+?)`|\[(.+?)\]\((.+?)\)|(https?:\/\/[^\s)>\]]+|www\.[^\s)>\]]+)|([^*_`[]+?(?=https?:\/\/|www\.|$)|[^*_`[]+)/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match[1])
+      spans.push({ text: match[1], bold: true });
+    else if (match[2])
+      spans.push({ text: match[2], bold: true });
+    else if (match[3])
+      spans.push({ text: match[3], italic: true });
+    else if (match[4])
+      spans.push({ text: match[4], italic: true });
+    else if (match[5])
+      spans.push({ text: match[5], code: true });
+    else if (match[6])
+      spans.push({
+        text: match[6],
+        ...match[7] !== void 0 && { href: match[7] }
+      });
+    else if (match[8]) {
+      const url = match[8];
+      const href = url.startsWith("www.") ? `https://${url}` : url;
+      spans.push({ text: url, href });
+    } else if (match[9]) spans.push({ text: match[9] });
+  }
+  return spans;
+}
+var BARE_URL_MAX_DISPLAY = 35;
+function truncateBareUrl(url) {
+  const stripped = url.replace(/^https?:\/\//, "").replace(/^www\./, "");
+  if (stripped.length <= BARE_URL_MAX_DISPLAY) return stripped;
+  return stripped.slice(0, BARE_URL_MAX_DISPLAY - 1) + "\u2026";
+}
+function stripInlineMarkdown(text) {
+  return text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1").replace(
+    /https?:\/\/[^\s)>\]]+|www\.[^\s)>\]]+/g,
+    (u) => truncateBareUrl(u)
+  ).replace(/\*\*|__|[*_`]/g, "");
+}
+function renderInlineText(textEl, text, palette, fontSize) {
+  const spans = parseInlineMarkdown(text);
+  for (const span of spans) {
+    if (span.href) {
+      const isBareUrl = span.text === span.href || `https://${span.text}` === span.href;
+      const display = isBareUrl ? truncateBareUrl(span.text) : span.text;
+      const safe = safeHref(span.href);
+      if (safe !== null) {
+        const a = textEl.append("a").attr("href", safe);
+        a.append("tspan").text(display).attr("fill", palette.primary).style("text-decoration", "underline");
+      } else {
+        textEl.append("tspan").text(display).attr("fill", palette.primary).style("text-decoration", "underline");
+      }
+    } else {
+      const tspan = textEl.append("tspan").text(span.text);
+      if (span.bold) tspan.attr("font-weight", "bold");
+      if (span.italic) tspan.attr("font-style", "italic");
+      if (span.code) {
+        tspan.attr("font-family", MONO_FAMILY);
+        if (fontSize) tspan.attr("font-size", fontSize - 1);
+      }
+    }
+  }
+}
+
+// src/utils/wrapped-desc.ts
+var BULLET_PREFIX = "\u2022 ";
+var BULLET_INDENT_CHARS = 2;
+var HARD_BREAK = "\\";
+function reflowDescriptionLines(lines) {
+  const blocks = [];
+  let open = null;
+  let gapPending = false;
+  let breakPending = false;
+  const openBlock = (kind, text) => {
+    const block = {
+      kind,
+      segments: [text],
+      gapBefore: gapPending && blocks.length > 0
+    };
+    blocks.push(block);
+    gapPending = false;
+    return block;
+  };
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (!line) {
+      open = null;
+      breakPending = false;
+      gapPending = blocks.length > 0;
+      continue;
+    }
+    const hard = line.endsWith(HARD_BREAK);
+    const text = hard ? line.slice(0, -1).trimEnd() : line;
+    if (!text) {
+      breakPending = hard;
+      continue;
+    }
+    if (text.startsWith(BULLET_PREFIX)) {
+      open = openBlock("bullet", text.slice(BULLET_PREFIX.length));
+    } else if (open) {
+      if (breakPending) open.segments.push(text);
+      else open.segments[open.segments.length - 1] += ` ${text}`;
+    } else {
+      open = openBlock("plain", text);
+    }
+    breakPending = hard;
+  }
+  return blocks;
+}
+function wrapDescriptionLines(lines, charsPerLine, lengthFn = (s) => s.length) {
+  const measure = (s) => lengthFn(stripInlineMarkdown(s));
+  const result = [];
+  for (const block of reflowDescriptionLines(lines)) {
+    if (block.gapBefore && result.length > 0)
+      result.push({ text: "", kind: "plain" });
+    if (block.kind === "plain") {
+      for (const segment of block.segments)
+        for (const w of wrapPlainLine(segment, charsPerLine, measure))
+          result.push({ text: w, kind: "plain" });
+      continue;
+    }
+    const bodyLimit = Math.max(8, charsPerLine - BULLET_INDENT_CHARS);
+    let first = true;
+    for (const segment of block.segments) {
+      for (const w of wrapPlainLine(segment, bodyLimit, measure)) {
+        result.push({ text: w, kind: first ? "bullet-first" : "bullet-cont" });
+        first = false;
+      }
+    }
+  }
+  return result;
+}
+function wrapPlainLine(line, charsPerLine, lengthFn) {
+  const words = line.split(/\s+/);
+  const result = [];
+  let current = "";
+  for (const word of words) {
+    const test = current ? `${current} ${word}` : word;
+    if (lengthFn(test) > charsPerLine && current) {
+      result.push(current);
+      current = word;
+    } else {
+      current = test;
+    }
+  }
+  if (current) result.push(current);
+  return result;
+}
+
+// src/countdown/renderer.ts
+function bakedHero(parsed, now2) {
+  const resolved = parsed.resolvedMs;
+  if (resolved === null) return "\u2014";
+  const tz = parsed.tz;
+  const remaining = resolved - now2;
+  if (!parsed.rule && remaining <= 0) {
+    if (parsed.expired !== null) return parsed.expired;
+    const elapsed = -remaining;
+    if (elapsed <= 0) return "Now!";
+    if (parsed.units === "compound" || parsed.units === "human") {
+      const [a, b] = parsed.hasTime ? [resolved, now2] : [dayStart(resolved, tz), dayStart(now2, tz)];
+      return `${formatCompound(a, b, 2, tz)} ago`;
+    }
+    const bu = parsed.units === "full" || parsed.units === "clock" ? "days" : parsed.units;
+    return `${formatCount(elapsed, { units: bu, round: parsed.round, fields: parsed.fields })} ago`;
+  }
+  if (parsed.rule && sameDay(resolved, now2, tz))
+    return parsed.onDay ?? "Today!";
+  if (parsed.units === "human") {
+    const [hn, ht] = parsed.hasTime ? [now2, resolved] : [dayStart(now2, tz), dayStart(resolved, tz)];
+    return formatHuman(hn, ht, tz).big;
+  }
+  if (parsed.units === "compound") return formatCompound(now2, resolved, 2, tz);
+  const bakeUnits = parsed.units === "full" || parsed.units === "clock" ? "days" : parsed.units;
+  return formatCount(Math.max(0, remaining), {
+    units: bakeUnits,
+    round: parsed.round,
+    fields: parsed.fields
+  });
+}
+function stampRecur(sel, parsed) {
+  const r = parsed.rule;
+  if (!r) return;
+  sel.attr("data-dgmo-recur-kind", r.kind);
+  if (r.month !== void 0) sel.attr("data-dgmo-recur-month", r.month);
+  if (r.day !== void 0) sel.attr("data-dgmo-recur-day", r.day);
+  if (r.nth !== void 0) sel.attr("data-dgmo-recur-nth", r.nth);
+  if (r.weekday !== void 0) sel.attr("data-dgmo-recur-weekday", r.weekday);
+  sel.attr("data-dgmo-recur-hour", r.hour);
+  sel.attr("data-dgmo-recur-minute", r.minute);
+  sel.attr("data-dgmo-recur-allday", r.allDay ? "1" : "0");
+  if (r.intervalN !== void 0)
+    sel.attr("data-dgmo-recur-interval-n", r.intervalN);
+  if (r.intervalUnit !== void 0)
+    sel.attr("data-dgmo-recur-interval-unit", r.intervalUnit);
+  if (r.anchorMs !== void 0) sel.attr("data-dgmo-recur-anchor", r.anchorMs);
+  if (r.tz !== void 0) sel.attr("data-dgmo-recur-tz", r.tz);
+}
+var MON_ABBR = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var WD_ABBR = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
+var DAY_START = (ms) => {
+  const d = new Date(ms);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+};
+var dayDelta = (a, b) => Math.round((DAY_START(b) - DAY_START(a)) / DAY_MS);
+var keyOf = (ms) => {
+  const d = new Date(ms);
+  return d.getFullYear() * 1e4 + d.getMonth() * 100 + d.getDate();
+};
+function bandColors(palette, accent, muted, faint, isDark, fillMode) {
+  const blue = resolveColor("blue", palette) ?? mix(palette.text, palette.bg, 45);
+  const collides = accent.toLowerCase() === blue.toLowerCase();
+  const now2 = collides ? resolveColor("teal", palette) ?? resolveColor("cyan", palette) ?? mix(palette.text, palette.bg, 55) : blue;
+  const mid = mix(accent, now2, 50);
+  return {
+    bg: palette.bg,
+    text: palette.text,
+    muted,
+    faint,
+    rule: mix(palette.text, palette.bg, 14),
+    now: now2,
+    event: accent,
+    midSoft: mix(mid, palette.bg, 24),
+    inert: mix(palette.text, palette.bg, 7),
+    inertBorder: mix(palette.text, palette.bg, 22),
+    fillMode,
+    baseBg: themeBaseBg(palette, isDark),
+    onLight: palette.textOnFillLight,
+    onDark: palette.textOnFillDark
+  };
+}
+function roleStyle(C, role) {
+  switch (role) {
+    case "past":
+      return { fill: C.inert, stroke: C.inertBorder, text: C.faint };
+    case "future":
+      return { fill: C.inert, stroke: C.inertBorder, text: C.muted };
+    case "today":
+      return chipStyle(C, C.now);
+    case "event":
+      return chipStyle(C, C.event);
+  }
+}
+function chipStyle(C, color) {
+  if (C.fillMode === "outline")
+    return { fill: C.baseBg, stroke: color, text: color };
+  if (C.fillMode === "solid")
+    return {
+      fill: color,
+      stroke: color,
+      text: contrastText(color, C.onLight, C.onDark)
+    };
+  return { fill: color, stroke: color, text: C.bg };
+}
+function gradStyle(C, frac) {
+  const t = Math.max(0, Math.min(1, frac));
+  const f = mix(C.event, C.now, Math.round(t * 100));
+  return chipStyle(C, f);
+}
+function aText(svg, x, y, size, fill, weight, anchor, txt, extra) {
+  const t = svg.append("text").attr("x", x).attr("y", y).attr("text-anchor", anchor).attr("font-size", size).attr("font-weight", weight).attr("fill", fill).attr("font-family", FONT_FAMILY).attr("font-variant-numeric", "tabular-nums").text(txt);
+  if (extra) for (const k in extra) t.attr(k, extra[k]);
+}
+function aRect(svg, x, y, w, h, rx, fill, stroke, sw) {
+  const r = svg.append("rect").attr("x", x).attr("y", y).attr("width", w).attr("height", h).attr("rx", rx).attr("fill", fill);
+  if (stroke) r.attr("stroke", stroke).attr("stroke-width", sw ?? 1);
+}
+function aLine(svg, x1, y1, x2, y2, stroke, sw, opacity) {
+  const l = svg.append("line").attr("x1", x1).attr("y1", y1).attr("x2", x2).attr("y2", y2).attr("stroke", stroke).attr("stroke-width", sw);
+  if (opacity != null) l.attr("opacity", opacity);
+}
+var REPEAT_ICON_PATH = "m17 2 4 4-4 4 M3 11v-1a4 4 0 0 1 4-4h14 M7 22l-4-4 4-4 M21 13v1a4 4 0 0 1-4 4H3";
+function recurGlyph(svg, cx, cy, r, color) {
+  const side = r * 2.4;
+  const scale = side / 24;
+  const swPx = Math.max(1.5, r * 0.34);
+  svg.append("path").attr("d", REPEAT_ICON_PATH).attr(
+    "transform",
+    `translate(${cx - side / 2} ${cy - side / 2}) scale(${scale})`
+  ).attr("data-embed-ignore-bbox", "").attr("fill", "none").attr("stroke", color).attr("stroke-width", swPx / scale).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+}
+function haloRect(svg, x, y, w, h, rx, C) {
+  aRect(svg, x - 1, y - 1, w + 2, h + 2, rx + 1, "none", C.bg, 2);
+  svg.append("rect").attr("class", "dgmo-countdown-target-ring").attr("x", x - 3).attr("y", y - 3).attr("width", w + 6).attr("height", h + 6).attr("rx", rx + 3).attr("fill", "none").attr("stroke", C.event).attr("stroke-width", 2);
+}
+function pickBand(nowMs, resolvedMs, hasTime) {
+  const days = dayDelta(nowMs, resolvedMs);
+  if (hasTime && days <= 0) return "clock";
+  if (days === 0) return "today";
+  const mag = Math.abs(days);
+  if (mag > 3 * 365) return "years";
+  if (mag > 365) return "year";
+  if (mag > 92) return "months";
+  if (mag > 7) return "monthgrid";
+  return "weekstrip";
+}
+function monthSpan(nowMs, resolvedMs) {
+  const n = new Date(nowMs);
+  const t = new Date(resolvedMs);
+  return Math.abs(
+    (t.getFullYear() - n.getFullYear()) * 12 + (t.getMonth() - n.getMonth())
+  ) + 1;
+}
+var MONTH_TARGET_PX = 200;
+function monthGridLayout(nowMs, resolvedMs, contentW) {
+  const now2 = new Date(nowMs);
+  const ev = new Date(resolvedMs);
+  const realSpan = monthSpan(nowMs, resolvedMs);
+  const shown = Math.max(realSpan, Math.round(contentW / MONTH_TARGET_PX));
+  const padBefore = Math.floor((shown - realSpan) / 2);
+  const nowMk = now2.getFullYear() * 12 + now2.getMonth();
+  const evMk = ev.getFullYear() * 12 + ev.getMonth();
+  const loMk = Math.min(nowMk, evMk);
+  const hiMk = Math.max(nowMk, evMk);
+  const startMk = loMk - padBefore;
+  const months = [];
+  const dim = [];
+  for (let i = 0; i < shown; i++) {
+    const d = new Date(Math.floor(startMk / 12), startMk % 12 + i, 1);
+    const mk = d.getFullYear() * 12 + d.getMonth();
+    months.push(d);
+    dim.push(mk < loMk || mk > hiMk);
+  }
+  return { months, dim };
+}
+function yearsLayout(nowMs, resolvedMs) {
+  const y0 = new Date(nowMs).getFullYear();
+  const y1 = new Date(resolvedMs).getFullYear();
+  const d0 = Math.floor(Math.min(y0, y1) / 10) * 10;
+  const d1 = Math.floor(Math.max(y0, y1) / 10) * 10;
+  return { d0, d1, rows: (d1 - d0) / 10 + 1 };
+}
+function bandHeightFor(kind, nowMs, resolvedMs, contentW) {
+  const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+  switch (kind) {
+    case "years": {
+      const { rows } = yearsLayout(nowMs, resolvedMs);
+      const rowGap = 11;
+      const labW = 54;
+      const gap = 7;
+      const cellW = (contentW - labW - 10 * gap) / 10;
+      let cellH = clamp(cellW * 0.5, 26, 40);
+      const MAX = 380;
+      let total = rows * cellH + (rows - 1) * rowGap;
+      if (total > MAX) {
+        cellH = Math.max(9, (MAX - (rows - 1) * rowGap) / rows);
+        total = rows * cellH + (rows - 1) * rowGap;
+      }
+      return total;
+    }
+    case "year": {
+      const R = Math.abs(
+        new Date(resolvedMs).getFullYear() - new Date(nowMs).getFullYear()
+      ) + 1;
+      const yearW = 66;
+      const gap = 8;
+      const cellW = (contentW - yearW - 11 * gap) / 12;
+      const cellH = clamp(cellW * 0.6, 28, 44);
+      const rowGap = 12;
+      return R * cellH + (R - 1) * rowGap;
+    }
+    case "months": {
+      const realSpan = monthSpan(nowMs, resolvedMs);
+      const perRow = 6;
+      const shown = Math.max(perRow, Math.ceil(realSpan / perRow) * perRow);
+      const rows = shown / perRow;
+      const cellW = (contentW - 16 * (perRow - 1)) / perRow;
+      const cellH = clamp(cellW * 0.5, 58, 84);
+      return rows * cellH + (rows - 1) * 16;
+    }
+    case "monthgrid": {
+      const { months } = monthGridLayout(nowMs, resolvedMs, contentW);
+      const nM = months.length;
+      const mw = (contentW - 20 * (nM - 1)) / nM;
+      const cellW = (mw - 20) / 7;
+      const cellH = clamp(cellW * 0.8, 15, 22);
+      return 26 + 6 * cellH + 8;
+    }
+    case "weekstrip": {
+      const n = Math.max(7, Math.abs(dayDelta(nowMs, resolvedMs)) + 1);
+      const cw = (contentW - 10 * (n - 1)) / n;
+      return clamp(cw * 1.5, 116, 170);
+    }
+    case "clock":
+      return clamp(contentW * 0.26, 150, 205);
+    case "today":
+      return clamp(contentW * 0.22, 125, 170);
+  }
+}
+function vizYears(svg, g, nowMs, resolvedMs, C) {
+  const now2 = new Date(nowMs);
+  const ev = new Date(resolvedMs);
+  const nowY = now2.getFullYear();
+  const evY = ev.getFullYear();
+  const { d0, rows } = yearsLayout(nowMs, resolvedMs);
+  const labW = 54;
+  const gap = 7;
+  const rowGap = 11;
+  const rowH = (g.height - rowGap * (rows - 1)) / rows;
+  const cellH = rowH;
+  const cellW = (g.contentW - labW - 10 * gap) / 10;
+  const rx = Math.min(6, Math.min(cellW, cellH) * 0.22);
+  const showLabel = cellH >= 18 && cellW >= 22;
+  const yrFont = Math.min(12, cellW * 0.34, cellH * 0.5);
+  for (let r = 0; r < rows; r++) {
+    const dec = d0 + r * 10;
+    const ry = g.top + r * (rowH + rowGap);
+    aText(
+      svg,
+      g.left + labW - 12,
+      ry + rowH / 2,
+      Math.min(14, rowH * 0.5),
+      C.muted,
+      "bold",
+      "end",
+      `${dec}s`,
+      { "dominant-baseline": "central" }
+    );
+    for (let i = 0; i < 10; i++) {
+      const yr = dec + i;
+      const before = yr < nowY;
+      const isNow = yr === nowY;
+      const isEv = yr === evY;
+      const between = (yr - nowY) * (yr - evY) < 0;
+      const st = isEv ? roleStyle(C, "event") : isNow ? roleStyle(C, "today") : between ? gradStyle(C, (yr - nowY) / (evY - nowY)) : roleStyle(C, before ? "past" : "future");
+      const x = g.left + labW + i * (cellW + gap);
+      aRect(svg, x, ry, cellW, cellH, rx, st.fill, st.stroke, 1);
+      if (isEv) haloRect(svg, x, ry, cellW, cellH, rx, C);
+      if (showLabel) {
+        aText(
+          svg,
+          x + cellW / 2,
+          ry + cellH / 2,
+          yrFont,
+          st.text,
+          "bold",
+          "middle",
+          String(yr),
+          { "dominant-baseline": "central" }
+        );
+      }
+    }
+  }
+}
+function vizYear(svg, g, nowMs, resolvedMs, C) {
+  const now2 = new Date(nowMs);
+  const ev = new Date(resolvedMs);
+  const y0 = Math.min(now2.getFullYear(), ev.getFullYear());
+  const y1 = Math.max(now2.getFullYear(), ev.getFullYear());
+  const years = [];
+  for (let y = y0; y <= y1; y++) years.push(y);
+  const R = years.length;
+  const yearW = 66;
+  const gap = 8;
+  const rowGap = 12;
+  const rowH = (g.height - rowGap * (R - 1)) / R;
+  const cellH = rowH;
+  const cellW = (g.contentW - yearW - 11 * gap) / 12;
+  const nowY = now2.getFullYear();
+  const nowM = now2.getMonth();
+  const evY = ev.getFullYear();
+  const evM = ev.getMonth();
+  const nowOrd = nowY * 12 + nowM;
+  const evOrd = evY * 12 + evM;
+  years.forEach((yr, r) => {
+    const ry = g.top + r * (rowH + rowGap);
+    aText(
+      svg,
+      g.left + yearW - 12,
+      ry + rowH / 2,
+      Math.min(22, rowH * 0.6),
+      C.muted,
+      "bold",
+      "end",
+      String(yr),
+      { "dominant-baseline": "central" }
+    );
+    for (let m = 0; m < 12; m++) {
+      const mOrd = yr * 12 + m;
+      const before = mOrd < nowOrd;
+      const isNow = yr === nowY && m === nowM;
+      const isEv = yr === evY && m === evM;
+      const between = (mOrd - nowOrd) * (mOrd - evOrd) < 0;
+      const anchor = isEv || isNow;
+      const st = isEv ? roleStyle(C, "event") : isNow ? roleStyle(C, "today") : between ? gradStyle(C, (yr * 12 + m - nowOrd) / (evOrd - nowOrd)) : roleStyle(C, before ? "past" : "future");
+      const x = g.left + yearW + m * (cellW + gap);
+      const rx = Math.min(5, Math.min(cellW, cellH) * 0.22);
+      aRect(svg, x, ry, cellW, cellH, rx, st.fill, st.stroke, 1);
+      if (isEv) haloRect(svg, x, ry, cellW, cellH, rx, C);
+      const cx = x + cellW / 2;
+      const mFont = Math.min(11, cellW * 0.32);
+      if (anchor) {
+        aText(
+          svg,
+          cx,
+          ry + cellH * 0.36,
+          mFont,
+          st.text,
+          "bold",
+          "middle",
+          MON_ABBR[m],
+          { "dominant-baseline": "central" }
+        );
+        const dnum = isEv ? ev.getDate() : now2.getDate();
+        aText(
+          svg,
+          cx,
+          ry + cellH * 0.72,
+          Math.min(14, cellW * 0.42),
+          st.text,
+          "bold",
+          "middle",
+          String(dnum),
+          { "dominant-baseline": "central" }
+        );
+      } else {
+        aText(
+          svg,
+          cx,
+          ry + cellH / 2,
+          mFont,
+          st.text,
+          "bold",
+          "middle",
+          MON_ABBR[m],
+          { "dominant-baseline": "central" }
+        );
+      }
+    }
+  });
+}
+function vizMonths(svg, g, nowMs, resolvedMs, C) {
+  const now2 = new Date(nowMs);
+  const ev = new Date(resolvedMs);
+  const realSpan = monthSpan(nowMs, resolvedMs);
+  const perRow = 6;
+  const shown = Math.max(perRow, Math.ceil(realSpan / perRow) * perRow);
+  const padBefore = Math.floor((shown - realSpan) / 2);
+  const rows = shown / perRow;
+  const gap = 16;
+  const rowGap = 16;
+  const labelH = 27;
+  const cellW = (g.contentW - gap * (perRow - 1)) / perRow;
+  const cellH = (g.height - rowGap * (rows - 1)) / rows;
+  const nowMk = now2.getFullYear() * 12 + now2.getMonth();
+  const evMk = ev.getFullYear() * 12 + ev.getMonth();
+  const loMk = Math.min(nowMk, evMk);
+  const hiMk = Math.max(nowMk, evMk);
+  const startMk = loMk - padBefore;
+  for (let i = 0; i < shown; i++) {
+    const d = new Date(Math.floor(startMk / 12), startMk % 12 + i, 1);
+    const mk = d.getFullYear() * 12 + d.getMonth();
+    const isNow = mk === nowMk;
+    const isEv = mk === evMk;
+    const isContext = mk < loMk || mk > hiMk;
+    const anchor = isNow || isEv;
+    const col = i % perRow;
+    const row = Math.floor(i / perRow);
+    const x = g.left + col * (cellW + gap);
+    const y = g.top + row * (cellH + rowGap);
+    const mt = isContext ? svg.append("g").attr("opacity", 0.42) : svg;
+    const st = isEv ? roleStyle(C, "event") : isNow ? roleStyle(C, "today") : (mk - nowMk) * (mk - evMk) < 0 ? gradStyle(C, (mk - nowMk) / (evMk - nowMk)) : roleStyle(C, mk < nowMk ? "past" : "future");
+    const rxM = Math.min(12, cellH * 0.14);
+    aRect(mt, x, y, cellW, cellH, rxM, st.fill, st.stroke, 1.25);
+    if (isEv) haloRect(mt, x, y, cellW, cellH, rxM, C);
+    aText(
+      mt,
+      x + cellW / 2,
+      y + 19,
+      16,
+      st.text,
+      "bold",
+      "middle",
+      MON_ABBR[d.getMonth()]
+    );
+    aLine(
+      mt,
+      x,
+      y + labelH,
+      x + cellW,
+      y + labelH,
+      st.text,
+      1,
+      anchor ? 0.5 : 0.3
+    );
+    if (anchor) {
+      const dnum = isEv ? ev.getDate() : now2.getDate();
+      const dFont = Math.min(cellH - labelH - 6, cellW * 0.42, 44);
+      aText(
+        mt,
+        x + cellW / 2,
+        y + labelH + (cellH - labelH) / 2 + 1,
+        dFont,
+        st.text,
+        "bold",
+        "middle",
+        String(dnum),
+        { "dominant-baseline": "central" }
+      );
+    }
+  }
+}
+function vizMonthGrid(svg, g, nowMs, resolvedMs, C) {
+  const { months, dim: isContext } = monthGridLayout(
+    nowMs,
+    resolvedMs,
+    g.contentW
+  );
+  const nM = months.length;
+  const gap = 20;
+  const mw = (g.contentW - gap * (nM - 1)) / nM;
+  const padX = 10;
+  const gridLeft = padX;
+  const gridW = mw - 2 * padX;
+  const cols = 7;
+  const cellW = gridW / cols;
+  const top = g.top;
+  const headH = 26;
+  const cellH = (g.height - headH - 8) / 6;
+  const gridH = 6 * cellH;
+  const weekendShade = mix(C.text, C.bg, 8);
+  const todayKey = keyOf(nowMs);
+  const evKey = keyOf(resolvedMs);
+  months.forEach((m, mi) => {
+    const mt = isContext[mi] ? svg.append("g").attr("opacity", 0.42) : svg;
+    const mx = g.left + mi * (mw + gap);
+    aRect(mt, mx, top, mw, g.height, 14, C.inert, C.inertBorder, 1.25);
+    const gy = top + headH;
+    for (const wcol of [0, 6])
+      aRect(
+        mt,
+        mx + gridLeft + wcol * cellW,
+        gy,
+        cellW,
+        gridH,
+        6,
+        weekendShade
+      );
+    aText(
+      mt,
+      mx + mw / 2,
+      top + 16,
+      14,
+      C.text,
+      "bold",
+      "middle",
+      `${MON_ABBR[m.getMonth()]} ${m.getFullYear()}`
+    );
+    aLine(mt, mx, top + headH - 6, mx + mw, top + headH - 6, C.rule, 1.25);
+    const first = new Date(m.getFullYear(), m.getMonth(), 1).getDay();
+    const dim = new Date(m.getFullYear(), m.getMonth() + 1, 0).getDate();
+    for (let day = 1; day <= dim; day++) {
+      const pos = first + day - 1;
+      const wk = Math.floor(pos / 7);
+      const dk = keyOf(new Date(m.getFullYear(), m.getMonth(), day).getTime());
+      const wd = pos % 7;
+      const cx = mx + gridLeft + wd * cellW;
+      const cy = gy + wk * cellH;
+      const isEvent = dk === evKey;
+      const isToday = dk === todayKey;
+      const between = (dk - todayKey) * (dk - evKey) < 0;
+      const anchor = isEvent || isToday;
+      const dtMs = new Date(m.getFullYear(), m.getMonth(), day).getTime();
+      const st = isEvent ? roleStyle(C, "event") : isToday ? roleStyle(C, "today") : between ? gradStyle(C, dayDelta(nowMs, dtMs) / dayDelta(nowMs, resolvedMs)) : roleStyle(C, dk < todayKey ? "past" : "future");
+      if (anchor) {
+        const s = Math.min(cellW, cellH) * 1.02;
+        const sx = cx + (cellW - s) / 2;
+        const sy = cy + (cellH - s) / 2;
+        aRect(mt, sx, sy, s, s, 7, st.fill, st.stroke, 2);
+        if (isEvent) haloRect(mt, sx, sy, s, s, 7, C);
+        aText(
+          mt,
+          cx + cellW / 2,
+          cy + cellH / 2,
+          Math.min(16, cellH * 0.62),
+          st.text,
+          "bold",
+          "middle",
+          String(day),
+          { "dominant-baseline": "central" }
+        );
+      } else {
+        const s = Math.min(cellW, cellH) * 0.5;
+        aRect(
+          mt,
+          cx + (cellW - s) / 2,
+          cy + (cellH - s) / 2,
+          s,
+          s,
+          Math.min(3, s * 0.3),
+          st.fill,
+          st.stroke,
+          1
+        );
+      }
+    }
+  });
+}
+function vizWeekStrip(svg, g, nowMs, resolvedMs, C) {
+  const nReal = Math.abs(dayDelta(nowMs, resolvedMs)) + 1;
+  const n = Math.max(7, nReal);
+  const padBefore = Math.floor((n - nReal) / 2);
+  const gap = n <= 7 ? 14 : n <= 12 ? 10 : 7;
+  const cw = (g.contentW - gap * (n - 1)) / n;
+  const cellTop = g.top;
+  const ch = g.height;
+  const showWd = cw >= 30;
+  const showTag = cw >= 44;
+  const nowOrd = DAY_START(nowMs);
+  const evOrd = DAY_START(resolvedMs);
+  const loOrd = Math.min(nowOrd, evOrd);
+  const hiOrd = Math.max(nowOrd, evOrd);
+  const first = new Date(Math.min(nowMs, resolvedMs));
+  for (let i = 0; i < n; i++) {
+    const dt = new Date(
+      first.getFullYear(),
+      first.getMonth(),
+      first.getDate() + i - padBefore
+    );
+    const dtOrd = DAY_START(dt.getTime());
+    const x = g.left + i * (cw + gap);
+    const isToday = dtOrd === nowOrd;
+    const isEvent = dtOrd === evOrd;
+    const isContext = dtOrd < loOrd || dtOrd > hiOrd;
+    const st = isEvent ? roleStyle(C, "event") : isToday ? roleStyle(C, "today") : isContext ? roleStyle(C, dtOrd < nowOrd ? "past" : "future") : gradStyle(C, (dtOrd - nowOrd) / (evOrd - nowOrd));
+    const ct = isContext ? svg.append("g").attr("opacity", 0.5) : svg;
+    const sw = isToday || isEvent ? 2 : 1.25;
+    aRect(ct, x, cellTop, cw, ch, 14, st.fill, st.stroke, sw);
+    if (isEvent) haloRect(ct, x, cellTop, cw, ch, 14, C);
+    if (showWd) {
+      aText(
+        ct,
+        x + cw / 2,
+        cellTop + 18,
+        Math.min(12, cw * 0.3),
+        st.text,
+        "bold",
+        "middle",
+        WD_ABBR[dt.getDay()],
+        { "letter-spacing": "0.04em" }
+      );
+      aLine(
+        ct,
+        x,
+        cellTop + 27,
+        x + cw,
+        cellTop + 27,
+        st.text,
+        1,
+        isToday || isEvent ? 0.5 : 0.3
+      );
+    }
+    aText(
+      ct,
+      x + cw / 2,
+      cellTop + (showWd ? ch * 0.6 : ch * 0.54),
+      Math.min(44, cw * 0.62),
+      st.text,
+      "bold",
+      "middle",
+      String(dt.getDate())
+    );
+    if (showTag && isToday)
+      aText(
+        ct,
+        x + cw / 2,
+        cellTop + ch - 13,
+        10,
+        st.text,
+        "bold",
+        "middle",
+        "TODAY",
+        { "letter-spacing": "0.04em" }
+      );
+  }
+}
+function vizToday(svg, g, resolvedMs, C) {
+  const ev = new Date(resolvedMs);
+  const cx = g.left + g.contentW / 2;
+  const cy = g.top + g.height / 2;
+  aLine(svg, g.left, cy, g.left + g.contentW, cy, C.rule, 2);
+  aLine(svg, cx, cy, g.left + g.contentW, cy, C.midSoft, 2);
+  const rays = 16;
+  const r0 = g.height * 0.3;
+  const r1 = g.height * 0.44;
+  for (let i = 0; i < rays; i++) {
+    const a = i / rays * Math.PI * 2;
+    svg.append("line").attr("x1", cx + Math.cos(a) * r0).attr("y1", cy + Math.sin(a) * r0).attr("x2", cx + Math.cos(a) * r1).attr("y2", cy + Math.sin(a) * r1).attr("stroke", C.event).attr("stroke-width", 2.5).attr("stroke-linecap", "round").attr("opacity", 0.45);
+  }
+  const w = Math.min(120, g.contentW * 0.16);
+  const h = g.height * 0.52;
+  const st = roleStyle(C, "event");
+  aRect(svg, cx - w / 2, cy - h / 2, w, h, 18, st.fill, st.stroke, 2);
+  aText(
+    svg,
+    cx,
+    cy - h * 0.14,
+    14,
+    st.text,
+    "bold",
+    "middle",
+    MON_ABBR[ev.getMonth()].toUpperCase(),
+    { "letter-spacing": "0.08em" }
+  );
+  aText(
+    svg,
+    cx,
+    cy + h * 0.22,
+    Math.min(48, h * 0.4),
+    st.text,
+    "bold",
+    "middle",
+    String(ev.getDate())
+  );
+  aText(
+    svg,
+    cx,
+    cy + h / 2 + 26,
+    13,
+    C.event,
+    "bold",
+    "middle",
+    "THE DAY IS HERE",
+    { "letter-spacing": "0.12em" }
+  );
+}
+function polar(cx, cy, r, deg) {
+  const a = (deg - 90) * Math.PI / 180;
+  return [cx + r * Math.cos(a), cy + r * Math.sin(a)];
+}
+function arcPath(cx, cy, r, frac) {
+  frac = Math.max(0, Math.min(0.9999, frac));
+  const [x0, y0] = polar(cx, cy, r, 0);
+  const [x1, y1] = polar(cx, cy, r, frac * 360);
+  return `M ${x0} ${y0} A ${r} ${r} 0 ${frac > 0.5 ? 1 : 0} 1 ${x1} ${y1}`;
+}
+function vizClock(svg, g, nowMs, targetMs, C) {
+  const ahead = targetMs >= nowMs;
+  const rem = Math.abs(targetMs - nowMs);
+  const h = Math.floor(rem / 36e5);
+  const m = Math.floor(rem % 36e5 / 6e4);
+  const s = Math.floor(rem % 6e4 / 1e3);
+  const R = Math.min(g.contentW / 3 * 0.3, g.height * 0.34);
+  const cy = g.top + g.height * 0.42;
+  const sw = Math.max(8, R * 0.17);
+  const gauges = [
+    { frac: h % 24 / 24, val: h, label: "HOURS", col: C.event, key: "h" },
+    { frac: m / 60, val: m, label: "MINUTES", col: C.event, key: "m" },
+    { frac: s / 60, val: s, label: "SECONDS", col: C.event, key: "s" }
+  ];
+  gauges.forEach((gg, i) => {
+    const cx = g.left + g.contentW * (i + 0.5) / 3;
+    svg.append("circle").attr("cx", cx).attr("cy", cy).attr("r", R).attr("fill", "none").attr("stroke", C.inert).attr("stroke-width", sw);
+    const arc = svg.append("path").attr("d", gg.frac > 1e-3 ? arcPath(cx, cy, R, gg.frac) : "").attr("fill", "none").attr("stroke", gg.col).attr("stroke-width", sw).attr("stroke-linecap", "round").attr("data-dgmo-gauge-arc", gg.key).attr("data-cx", cx).attr("data-cy", cy).attr("data-r", R);
+    void arc;
+    aText(
+      svg,
+      cx,
+      cy + R * 0.22,
+      R * 0.62,
+      C.text,
+      "bold",
+      "middle",
+      pad2(gg.val),
+      {
+        "data-dgmo-gauge-val": gg.key
+      }
+    );
+    aText(svg, cx, cy + R + 22, 12, C.muted, "bold", "middle", gg.label, {
+      "letter-spacing": "0.1em"
+    });
+  });
+  const cxMid = g.left + g.contentW * 0.5;
+  aText(
+    svg,
+    cxMid,
+    cy - R - 14,
+    13,
+    ahead ? C.event : C.muted,
+    "bold",
+    "middle",
+    ahead ? "TO GO" : "AGO",
+    {
+      "letter-spacing": "0.12em",
+      "data-dgmo-gauge-caption": ""
+    }
+  );
+}
+function pad2(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+function paintClock(sel, str, secSize, secFill) {
+  const { lead, sec } = splitClockSeconds(str);
+  sel.attr("font-variant-numeric", "tabular-nums").attr("data-dgmo-cd-clock", "").attr("data-dgmo-cd-sec-size", secSize).attr("data-dgmo-cd-sec-fill", secFill).text(null);
+  sel.append("tspan").attr("data-cd-lead", "").text(lead);
+  if (sec !== null)
+    sel.append("tspan").attr("data-cd-sec", "").attr("font-size", secSize).attr("fill", secFill).attr("font-weight", "bold").text(sec);
+}
+function drawBand(svg, kind, g, nowMs, resolvedMs, C) {
+  switch (kind) {
+    case "years":
+      return vizYears(svg, g, nowMs, resolvedMs, C);
+    case "year":
+      return vizYear(svg, g, nowMs, resolvedMs, C);
+    case "months":
+      return vizMonths(svg, g, nowMs, resolvedMs, C);
+    case "monthgrid":
+      return vizMonthGrid(svg, g, nowMs, resolvedMs, C);
+    case "weekstrip":
+      return vizWeekStrip(svg, g, nowMs, resolvedMs, C);
+    case "today":
+      return vizToday(svg, g, resolvedMs, C);
+    case "clock":
+      return vizClock(svg, g, nowMs, resolvedMs, C);
+  }
+}
+function renderCountdown(container, parsed, palette, isDark, exportDims) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const now2 = now();
+  const resolved = parsed.resolvedMs;
+  const label = parsed.sinceLabel ?? parsed.title ?? "";
+  const ordinal = parsed.sinceLabel !== null && parsed.rule !== null && resolved !== null ? ordinalFor(resolved, parsed.rule) : null;
+  const expiredFrozen = !parsed.rule && parsed.expired !== null && resolved !== null && resolved - now2 <= 0;
+  const bandKind = resolved === null || parsed.noVisual || expiredFrozen ? null : pickBand(now2, resolved, parsed.hasTime);
+  let hero = bakedHero(parsed, now2);
+  if (bandKind === "clock" && resolved !== null) {
+    const clock = formatCount(Math.abs(resolved - now2), {
+      units: "clock",
+      round: parsed.round,
+      fields: parsed.fields
+    });
+    hero = resolved - now2 < 0 ? `${clock} ago` : clock;
+  }
+  const seriesAccent = getSeriesColors(palette)[0];
+  const defaultAccent = resolveColor("red", palette) ?? seriesAccent;
+  const manualColor = (parsed.color && resolveColor(parsed.color, palette)) ?? parsed.color ?? null;
+  const accent = manualColor ?? defaultAccent;
+  const muted = mix(palette.text, themeBaseBg(palette, isDark), 55);
+  const banked = resolveColor("green", palette) ?? muted;
+  const faint = mix(palette.text, themeBaseBg(palette, isDark), 72);
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("preserveAspectRatio", "xMidYMid meet").attr("xmlns", "http://www.w3.org/2000/svg").attr("role", "img").attr("aria-label", `${parsed.title ?? "Countdown"}: ${hero}`).style("font-family", FONT_FAMILY);
+  svg.append("style").text(`
+    @keyframes dgmo-countdown-flash {
+      0%, 100% { opacity: 1; stroke-width: 2; }
+      50% { opacity: 0.45; stroke-width: 3; }
+    }
+    .dgmo-countdown-target-ring {
+      animation: dgmo-countdown-flash 1.8s ease-in-out infinite;
+    }
+    @media (prefers-reduced-motion: reduce) {
+      .dgmo-countdown-target-ring { animation: none; }
+    }
+  `);
+  const bgRect = svg.append("rect").attr("width", width).attr("fill", palette.bg);
+  const estWidth = (t, fs) => t.length * fs * 0.58;
+  const fitFont = (t, base, maxW, min) => {
+    const w = estWidth(t, base);
+    return w <= maxW ? base : Math.max(min, Math.floor(base * maxW / w));
+  };
+  const dispLen = (s) => stripInlineMarkdown(s).length;
+  const padX = Math.max(30, Math.round(width * 0.045));
+  const padY = Math.max(26, Math.round(width * 0.03));
+  const contentW = width - 2 * padX;
+  const leftX = padX;
+  const remainingNow = resolved === null ? 0 : Math.max(0, resolved - now2);
+  const dayCount = Math.ceil(remainingNow / DAY_MS);
+  const heroSizeStr = parsed.units === "full" ? `${dayCount > 0 ? `${dayCount}d ` : ""}00:00:00` : parsed.units === "clock" ? formatCount(remainingNow, {
+    units: "clock",
+    round: parsed.round,
+    fields: parsed.fields
+  }) : hero;
+  const heroMaxW = contentW * 0.44;
+  const sizeStr = estWidth(hero, 1) > estWidth(heroSizeStr, 1) ? hero : heroSizeStr;
+  const gapMid = Math.max(28, Math.round(width * 0.03));
+  const stacked = estWidth(sizeStr, 26) > heroMaxW;
+  const heroFont = fitFont(sizeStr, 96, stacked ? contentW : heroMaxW, 26);
+  const heroW = stacked ? contentW : Math.min(heroMaxW, estWidth(sizeStr, heroFont));
+  const leftW = stacked ? contentW : Math.max(contentW * 0.42, contentW - heroW - gapMid);
+  const titleBase = 40;
+  let titleFont = 0;
+  let titleLines = [];
+  if (parsed.title) {
+    const longestWord = parsed.title.split(/\s+/).reduce((a, b) => b.length > a.length ? b : a, "");
+    titleFont = fitFont(longestWord, titleBase, leftW, 22);
+    const cpl = Math.max(6, Math.floor(leftW / (titleFont * 0.58)));
+    titleLines = wrapDescriptionLines([parsed.title], cpl).map((l) => l.text);
+  }
+  const eyebrowText = ordinal !== null ? applyOrdinalTemplate(parsed.sinceLabel ?? `Nth ${label}`, ordinal) : null;
+  const eyebrowFont = 16;
+  const footerText = resolved !== null ? formatFooter(resolved, parsed.hasTime, parsed.tz) : null;
+  const footerFont = 17;
+  const noteFont = 19;
+  const asofFont = 13;
+  const noteCharsPerLine = Math.max(8, Math.floor(leftW / (noteFont * 0.5)));
+  const noteSource = parsed.note ? parsed.note.split("\n").map((l) => l.replace(/^[-*]\s+/, "\u2022 ")) : [];
+  const noteLines = noteSource.length ? wrapDescriptionLines(noteSource, noteCharsPerLine, dispLen) : [];
+  const bulletPx = noteFont * 0.95;
+  let y = padY;
+  const drawText = (text, yTop, fs, fill, weight) => svg.append("text").attr("x", leftX).attr("y", yTop + fs).attr("text-anchor", "start").attr("dominant-baseline", "alphabetic").attr("fill", fill).attr("font-family", FONT_FAMILY).attr("font-size", fs).attr("font-weight", weight).text(text);
+  if (parsed.title) {
+    titleLines.forEach((tl, i) => {
+      const t = drawText(tl, y, titleFont, palette.text, "bold");
+      if (i === 0) t.attr("data-line-number", parsed.titleLineNumber);
+      y += i < titleLines.length - 1 ? Math.round(titleFont * 1.12) : titleFont;
+    });
+    y += Math.round(titleFont * 0.45);
+    const heroLeft = width - padX - heroW;
+    const ruleRight = stacked ? width - padX : Math.max(leftX + 40, heroLeft - 20);
+    svg.append("line").attr("x1", leftX).attr("x2", ruleRight).attr("y1", y).attr("y2", y).attr("stroke", mix(palette.text, palette.bg, 14)).attr("stroke-width", 1.25);
+    y += Math.round(titleFont * 0.5);
+  }
+  if (eyebrowText) {
+    drawText(eyebrowText, y, eyebrowFont, banked, "bold").attr(
+      "data-dgmo-countdown-eyebrow",
+      ""
+    );
+    y += eyebrowFont + 8;
+  }
+  if (footerText) {
+    const fx = parsed.rule ? leftX + 22 : leftX;
+    if (parsed.rule)
+      recurGlyph(svg, leftX + 8, y + footerFont * 0.52, 6.5, muted);
+    svg.append("text").attr("x", fx).attr("y", y + footerFont).attr("text-anchor", "start").attr("dominant-baseline", "alphabetic").attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", footerFont).attr("font-weight", "normal").attr("data-dgmo-countdown-footer", "").text(footerText);
+    y += footerFont + 8;
+  }
+  if (noteLines.length) {
+    y += 4;
+    for (const nl of noteLines) {
+      const bx = nl.kind === "plain" ? leftX : leftX + bulletPx;
+      if (nl.kind === "bullet-first") {
+        svg.append("text").attr("x", leftX).attr("y", y + noteFont).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", noteFont).text("\u2022");
+      }
+      const t = svg.append("text").attr("x", bx).attr("y", y + noteFont).attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", noteFont).attr("font-weight", "normal");
+      renderInlineText(t, nl.text, palette, noteFont);
+      y += Math.round(noteFont * 1.35);
+    }
+    y += 2;
+  }
+  drawText(`as of ${formatDateShort(now2)}`, y, asofFont, faint, "normal").attr(
+    "data-dgmo-countdown-asof",
+    ""
+  );
+  y += asofFont;
+  const leftBottom = y;
+  const detailFont = 18;
+  const remainingSub = resolved !== null ? resolved - now2 : 0;
+  const subText = resolved === null || remainingSub <= 0 ? null : parsed.units === "words" ? formatWordsDetail(remainingSub) : parsed.units === "human" && bandKind !== "clock" ? parsed.hasTime ? formatCount(remainingSub, {
+    units: "clock",
+    round: parsed.round,
+    fields: parsed.fields
+  }) : formatHuman(
+    dayStart(now2, parsed.tz),
+    dayStart(resolved, parsed.tz),
+    parsed.tz
+  ).sub || null : null;
+  const heroCapTop = stacked ? leftBottom + Math.round(heroFont * 0.2) : padY + 0.28 * titleFont;
+  const heroBaseline = heroCapTop + 0.72 * heroFont;
+  const heroBlockBottom = heroBaseline + (subText ? heroFont * 0.28 + detailFont : 0);
+  const contentBottom = Math.max(leftBottom, heroBlockBottom);
+  const hasBand = bandKind !== null;
+  const topSection = contentBottom;
+  const bandTop = topSection + 26;
+  const BAND_H = hasBand && resolved !== null ? Math.round(bandHeightFor(bandKind, now2, resolved, width - 2 * padX)) : 0;
+  const bannerH = hasBand ? bandTop + BAND_H + padY : Math.max(
+    contentBottom + padY,
+    heroFont * 1.25 + 2 * padY,
+    Math.round(width * 0.28)
+  );
+  svg.attr("height", bannerH).attr("viewBox", `0 0 ${width} ${bannerH}`);
+  bgRect.attr("height", bannerH);
+  const bandC = bandColors(
+    palette,
+    accent,
+    muted,
+    faint,
+    isDark,
+    parsed.fillMode
+  );
+  if (hasBand && resolved !== null) {
+    drawBand(
+      svg,
+      bandKind,
+      { left: leftX, top: bandTop, contentW: width - 2 * padX, height: BAND_H },
+      now2,
+      resolved,
+      bandC
+    );
+  }
+  const value = svg.append("text").attr("class", "countdown-value").attr("x", stacked ? leftX : width - padX).attr("y", heroBaseline).attr("text-anchor", stacked ? "start" : "end").attr("dominant-baseline", "alphabetic").attr("fill", accent).attr("font-family", FONT_FAMILY).attr("font-size", heroFont).attr("font-weight", "bold").attr("data-dgmo-countdown-units", parsed.units).attr("data-dgmo-countdown-round", parsed.round).attr("data-dgmo-countdown-fields", parsed.fields.join(",")).attr("data-dgmo-countdown-expired", parsed.expired).attr("aria-label", `${parsed.title ?? "Countdown"}: ${hero}`);
+  paintClock(value, hero, Math.round(heroFont * 0.55), bandC.now);
+  if (parsed.rule && resolved !== null) {
+    value.attr("data-dgmo-countdown", new Date(resolved).toISOString());
+  } else if (parsed.target) {
+    value.attr("data-dgmo-countdown", parsed.target);
+  }
+  if (parsed.title) value.attr("data-dgmo-countdown-title", parsed.title);
+  if (parsed.onDay) value.attr("data-dgmo-countdown-onday", parsed.onDay);
+  if (parsed.hasTime) value.attr("data-dgmo-countdown-hastime", "1");
+  if (parsed.tz) value.attr("data-dgmo-countdown-tz", parsed.tz);
+  if (parsed.sinceLabel !== null) {
+    value.attr("data-dgmo-countdown-since-label", parsed.sinceLabel);
+  }
+  stampRecur(value, parsed);
+  if (bandKind !== null && resolved !== null) {
+    value.attr("data-dgmo-countdown-band-day", dayKey(now2, parsed.tz)).attr("data-dgmo-countdown-band-on", dayKey(resolved, parsed.tz));
+    svg.attr(
+      "data-dgmo-countdown-redraw",
+      JSON.stringify({ parsed, palette, isDark, width, height })
+    );
+  }
+  if (subText) {
+    const detailSel = svg.append("text").attr("x", stacked ? leftX : width - padX).attr("y", heroBaseline + heroFont * 0.28 + detailFont).attr("text-anchor", stacked ? "start" : "end").attr("dominant-baseline", "alphabetic").attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", detailFont).attr("font-weight", "normal").attr("data-dgmo-countdown-detail", "");
+    paintClock(detailSel, subText, Math.round(detailFont * 0.66), bandC.now);
+  }
+}
+
+// src/countdown/redraw.ts
+function redrawCountdown(svg, resolvedMs) {
+  const raw = svg.getAttribute("data-dgmo-countdown-redraw");
+  if (!raw) return;
+  let p;
+  try {
+    p = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const doc = svg.ownerDocument;
+  const container = doc.createElement("div");
+  renderCountdown(container, { ...p.parsed, resolvedMs }, p.palette, p.isDark, {
+    width: p.width,
+    height: p.height
+  });
+  let fresh = container.querySelector("svg");
+  if (!fresh) return;
+  if (!svg.hasAttribute("width")) {
+    const bg = p.palette.bg.trim().toLowerCase();
+    const keptBackground = /background/i.test(svg.getAttribute("style") ?? "") || Array.from(svg.children).some(
+      (c) => c.tagName.toLowerCase() === "rect" && (c.getAttribute("fill") ?? "").trim().toLowerCase() === bg
+    );
+    fresh.style.background = p.palette.bg;
+    const holder = doc.createElement("div");
+    holder.innerHTML = normalizeSvgForEmbed(fresh.outerHTML, {
+      background: keptBackground ? "opaque" : "transparent"
+    });
+    fresh = holder.querySelector("svg");
+    if (!fresh) return;
+  }
+  Array.from(svg.childNodes).forEach((c) => {
+    if (!(c.nodeType === 1 && c.tagName.toLowerCase() === "desc")) {
+      svg.removeChild(c);
+    }
+  });
+  Array.from(fresh.childNodes).forEach((c) => {
+    const isDesc = c.nodeType === 1 && c.tagName.toLowerCase() === "desc";
+    if (!isDesc) svg.appendChild(doc.importNode(c, true));
+  });
+  for (const name of ["viewBox", "width", "height", "aria-label"]) {
+    const v = fresh.getAttribute(name);
+    if (v !== null) svg.setAttribute(name, v);
+  }
+  const payload = fresh.getAttribute("data-dgmo-countdown-redraw");
+  if (payload !== null) svg.setAttribute("data-dgmo-countdown-redraw", payload);
+  else svg.removeAttribute("data-dgmo-countdown-redraw");
+  const view = doc.defaultView;
+  if (view && typeof view.CustomEvent === "function") {
+    svg.dispatchEvent(
+      new view.CustomEvent("dgmo:countdown-redrawn", { bubbles: true })
+    );
+  }
+}
+export {
+  redrawCountdown
+};