@diagrammo/dgmo 0.48.2 → 0.50.0

package/dist/chunk-7PQYTZMA.js

@@ -0,0 +1,681 @@
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  mix,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+
+// src/clock/renderer.ts
+import * as d3Selection from "d3-selection";
+
+// src/clock/resolve.ts
+var CLOCK_RAMP = [
+  [0, "#3d478f"],
+  [4, "#4a4d8c"],
+  [6, "#c98a6b"],
+  [8, "#d9a441"],
+  [11, "#e0b23c"],
+  [13, "#4f96c4"],
+  [16, "#cc7a33"],
+  [19, "#8a5aa0"],
+  [24, "#3d478f"]
+];
+function hexLerp(a, b, t) {
+  const pa = [1, 3, 5].map((i) => parseInt(a.slice(i, i + 2), 16));
+  const pb = [1, 3, 5].map((i) => parseInt(b.slice(i, i + 2), 16));
+  const c = pa.map(
+    (v, i) => Math.round(v + (pb[i] - v) * t).toString(16).padStart(2, "0")
+  );
+  return `#${c.join("")}`;
+}
+function rampColor(h) {
+  const hh = (h % 24 + 24) % 24;
+  for (let i = 0; i < CLOCK_RAMP.length - 1; i++) {
+    const [h0, c0] = CLOCK_RAMP[i];
+    const [h1, c1] = CLOCK_RAMP[i + 1];
+    if (hh >= h0 && hh <= h1) return hexLerp(c0, c1, (hh - h0) / (h1 - h0));
+  }
+  return CLOCK_RAMP[0][1];
+}
+var SOON_MIN = 60;
+var RAD = Math.PI / 180;
+var DAY_MS = 864e5;
+var J1970 = 2440588;
+var J2000 = 2451545;
+function zoneParts(zone, nowMs) {
+  const d = new Date(nowMs);
+  try {
+    const o = {};
+    new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      weekday: "short"
+    }).formatToParts(d).forEach((x) => {
+      o[x.type] = x.value;
+    });
+    const off = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      timeZoneName: "shortOffset"
+    }).formatToParts(d).find((x) => x.type === "timeZoneName");
+    return {
+      h: parseInt(o["hour"], 10) % 24,
+      m: parseInt(o["minute"], 10),
+      s: parseInt(o["second"], 10),
+      weekday: o["weekday"],
+      offsetLabel: off ? off.value.replace("GMT", "UTC") : ""
+    };
+  } catch {
+    return {
+      h: d.getUTCHours(),
+      m: d.getUTCMinutes(),
+      s: d.getUTCSeconds(),
+      weekday: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][d.getUTCDay()],
+      offsetLabel: "UTC"
+    };
+  }
+}
+function pad2(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+function formatTime(h, m, s, hours12) {
+  const sec = pad2(s);
+  if (hours12) {
+    const ap = h < 12 ? "am" : "pm";
+    let hr = h % 12;
+    if (hr === 0) hr = 12;
+    return { main: `${hr}:${pad2(m)}`, sec, ap };
+  }
+  return { main: `${pad2(h)}:${pad2(m)}`, sec, ap: "" };
+}
+function fmtDelta(ms) {
+  const m = Math.max(0, Math.round(ms / 6e4));
+  if (m < 90) return `${m}m`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+function workStatus(parts, work) {
+  if (!work) return null;
+  const min = parts.h * 60 + parts.m;
+  if (!work.days[parts.weekday]) return { cls: "off", text: "Weekend" };
+  if (min < work.startMin) {
+    const d = work.startMin - min;
+    return {
+      cls: d <= SOON_MIN ? "soon" : "off",
+      text: `starts in ${fmtDelta(d * 6e4)}`
+    };
+  }
+  if (min < work.endMin) {
+    return { cls: "ok", text: `${fmtDelta((work.endMin - min) * 6e4)} left` };
+  }
+  return {
+    cls: "off",
+    text: `ended ${fmtDelta((min - work.endMin) * 6e4)} ago`
+  };
+}
+function toJulian(ms) {
+  return ms / DAY_MS - 0.5 + J1970;
+}
+function fromJulian(j) {
+  return (j + 0.5 - J1970) * DAY_MS;
+}
+function sunTimes(nowMs, lat, lon) {
+  const lw = -lon * RAD;
+  const phi = lat * RAD;
+  const J = toJulian(nowMs);
+  const n = Math.round(J - J2000 - 9e-4 - lw / (2 * Math.PI));
+  const Jn = J2000 + 9e-4 + lw / (2 * Math.PI) + n;
+  const M = (357.5291 + 0.98560028 * (Jn - J2000)) * RAD;
+  const C = (1.9148 * Math.sin(M) + 0.02 * Math.sin(2 * M) + 3e-4 * Math.sin(3 * M)) * RAD;
+  const L = M + C + Math.PI + 102.9372 * RAD;
+  const Jt = Jn + 53e-4 * Math.sin(M) - 69e-4 * Math.sin(2 * L);
+  const dec = Math.asin(Math.sin(L) * Math.sin(23.44 * RAD));
+  const cw = (Math.sin(-0.833 * RAD) - Math.sin(phi) * Math.sin(dec)) / (Math.cos(phi) * Math.cos(dec));
+  if (cw > 1) return { polar: "night" };
+  if (cw < -1) return { polar: "day" };
+  const w = Math.acos(cw);
+  const Jset = J2000 + 9e-4 + (w + lw) / (2 * Math.PI) + n + 53e-4 * Math.sin(M) - 69e-4 * Math.sin(2 * L);
+  return {
+    sunriseMs: fromJulian(Jt - (Jset - Jt)),
+    sunsetMs: fromJulian(Jset)
+  };
+}
+function sunLine(nowMs, lat, lon) {
+  const t = sunTimes(nowMs, lat, lon);
+  if (t.polar) {
+    return {
+      up: t.polar === "day",
+      text: t.polar === "day" ? "midnight sun" : "polar night"
+    };
+  }
+  if (nowMs < t.sunriseMs) {
+    return { up: false, text: `sunrise in ${fmtDelta(t.sunriseMs - nowMs)}` };
+  }
+  if (nowMs < t.sunsetMs) {
+    return { up: true, text: `sunset in ${fmtDelta(t.sunsetMs - nowMs)}` };
+  }
+  const tm = sunTimes(nowMs + DAY_MS, lat, lon);
+  if (tm.polar) return { up: false, text: "sunrise in \u2014" };
+  return { up: false, text: `sunrise in ${fmtDelta(tm.sunriseMs - nowMs)}` };
+}
+function handAngles(h, m, s) {
+  return {
+    hour: (h % 12 + m / 60) * 30,
+    minute: (m + s / 60) * 6,
+    second: s * 6
+  };
+}
+
+// src/clock/renderer.ts
+var PLACE_ACCENTS = [
+  "blue",
+  "green",
+  "orange",
+  "purple",
+  "teal",
+  "red",
+  "cyan"
+];
+function resolveColorBy(mode, entry, index, ctx) {
+  if (entry.color)
+    return { solid: entry.color, laneTint: mix(entry.color, ctx.cardFill, 14) };
+  switch (mode) {
+    case "none":
+      return null;
+    case "place": {
+      const name = PLACE_ACCENTS[index % PLACE_ACCENTS.length];
+      const c = resolveColor(name, ctx.palette) ?? ctx.sw.day;
+      return { solid: c, laneTint: mix(c, ctx.cardFill, 14) };
+    }
+    case "daylight":
+      return ctx.up ? { solid: ctx.sw.day, laneTint: ctx.sw.dayTint } : { solid: ctx.sw.night, laneTint: ctx.sw.nightTint };
+    case "work": {
+      if (!ctx.status) return null;
+      const cls = ctx.status.cls;
+      const solid = cls === "ok" ? ctx.sw.ok : cls === "soon" ? ctx.sw.soon : ctx.sw.off;
+      const laneTint = cls === "ok" ? ctx.sw.okSoft : cls === "soon" ? ctx.sw.soonSoft : ctx.sw.offSoft;
+      return { solid, laneTint };
+    }
+    case "time":
+      return {
+        solid: rampColor(ctx.localHour),
+        laneTint: mix(rampColor(ctx.localHour), ctx.cardFill, 14)
+      };
+  }
+}
+var clipSeq = 0;
+function estWidth(t, fs) {
+  return t.length * fs * 0.6;
+}
+function fitFont(t, base, maxW, min) {
+  const w = estWidth(t, base);
+  return w <= maxW ? base : Math.max(min, Math.floor(base * maxW / w));
+}
+function ellipsize(t, fs, maxW) {
+  if (maxW <= 0) return "";
+  if (estWidth(t, fs) <= maxW) return t;
+  let s = t;
+  while (s.length > 0 && estWidth(`${s}\u2026`, fs) > maxW) s = s.slice(0, -1);
+  return `${s}\u2026`;
+}
+function wrapText(t, fs, maxW, maxLines) {
+  const words = t.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let cur = "";
+  for (const w of words) {
+    const trial = cur ? `${cur} ${w}` : w;
+    if (estWidth(trial, fs) <= maxW) {
+      cur = trial;
+    } else if (!cur) {
+      cur = w;
+    } else if (lines.length + 1 < maxLines) {
+      lines.push(cur);
+      cur = w;
+    } else {
+      cur = trial;
+    }
+  }
+  if (cur) lines.push(cur);
+  return lines.map((l) => ellipsize(l, fs, maxW));
+}
+function drawSunMoon(parent, cx, cy, up, sw, scale = 1) {
+  const icon = parent.append("g").attr("data-dgmo-clock-sun-icon", "").attr(
+    "transform",
+    scale === 1 ? `translate(${cx},${cy})` : `translate(${cx},${cy}) scale(${scale})`
+  );
+  const sunG = icon.append("g").attr("data-clock-glyph", "sun").attr("display", up ? "inline" : "none");
+  sunG.append("circle").attr("r", 2.5).attr("fill", sw.sunIcon);
+  for (let k = 0; k < 8; k++) {
+    const a = k * Math.PI / 4;
+    sunG.append("line").attr("x1", 3.2 * Math.cos(a)).attr("y1", 3.2 * Math.sin(a)).attr("x2", 4.6 * Math.cos(a)).attr("y2", 4.6 * Math.sin(a)).attr("stroke", sw.sunIcon).attr("stroke-width", 1).attr("stroke-linecap", "round");
+  }
+  icon.append("g").attr("data-clock-glyph", "moon").attr("display", up ? "none" : "inline").append("path").attr(
+    "d",
+    "M1.85,-3.32 A3.8,3.8 0 1,0 1.85,3.32 A3.4,3.4 0 0,1 1.85,-3.32 Z"
+  ).attr("fill", sw.moonIcon);
+}
+function hourLabel(min, hours12) {
+  const h = Math.floor(min / 60);
+  const m = min % 60;
+  const mm = m ? `:${String(m).padStart(2, "0")}` : "";
+  if (!hours12) return `${h}${mm}`;
+  const ap = h < 12 ? "am" : "pm";
+  const hr = h % 12 === 0 ? 12 : h % 12;
+  return `${hr}${mm}${ap}`;
+}
+var WEEKDAY_ABBR = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function daysLabel(days) {
+  const on = WEEKDAY_ABBR.filter((d) => days[d]);
+  if (on.length === 5 && days["Mon"] && days["Fri"] && !days["Sat"] && !days["Sun"])
+    return "Mon\u2013Fri";
+  return on.join(", ");
+}
+function buildSwatches(palette, muted) {
+  const bg = palette.bg;
+  const day = resolveColor("orange", palette) ?? "#d98a1f";
+  const night = resolveColor("blue", palette) ?? "#4864b0";
+  const ok = resolveColor("green", palette) ?? "#3f9e59";
+  const soon = resolveColor("orange", palette) ?? "#c9761a";
+  return {
+    day,
+    night,
+    dayTint: mix(day, bg, 14),
+    nightTint: mix(night, bg, 14),
+    ok,
+    soon,
+    off: muted,
+    okSoft: mix(ok, bg, 14),
+    soonSoft: mix(soon, bg, 14),
+    offSoft: mix(muted, bg, 16),
+    // Sundown indicator: a yellow sun by day, a blue moon by night.
+    sunIcon: resolveColor("yellow", palette) ?? "#f4b400",
+    moonIcon: night
+  };
+}
+function renderClock(container, parsed, palette, isDark, exportDims) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const avail = exportDims?.width ?? container.clientWidth;
+  const heightHint = exportDims?.height ?? container.clientHeight;
+  if (avail <= 0) return;
+  const width = exportDims?.width ?? Math.min(720, Math.max(460, avail));
+  const now = Date.now();
+  const baseBg = themeBaseBg(palette, isDark);
+  const muted = mix(palette.text, baseBg, 55);
+  const faint = mix(palette.text, baseBg, 72);
+  const line2 = mix(palette.text, palette.bg, 76);
+  const cardFill = mix(palette.text, palette.bg, 8);
+  const sw = buildSwatches(palette, muted);
+  const padX = Math.max(20, Math.round(width * 0.04));
+  const padY = 20;
+  const rightX = width - padX;
+  const rowH = 84;
+  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 ?? "Clock"} \u2014 world clocks`).style("font-family", FONT_FAMILY);
+  const bgRect = svg.append("rect").attr("width", width).attr("fill", palette.bg);
+  const cardM = 8;
+  const card = svg.append("rect").attr("x", cardM).attr("y", cardM).attr("width", width - 2 * cardM).attr("rx", 14).attr("fill", cardFill).attr("stroke", mix(palette.text, palette.bg, 40)).attr("stroke-width", 1);
+  clipSeq += 1;
+  const clipId = `dgmo-clock-clip-${clipSeq}`;
+  const clipRect = svg.append("clipPath").attr("id", clipId).append("rect").attr("x", cardM).attr("y", cardM).attr("width", width - 2 * cardM).attr("rx", 14);
+  const anyLane = parsed.colorBy !== "none" || parsed.entries.some((e) => e.color);
+  const hasTitle = Boolean(parsed.title && !parsed.noTitle);
+  let y = padY;
+  if (parsed.title && !parsed.noTitle) {
+    const titleFont = 20;
+    const meta = parsed.work ? `${hourLabel(parsed.work.startMin, parsed.hours12)}\u2013${hourLabel(parsed.work.endMin, parsed.hours12)} \xB7 ${daysLabel(parsed.work.days)}` : null;
+    const metaW = meta ? estWidth(meta, 12) + 16 : 0;
+    svg.append("text").attr("x", padX).attr("y", y + titleFont).attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", titleFont).attr("font-weight", 650).attr("data-line-number", parsed.titleLineNumber).text(ellipsize(parsed.title, titleFont, rightX - padX - metaW));
+    if (meta) {
+      svg.append("text").attr("x", rightX).attr("y", y + titleFont - 3).attr("text-anchor", "end").attr("fill", faint).attr("font-family", FONT_FAMILY).attr("font-size", 12).attr("font-weight", 500).text(meta);
+    }
+    y += titleFont + 12;
+    svg.append("line").attr("x1", cardM).attr("x2", width - cardM).attr("y1", y).attr("y2", y).attr("stroke", mix(palette.text, palette.bg, 22)).attr("stroke-width", 1);
+    y += 1;
+  }
+  const rowsTop = !hasTitle && anyLane ? cardM : y;
+  const body = svg.append("g").attr("clip-path", `url(#${clipId})`);
+  const col = {
+    text: palette.text,
+    muted,
+    faint,
+    line2,
+    tick: mix(palette.text, palette.bg, 35),
+    cardFill,
+    sw,
+    palette
+  };
+  let bannerH;
+  if (parsed.columns) {
+    bannerH = drawColumns(body, parsed, now, rowsTop, { width, cardM }, col);
+  } else {
+    let leftColW = rowH - 20;
+    let mainW = 0;
+    if (parsed.face === "digital") {
+      let secW = 0;
+      for (const e of parsed.entries) {
+        const p = zoneParts(e.zone, now);
+        const t = formatTime(p.h, p.m, p.s, parsed.hours12);
+        mainW = Math.max(mainW, estWidth(t.main, 48));
+        secW = Math.max(secW, estWidth(`:${t.sec}`, 16), estWidth(t.ap, 16));
+      }
+      leftColW = Math.max(92, mainW + 5 + secW);
+    }
+    parsed.entries.forEach((entry, i) => {
+      drawRow(
+        body,
+        entry,
+        i,
+        parsed,
+        now,
+        rowsTop + i * rowH,
+        rowH,
+        { padX, rightX, width, leftColW, mainW },
+        col
+      );
+    });
+    const rowsBottom = rowsTop + parsed.entries.length * rowH;
+    const bottomMargin = anyLane ? cardM : padY;
+    bannerH = Math.max(rowsBottom + bottomMargin, heightHint > 0 ? 0 : 120);
+  }
+  clipRect.attr("height", bannerH - 2 * cardM);
+  svg.attr("height", bannerH).attr("viewBox", `0 0 ${width} ${bannerH}`);
+  bgRect.attr("height", bannerH);
+  card.attr("height", bannerH - 2 * cardM);
+}
+function drawRow(svg, entry, index, parsed, now, rowTop, rowH, geom, col) {
+  const { padX } = geom;
+  const { text, muted, line2, tick, sw, cardFill } = col;
+  const center = rowTop + rowH / 2;
+  const parts = zoneParts(entry.zone, now);
+  const hasCoords = entry.lat !== null && entry.lon !== null;
+  const sun = parsed.sun && hasCoords ? sunLine(now, entry.lat, entry.lon) : null;
+  const up = sun ? sun.up : parts.h >= 6 && parts.h < 18;
+  const stColor = up ? sw.day : sw.night;
+  const stTint = up ? sw.dayTint : sw.nightTint;
+  const ts = formatTime(parts.h, parts.m, parts.s, parsed.hours12);
+  const work = parsed.work ? {
+    startMin: parsed.work.startMin,
+    endMin: parsed.work.endMin,
+    days: parsed.work.days
+  } : null;
+  const status = workStatus(parts, work);
+  const auto = resolveColorBy(parsed.colorBy, entry, index, {
+    up,
+    status,
+    localHour: parts.h,
+    sw,
+    palette: col.palette,
+    cardFill
+  });
+  const rightBlockW = 178;
+  const rightColLeft = geom.rightX - rightBlockW;
+  const g = svg.append("g").attr("data-line-number", entry.lineNumber);
+  if (auto) {
+    g.append("rect").attr("x", 9).attr("y", rowTop).attr("width", geom.width - 18).attr("height", rowH).attr("fill", auto.laneTint);
+  }
+  g.attr("data-dgmo-clock", "").attr("data-dgmo-clock-zone", entry.zone).attr("data-dgmo-clock-face", parsed.face).attr("data-dgmo-clock-hours12", parsed.hours12 ? "1" : "0").attr("data-dgmo-clock-sun", sun ? "1" : "0").attr("data-dgmo-clock-c-day", sw.day).attr("data-dgmo-clock-c-night", sw.night).attr("data-dgmo-clock-c-day-soft", sw.dayTint).attr("data-dgmo-clock-c-night-soft", sw.nightTint).attr("data-dgmo-clock-c-ok", sw.ok).attr("data-dgmo-clock-c-soon", sw.soon).attr("data-dgmo-clock-c-off", sw.off).attr("data-dgmo-clock-c-ok-soft", sw.okSoft).attr("data-dgmo-clock-c-soon-soft", sw.soonSoft).attr("data-dgmo-clock-c-off-soft", sw.offSoft);
+  if (entry.lat !== null) g.attr("data-dgmo-clock-lat", entry.lat);
+  if (entry.lon !== null) g.attr("data-dgmo-clock-lon", entry.lon);
+  if (parsed.work) {
+    g.attr("data-dgmo-clock-work-start", parsed.work.startMin).attr("data-dgmo-clock-work-end", parsed.work.endMin).attr(
+      "data-dgmo-clock-work-days",
+      WEEKDAY_ABBR.filter((d) => parsed.work.days[d]).join(",")
+    );
+  }
+  const contentLeft = padX + 4;
+  const timeColor = auto?.solid ?? text;
+  const faceFill = auto ? mix(auto.solid, cardFill, 20) : stTint;
+  const ringColor = auto?.solid ?? line2;
+  const accentColor = auto?.solid ?? stColor;
+  if (auto) {
+    g.attr("data-dgmo-clock-auto-solid", auto.solid).attr(
+      "data-dgmo-clock-auto-face",
+      faceFill
+    );
+  }
+  if (parsed.face === "analog") {
+    const size = rowH - 20;
+    const fx = contentLeft;
+    const fy = center - size / 2;
+    const fg = g.append("g").attr("transform", `translate(${fx},${fy}) scale(${size / 100})`);
+    fg.append("circle").attr("data-dgmo-clock-facebg", "").attr("cx", 50).attr("cy", 50).attr("r", 47).attr("fill", faceFill);
+    fg.append("circle").attr("data-dgmo-clock-facering", "").attr("cx", 50).attr("cy", 50).attr("r", 47).attr("fill", "none").attr("stroke", ringColor).attr("stroke-width", auto ? 1.6 : 1.4);
+    for (let k = 0; k < 12; k++) {
+      const a = k * 30 * Math.PI / 180;
+      fg.append("line").attr("x1", 50 + 39 * Math.sin(a)).attr("y1", 50 - 39 * Math.cos(a)).attr("x2", 50 + 46 * Math.sin(a)).attr("y2", 50 - 46 * Math.cos(a)).attr("stroke", tick).attr("stroke-width", 1.8);
+    }
+    const ang = handAngles(parts.h, parts.m, parts.s);
+    fg.append("line").attr("data-dgmo-clock-hand", "h").attr("x1", 50).attr("y1", 50).attr("x2", 50).attr("y2", 28).attr("stroke", text).attr("stroke-width", 4).attr("stroke-linecap", "round").attr("transform", `rotate(${ang.hour} 50 50)`);
+    fg.append("line").attr("data-dgmo-clock-hand", "m").attr("x1", 50).attr("y1", 50).attr("x2", 50).attr("y2", 17).attr("stroke", text).attr("stroke-width", 2.6).attr("stroke-linecap", "round").attr("transform", `rotate(${ang.minute} 50 50)`);
+    fg.append("line").attr("data-dgmo-clock-hand", "s").attr("x1", 50).attr("y1", 55).attr("x2", 50).attr("y2", 14).attr("stroke", accentColor).attr("stroke-width", 1.3).attr("stroke-linecap", "round").attr("transform", `rotate(${ang.second} 50 50)`);
+    fg.append("circle").attr("data-dgmo-clock-center", "").attr("cx", 50).attr("cy", 50).attr("r", 2.6).attr("fill", accentColor);
+  } else {
+    const mainFont = 48;
+    const baseY = center + 16;
+    const capTop = baseY - mainFont * 0.7;
+    g.append("text").attr("data-dgmo-clock-digital", "").attr("data-dgmo-clock-digital-part", "main").attr("x", contentLeft).attr("y", baseY).attr("fill", timeColor).attr("font-family", FONT_FAMILY).attr("font-size", mainFont).attr("font-weight", 600).style("font-variant-numeric", "tabular-nums").text(ts.main);
+    const sf = 20;
+    const mainW = [...ts.main].reduce(
+      (w, c) => w + mainFont * (c === ":" ? 0.28 : 0.6),
+      0
+    );
+    const stackX = contentLeft + mainW + 5;
+    g.append("text").attr("data-dgmo-clock-digital-part", "sec").attr("x", stackX).attr("y", capTop + sf * 0.72).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", sf).attr("font-weight", 600).style("font-variant-numeric", "tabular-nums").text(`:${ts.sec}`);
+    if (ts.ap)
+      g.append("text").attr("data-dgmo-clock-digital-part", "ap").attr("x", stackX).attr("y", baseY).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", sf).attr("font-weight", 600).text(ts.ap);
+  }
+  const midLeft = contentLeft + geom.leftColW + 26;
+  const midMaxW = Math.max(40, rightColLeft - 12 - midLeft);
+  const availH = rowH - 12;
+  const ladder = [48, 40, 34, 28, 24, 20, 17];
+  let aliasFont = 17;
+  let aliasLines = [];
+  for (const f of ladder) {
+    const maxLines = Math.max(1, Math.floor(availH / (f + 4)));
+    const ls = wrapText(entry.label, f, midMaxW, maxLines);
+    if (!ls.some((l) => l.endsWith("\u2026"))) {
+      aliasFont = f;
+      aliasLines = ls;
+      break;
+    }
+  }
+  if (aliasLines.length === 0) {
+    const maxLines = Math.max(1, Math.floor(availH / 21));
+    aliasLines = wrapText(entry.label, 17, midMaxW, maxLines);
+  }
+  const aliasLh = aliasFont + 4;
+  const firstBase = aliasLines.length === 1 ? center + 16 : center - aliasLines.length * aliasLh / 2 + aliasFont * 0.72;
+  const aliasFill = auto?.solid ?? mix(muted, text, Math.round((aliasFont - 17) / 31 * 55));
+  aliasLines.forEach((ln, i) => {
+    g.append("text").attr("x", midLeft).attr("y", firstBase + i * aliasLh).attr("fill", aliasFill).attr("font-family", FONT_FAMILY).attr("font-size", aliasFont).attr("font-weight", 650).text(ln);
+  });
+  const iconX = rightColLeft + 6;
+  const textX = rightColLeft + 20;
+  const textMax = geom.rightX - textX;
+  const lines = [];
+  if (entry.label !== entry.place) lines.push({ kind: "place" });
+  if (status) lines.push({ kind: "avail" });
+  if (sun) lines.push({ kind: "sun" });
+  const lh = 23;
+  const top = center + 10 - (lines.length - 1) * lh / 2;
+  lines.forEach((ln, i) => {
+    const yy = top + i * lh;
+    if (ln.kind === "place") {
+      g.append("path").attr("transform", `translate(${iconX},${yy - 5}) scale(1.25)`).attr("d", "M0,4 L-2.3,-0.6 A2.6,2.6 0 1 1 2.3,-0.6 Z").attr("fill", muted);
+      g.append("text").attr("x", textX).attr("y", yy).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", 14).attr("font-weight", 500).text(ellipsize(entry.place, 14, textMax));
+    } else if (ln.kind === "avail" && status) {
+      const stCol = status.cls === "ok" ? sw.ok : status.cls === "soon" ? sw.soon : sw.off;
+      const dot = g.append("circle").attr("data-dgmo-clock-status-dot", "").attr("cx", iconX).attr("cy", yy - 5).attr("r", 5);
+      if (status.cls === "off")
+        dot.attr("fill", "none").attr("stroke", stCol).attr("stroke-width", 1.6);
+      else dot.attr("fill", stCol).attr("stroke", "none");
+      g.append("text").attr("data-dgmo-clock-status", "").attr("x", textX).attr("y", yy).attr("fill", stCol).attr("font-family", FONT_FAMILY).attr("font-size", 14).attr("font-weight", 600).text(ellipsize(status.text, 14, textMax));
+    } else if (ln.kind === "sun" && sun) {
+      drawSunMoon(g, iconX, yy - 5, up, sw, 1.25);
+      g.append("text").attr("data-dgmo-clock-sun-line", "").attr("x", textX).attr("y", yy).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", 13.5).text(ellipsize(sun.text, 13.5, textMax));
+    }
+  });
+}
+function bakeAnchors(g, entry, parsed, sun, sw) {
+  g.attr("data-dgmo-clock", "").attr("data-dgmo-clock-zone", entry.zone).attr("data-dgmo-clock-face", parsed.face).attr("data-dgmo-clock-hours12", parsed.hours12 ? "1" : "0").attr("data-dgmo-clock-sun", sun ? "1" : "0").attr("data-dgmo-clock-c-day", sw.day).attr("data-dgmo-clock-c-night", sw.night).attr("data-dgmo-clock-c-day-soft", sw.dayTint).attr("data-dgmo-clock-c-night-soft", sw.nightTint).attr("data-dgmo-clock-c-ok", sw.ok).attr("data-dgmo-clock-c-soon", sw.soon).attr("data-dgmo-clock-c-off", sw.off).attr("data-dgmo-clock-c-ok-soft", sw.okSoft).attr("data-dgmo-clock-c-soon-soft", sw.soonSoft).attr("data-dgmo-clock-c-off-soft", sw.offSoft);
+  if (entry.lat !== null) g.attr("data-dgmo-clock-lat", entry.lat);
+  if (entry.lon !== null) g.attr("data-dgmo-clock-lon", entry.lon);
+  if (parsed.work) {
+    g.attr("data-dgmo-clock-work-start", parsed.work.startMin).attr("data-dgmo-clock-work-end", parsed.work.endMin).attr(
+      "data-dgmo-clock-work-days",
+      WEEKDAY_ABBR.filter((d) => parsed.work.days[d]).join(",")
+    );
+  }
+}
+function drawColumns(body, parsed, now, top, geom, col) {
+  const { width, cardM } = geom;
+  const { text, muted, line2, tick, cardFill, sw } = col;
+  const n = Math.max(1, parsed.entries.length);
+  const colW = (width - 2 * cardM) / n;
+  const tints = [];
+  let maxBottom = top;
+  parsed.entries.forEach((entry, i) => {
+    const x0 = cardM + i * colW;
+    const cx = x0 + colW / 2;
+    const parts = zoneParts(entry.zone, now);
+    const hasCoords = entry.lat !== null && entry.lon !== null;
+    const sun = parsed.sun && hasCoords ? sunLine(now, entry.lat, entry.lon) : null;
+    const up = sun ? sun.up : parts.h >= 6 && parts.h < 18;
+    const ts = formatTime(parts.h, parts.m, parts.s, parsed.hours12);
+    const work = parsed.work ? {
+      startMin: parsed.work.startMin,
+      endMin: parsed.work.endMin,
+      days: parsed.work.days
+    } : null;
+    const status = workStatus(parts, work);
+    const stColor = up ? sw.day : sw.night;
+    const stTint = up ? sw.dayTint : sw.nightTint;
+    const auto = resolveColorBy(parsed.colorBy, entry, i, {
+      up,
+      status,
+      localHour: parts.h,
+      sw,
+      palette: col.palette,
+      cardFill
+    });
+    const timeColor = auto?.solid ?? text;
+    const faceFill = auto ? mix(auto.solid, cardFill, 20) : stTint;
+    const ringColor = auto?.solid ?? line2;
+    const accentColor = auto?.solid ?? stColor;
+    if (auto)
+      tints.push(
+        body.append("rect").attr("x", x0).attr("y", top).attr("width", colW).attr("fill", auto.laneTint)
+      );
+    const g = body.append("g").attr("data-line-number", entry.lineNumber);
+    bakeAnchors(g, entry, parsed, sun, sw);
+    if (auto) {
+      g.attr("data-dgmo-clock-auto-solid", auto.solid).attr(
+        "data-dgmo-clock-auto-face",
+        faceFill
+      );
+    }
+    let cy = top + (parsed.face === "analog" ? 22 : 36);
+    const innerW = colW - 16;
+    if (parsed.face === "analog") {
+      const size = Math.min(innerW, 96);
+      const fg = g.append("g").attr(
+        "transform",
+        `translate(${cx - size / 2},${cy}) scale(${size / 100})`
+      );
+      fg.append("circle").attr("data-dgmo-clock-facebg", "").attr("cx", 50).attr("cy", 50).attr("r", 47).attr("fill", faceFill);
+      fg.append("circle").attr("data-dgmo-clock-facering", "").attr("cx", 50).attr("cy", 50).attr("r", 47).attr("fill", "none").attr("stroke", ringColor).attr("stroke-width", auto ? 1.6 : 1.4);
+      for (let k = 0; k < 12; k++) {
+        const a = k * 30 * Math.PI / 180;
+        fg.append("line").attr("x1", 50 + 39 * Math.sin(a)).attr("y1", 50 - 39 * Math.cos(a)).attr("x2", 50 + 46 * Math.sin(a)).attr("y2", 50 - 46 * Math.cos(a)).attr("stroke", tick).attr("stroke-width", 1.8);
+      }
+      const ang = handAngles(parts.h, parts.m, parts.s);
+      fg.append("line").attr("data-dgmo-clock-hand", "h").attr("x1", 50).attr("y1", 50).attr("x2", 50).attr("y2", 28).attr("stroke", text).attr("stroke-width", 4).attr("stroke-linecap", "round").attr("transform", `rotate(${ang.hour} 50 50)`);
+      fg.append("line").attr("data-dgmo-clock-hand", "m").attr("x1", 50).attr("y1", 50).attr("x2", 50).attr("y2", 17).attr("stroke", text).attr("stroke-width", 2.6).attr("stroke-linecap", "round").attr("transform", `rotate(${ang.minute} 50 50)`);
+      fg.append("line").attr("data-dgmo-clock-hand", "s").attr("x1", 50).attr("y1", 55).attr("x2", 50).attr("y2", 14).attr("stroke", accentColor).attr("stroke-width", 1.3).attr("stroke-linecap", "round").attr("transform", `rotate(${ang.second} 50 50)`);
+      fg.append("circle").attr("data-dgmo-clock-center", "").attr("cx", 50).attr("cy", 50).attr("r", 2.6).attr("fill", accentColor);
+      cy += size + 6;
+    } else {
+      const sf = 13;
+      const tf = fitFont(ts.main, 44, innerW - 30, 20);
+      const mainW = [...ts.main].reduce(
+        (w, c) => w + tf * (c === ":" ? 0.28 : 0.6),
+        0
+      );
+      const stackW = Math.max(estWidth(`:${ts.sec}`, sf), estWidth(ts.ap, sf));
+      const gLeft = cx - (mainW + 7 + stackW) / 2;
+      const baseY = cy + tf * 0.34;
+      g.append("text").attr("data-dgmo-clock-digital", "").attr("data-dgmo-clock-digital-part", "main").attr("x", gLeft).attr("y", baseY).attr("fill", timeColor).attr("font-family", FONT_FAMILY).attr("font-size", tf).attr("font-weight", 600).style("font-variant-numeric", "tabular-nums").text(ts.main);
+      const stackX = gLeft + mainW + 7;
+      g.append("text").attr("data-dgmo-clock-digital-part", "sec").attr("x", stackX).attr("y", baseY - tf * 0.32).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", sf).attr("font-weight", 500).text(`:${ts.sec}`);
+      if (ts.ap)
+        g.append("text").attr("data-dgmo-clock-digital-part", "ap").attr("x", stackX).attr("y", baseY).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", sf).attr("font-weight", 500).text(ts.ap);
+      cy += tf + 8;
+    }
+    const amax = colW - 14;
+    let af = 14;
+    let alines = [];
+    for (const f of [26, 22, 19, 16, 14]) {
+      const ml = Math.max(1, Math.floor(70 / (f + 3)));
+      const ls = wrapText(entry.label, f, amax, ml);
+      if (!ls.some((l) => l.endsWith("\u2026"))) {
+        af = f;
+        alines = ls;
+        break;
+      }
+    }
+    if (!alines.length) alines = wrapText(entry.label, 14, amax, 3);
+    const alh = af + 3;
+    const aFill = auto?.solid ?? mix(muted, text, Math.round((af - 14) / 12 * 55));
+    alines.forEach(
+      (ln, j) => g.append("text").attr("x", cx).attr("y", cy + af * 0.72 + j * alh).attr("text-anchor", "middle").attr("fill", aFill).attr("font-family", FONT_FAMILY).attr("font-size", af).attr("font-weight", 650).text(ln)
+    );
+    cy += alines.length * alh + 12;
+    const kinds = [];
+    if (entry.label !== entry.place) kinds.push("place");
+    if (status) kinds.push("avail");
+    if (sun) kinds.push("sun");
+    const iconX = x0 + 16;
+    const textX = x0 + 28;
+    const tmax = colW - 40;
+    kinds.forEach((kind, j) => {
+      const yy = cy + j * 20;
+      if (kind === "place") {
+        g.append("path").attr("transform", `translate(${iconX},${yy - 4})`).attr("d", "M0,4 L-2.3,-0.6 A2.6,2.6 0 1 1 2.3,-0.6 Z").attr("fill", muted);
+        g.append("text").attr("x", textX).attr("y", yy).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", 12).text(ellipsize(entry.place, 12, tmax));
+      } else if (kind === "avail" && status) {
+        const stCol = status.cls === "ok" ? sw.ok : status.cls === "soon" ? sw.soon : sw.off;
+        const dot = g.append("circle").attr("data-dgmo-clock-status-dot", "").attr("cx", iconX).attr("cy", yy - 4).attr("r", 4);
+        if (status.cls === "off")
+          dot.attr("fill", "none").attr("stroke", stCol).attr("stroke-width", 1.4);
+        else dot.attr("fill", stCol).attr("stroke", "none");
+        g.append("text").attr("data-dgmo-clock-status", "").attr("x", textX).attr("y", yy).attr("fill", stCol).attr("font-family", FONT_FAMILY).attr("font-size", 12).attr("font-weight", 600).text(ellipsize(status.text, 12, tmax));
+      } else if (kind === "sun" && sun) {
+        drawSunMoon(g, iconX, yy - 4, up, sw, 1);
+        g.append("text").attr("data-dgmo-clock-sun-line", "").attr("x", textX).attr("y", yy).attr("fill", muted).attr("font-family", FONT_FAMILY).attr("font-size", 11.5).text(ellipsize(sun.text, 11.5, tmax));
+      }
+    });
+    const bottom = kinds.length ? cy + (kinds.length - 1) * 20 + 8 : cy;
+    if (bottom > maxBottom) maxBottom = bottom;
+  });
+  const colBodyH = maxBottom - top + 14;
+  tints.forEach((r) => r.attr("height", colBodyH));
+  return top + colBodyH + cardM;
+}
+function renderClockForExport(container, parsed, palette, isDark, exportDims) {
+  renderClock(container, parsed, palette, isDark, exportDims);
+}
+
+export {
+  zoneParts,
+  formatTime,
+  workStatus,
+  sunLine,
+  handAngles,
+  renderClock,
+  renderClockForExport
+};
+//# sourceMappingURL=chunk-7PQYTZMA.js.map