@diagrammo/dgmo 0.49.0 → 0.50.0

package/dist/chunk-BTUTZMPT.js

@@ -0,0 +1,482 @@
+import {
+  monthIndex,
+  resolveNext,
+  weekdayIndex
+} from "./chunk-YNRDWYZP.js";
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine
+} from "./chunk-OTAL43EH.js";
+import {
+  makeDgmoError,
+  makeFail
+} from "./chunk-CXK4DZH3.js";
+
+// src/countdown/parser.ts
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var TIME_24H_RE = /^(\d{1,2}):(\d{2})$/;
+var AMPM_RE = /^(\d{1,2})(?::(\d{2}))?\s*([ap]m)$/i;
+function targetToMs(target) {
+  const s = target.trim();
+  if (DATE_ONLY_RE.test(s)) {
+    const [y, m, d] = s.split("-").map(Number);
+    return new Date(y, m - 1, d).getTime();
+  }
+  const t = new Date(s).getTime();
+  return Number.isFinite(t) ? t : null;
+}
+function ordinalToken(tok) {
+  const t = tok.toLowerCase();
+  if (t === "last") return -1;
+  const m = t.match(/^(\d+)(?:st|nd|rd|th)?$/);
+  if (m) {
+    const n = Number(m[1]);
+    return n >= 1 && n <= 5 ? n : null;
+  }
+  return null;
+}
+function parse24h(tok) {
+  const m = tok.match(TIME_24H_RE);
+  if (!m) return null;
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  if (hour > 23 || minute > 59) return null;
+  return { hour, minute };
+}
+function parseAt(rest, lineNum, softError) {
+  const t = parse24h(rest.trim());
+  if (t) return t;
+  const fixed = ampmTo24h(rest.trim());
+  softError(
+    lineNum,
+    fixed ? `"at ${rest}": use 24h time (${fixed}).` : `"at" needs a 24h time like 18:00 (got "${rest}").`
+  );
+  return null;
+}
+function ampmTo24h(tok) {
+  const m = tok.match(AMPM_RE);
+  if (!m) return null;
+  let hour = Number(m[1]) % 12;
+  if (/pm/i.test(m[3])) hour += 12;
+  return `${String(hour).padStart(2, "0")}:${m[2] ?? "00"}`;
+}
+function parseCountdown(content, palette) {
+  const result = {
+    type: "countdown",
+    title: null,
+    titleLineNumber: null,
+    target: null,
+    targetMs: null,
+    rule: null,
+    resolvedMs: null,
+    hasTime: false,
+    since: null,
+    sinceLabel: null,
+    units: "human",
+    round: "up",
+    fields: ["d", "h", "m", "s"],
+    lang: "en",
+    onDay: null,
+    expired: null,
+    note: null,
+    noVisual: false,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const warn = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  const softError = (line, message) => {
+    result.diagnostics.push(makeDgmoError(line, message, "error"));
+  };
+  if (!content?.trim()) return fail(0, "No content provided");
+  const lines = content.split("\n");
+  let headerParsed = false;
+  let cadence = null;
+  let intervalN = 1;
+  let intervalUnit = "day";
+  let onSpec = null;
+  let atTime = null;
+  let anchorMs = null;
+  let targetMs = null;
+  let hasTargetLine = false;
+  let hasEvery = false;
+  const noteBody = [];
+  let inNote = false;
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1;
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (!headerParsed) {
+      const first = parseFirstLine(trimmed);
+      if (first?.chartType !== "countdown") {
+        return fail(lineNum, 'Expected "countdown [Title]" as the first line.');
+      }
+      if (first.title) {
+        const { label, color } = extractColor(
+          first.title,
+          palette,
+          result.diagnostics,
+          lineNum
+        );
+        result.title = label || null;
+        if (color !== void 0) result.color = color;
+      }
+      result.titleLineNumber = lineNum;
+      headerParsed = true;
+      continue;
+    }
+    if (measureIndent(raw) > 0) {
+      if (inNote) noteBody.push(trimmed);
+      else
+        warn(
+          lineNum,
+          `Indented content "${trimmed}" ignored \u2014 countdown is a single value.`
+        );
+      continue;
+    }
+    const [keyword, ...restTokens] = trimmed.split(/\s+/);
+    const key = keyword.toLowerCase();
+    const rest = restTokens.join(" ").trim();
+    if (key !== "note") inNote = false;
+    switch (key) {
+      // ── One-shot target ──
+      case "target": {
+        hasTargetLine = true;
+        if (/^now$/i.test(rest)) {
+          targetMs = Date.now();
+          result.target = new Date(targetMs).toISOString();
+          result.hasTime = true;
+        } else {
+          const ms = targetToMs(rest);
+          if (ms === null) {
+            softError(
+              lineNum,
+              `"target" needs an ISO date/datetime or "now" (got "${rest}").`
+            );
+          } else {
+            result.target = rest;
+            targetMs = ms;
+            if (rest.includes("T")) result.hasTime = true;
+          }
+        }
+        break;
+      }
+      // ── Recurrence — the canonical single-line form:
+      //   every <cadence> [on <instant>] [at <time>] [from <date>]
+      // (each slot may also appear on its own line — handled below.)
+      case "every": {
+        hasEvery = true;
+        const seg = {
+          cadence: [],
+          on: [],
+          at: [],
+          from: []
+        };
+        let cur = "cadence";
+        for (const tok of rest.split(/\s+/).filter(Boolean)) {
+          const low = tok.toLowerCase();
+          if (low === "on" || low === "at" || low === "from") cur = low;
+          else seg[cur].push(tok);
+        }
+        const head = (seg.cadence[0] ?? "").toLowerCase();
+        const bareInterval = (head === "day" || head === "week" || head === "month") && seg.from.length > 0 && seg.on.length === 0;
+        if (bareInterval) {
+          cadence = "interval";
+          intervalN = 1;
+          intervalUnit = head;
+        } else if (head === "year" || head === "month" || head === "week") {
+          cadence = head;
+        } else if (head === "day") {
+          softError(
+            lineNum,
+            "`every day` needs `from <date>` (an interval anchor)."
+          );
+          break;
+        } else if (/^\d+$/.test(head) && seg.cadence[1]) {
+          const unit = seg.cadence[1].toLowerCase().replace(/s$/, "");
+          if (unit === "day" || unit === "week" || unit === "month") {
+            cadence = "interval";
+            intervalN = Number(head);
+            intervalUnit = unit;
+          } else {
+            softError(
+              lineNum,
+              `every ${head} <days|weeks|months> \u2014 unknown unit "${seg.cadence[1]}".`
+            );
+          }
+        } else {
+          emitFreeProseError(lineNum, rest, softError);
+          break;
+        }
+        if (seg.on.length)
+          onSpec = parseOn(seg.on.join(" "), lineNum, softError);
+        if (seg.at.length)
+          atTime = parseAt(seg.at.join(" "), lineNum, softError);
+        if (seg.from.length) {
+          const ms = targetToMs(seg.from.join(" "));
+          if (ms === null) {
+            softError(
+              lineNum,
+              `"from" needs an anchor date (got "${seg.from.join(" ")}").`
+            );
+          } else {
+            anchorMs = ms;
+          }
+        }
+        break;
+      }
+      // Standalone slot lines (lenient multi-line form).
+      case "on": {
+        onSpec = parseOn(rest, lineNum, softError);
+        break;
+      }
+      case "at": {
+        const t = parseAt(rest, lineNum, softError);
+        if (t) atTime = t;
+        break;
+      }
+      case "from": {
+        const ms = targetToMs(rest);
+        if (ms === null) {
+          softError(lineNum, `"from" needs an anchor date (got "${rest}").`);
+        } else {
+          anchorMs = ms;
+        }
+        break;
+      }
+      // ── Ordinal / since — numbers a yearly occurrence (resolvedYear − since) ──
+      case "since": {
+        const y = Number(rest);
+        if (Number.isInteger(y) && y > 0) result.since = y;
+        else softError(lineNum, `"since" needs a year (got "${rest}").`);
+        break;
+      }
+      // The eyebrow template: `Nth` → ordinal word, `N` → the number.
+      case "since-label":
+        result.sinceLabel = rest || null;
+        break;
+      // ── Display ──
+      case "units": {
+        const v = rest.toLowerCase();
+        if (v === "human" || v === "days" || v === "full" || v === "clock" || v === "weeks" || v === "words" || v === "compound") {
+          result.units = v;
+        } else {
+          warn(
+            lineNum,
+            `Unknown units "${rest}" \u2014 use human|days|full|clock|weeks|words.`
+          );
+        }
+        break;
+      }
+      case "round": {
+        const v = rest.toLowerCase();
+        if (v === "up" || v === "down" || v === "nearest") {
+          result.round = v;
+        } else {
+          warn(lineNum, `Unknown round "${rest}" \u2014 use up|down|nearest.`);
+        }
+        break;
+      }
+      case "fields": {
+        const set = rest.split(/[,\s]+/).map((f) => f.toLowerCase()).filter((f) => ["d", "h", "m", "s"].includes(f));
+        if (set.length) result.fields = set;
+        else
+          warn(lineNum, `"fields" needs a subset of d,h,m,s (got "${rest}").`);
+        break;
+      }
+      case "lang":
+        result.lang = rest.toLowerCase() || "en";
+        break;
+      case "on-day":
+        result.onDay = rest || null;
+        break;
+      case "expired":
+        result.expired = rest;
+        break;
+      // ── `no-visual` — suppress the default-on calendar band (§36.6). ──
+      case "no-visual":
+        result.noVisual = true;
+        break;
+      // ── `note` — markdown caption; inline value or indented body block. ──
+      case "note":
+        inNote = true;
+        if (rest) noteBody.push(rest);
+        break;
+      default:
+        warn(lineNum, `Unrecognized line "${trimmed}".`);
+    }
+  }
+  if (noteBody.length) result.note = noteBody.join("\n");
+  if (hasEvery && hasTargetLine) {
+    softError(
+      result.titleLineNumber ?? 1,
+      "A countdown has either `target` (one-shot) or `every` (recurring), not both."
+    );
+  }
+  if (result.expired !== null && hasEvery) {
+    warn(
+      result.titleLineNumber ?? 1,
+      "`expired` applies only to one-shot `target` blocks; recurring blocks roll forward."
+    );
+  }
+  if (hasEvery && cadence) {
+    const rule = assembleRule(
+      cadence,
+      { intervalN, intervalUnit, anchorMs },
+      onSpec,
+      atTime,
+      result.titleLineNumber ?? 1,
+      softError
+    );
+    if (rule) {
+      result.rule = rule;
+      result.resolvedMs = resolveNext(rule, Date.now());
+      if (atTime) result.hasTime = true;
+    }
+  } else if (targetMs !== null) {
+    result.targetMs = targetMs;
+    result.resolvedMs = targetMs;
+  }
+  if (result.resolvedMs === null && result.error === null) {
+    if (!hasEvery && !hasTargetLine) {
+      softError(
+        result.titleLineNumber ?? 1,
+        "Missing `target` or `every` \u2014 a countdown needs one."
+      );
+    }
+  }
+  return result;
+}
+function parseOn(rest, lineNum, softError) {
+  const toks = rest.split(/\s+/).filter(Boolean);
+  if (toks.length === 0) {
+    softError(
+      lineNum,
+      '"on" needs a target (e.g. "Aug 21", "3rd Tuesday", "Friday").'
+    );
+    return null;
+  }
+  const ord = ordinalToken(toks[0]);
+  if (ord !== null && toks[1]) {
+    const wd2 = weekdayIndex(toks[1]);
+    if (wd2 === null) {
+      softError(lineNum, `"${toks[1]}" is not a weekday.`);
+      return null;
+    }
+    return { nth: ord, weekday: wd2 };
+  }
+  const mo = monthIndex(toks[0]);
+  if (mo !== null && toks[1]) {
+    const day = Number(toks[1].replace(/(st|nd|rd|th)$/i, ""));
+    if (!Number.isInteger(day) || day < 1 || day > 31) {
+      softError(lineNum, `"${toks[1]}" is not a valid day of month.`);
+      return null;
+    }
+    return { month: mo, day };
+  }
+  const wd = weekdayIndex(toks[0]);
+  if (wd !== null) return { weekday: wd };
+  softError(
+    lineNum,
+    `"on ${rest}" \u2014 use "Aug 21", "3rd Tuesday", "last Friday", or a weekday.`
+  );
+  return null;
+}
+function assembleRule(cadence, interval, onSpec, atTime, lineNum, softError) {
+  const hour = atTime?.hour ?? 0;
+  const minute = atTime?.minute ?? 0;
+  const allDay = atTime === null;
+  if (cadence === "interval") {
+    return {
+      kind: "interval",
+      intervalN: interval.intervalN,
+      intervalUnit: interval.intervalUnit,
+      anchorMs: interval.anchorMs ?? void 0,
+      hour,
+      minute,
+      allDay
+    };
+  }
+  if (cadence === "year") {
+    if (onSpec?.month === void 0 || onSpec.day === void 0) {
+      softError(
+        lineNum,
+        "`every year` needs `on <Month> <Day>` (e.g. on Aug 21)."
+      );
+      return null;
+    }
+    return {
+      kind: "month-day",
+      month: onSpec.month,
+      day: onSpec.day,
+      hour,
+      minute,
+      allDay
+    };
+  }
+  if (cadence === "month") {
+    if (onSpec?.nth === void 0 || onSpec.weekday === void 0) {
+      softError(
+        lineNum,
+        "`every month` needs `on <nth> <weekday>`, `on last <weekday>`, or `from <date>`."
+      );
+      return null;
+    }
+    return onSpec.nth < 0 ? { kind: "last-weekday", weekday: onSpec.weekday, hour, minute, allDay } : {
+      kind: "nth-weekday",
+      nth: onSpec.nth,
+      weekday: onSpec.weekday,
+      hour,
+      minute,
+      allDay
+    };
+  }
+  if (onSpec?.weekday === void 0 || onSpec.nth !== void 0) {
+    softError(lineNum, "`every week` needs `on <weekday>` (e.g. on Friday).");
+    return null;
+  }
+  return { kind: "weekly", weekday: onSpec.weekday, hour, minute, allDay };
+}
+function emitFreeProseError(lineNum, rest, softError) {
+  const toks = rest.split(/\s+/).filter(Boolean);
+  const problems = [];
+  let onPart = "";
+  let atPart = "";
+  for (let i = 0; i < toks.length; i++) {
+    const tok = toks[i];
+    const fixed = ampmTo24h(tok);
+    if (fixed) {
+      problems.push(`"${tok}": use 24h time (${fixed})`);
+      atPart = ` at ${fixed}`;
+      continue;
+    }
+    const wd = weekdayIndex(tok);
+    if (wd !== null) onPart = `week on ${tok}`;
+    const mo = monthIndex(tok);
+    if (mo !== null && toks[i + 1] && /^\d/.test(toks[i + 1])) {
+      onPart = `year on ${tok} ${toks[i + 1]}`;
+    }
+  }
+  if (!onPart && !atPart) {
+    problems.push(
+      "bare cadence \u2014 use year | month | week | N days|weeks|months"
+    );
+  } else if (onPart.startsWith("week")) {
+    problems.push("bare weekday needs a cadence");
+  }
+  const suggestion = onPart ? `every ${onPart}${atPart}` : `every week \u2026${atPart}`;
+  softError(
+    lineNum,
+    `Free-form recurrence rejected. ${problems.join("; ")}. Try: ${suggestion}`
+  );
+}
+
+export {
+  targetToMs,
+  parseCountdown
+};
+//# sourceMappingURL=chunk-BTUTZMPT.js.map

package/dist/{chunk-UVCXZEGU.js → chunk-CVV36CWI.js}

@@ -4,7 +4,7 @@ import {
 import {
   resolveTagColor,
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   resolveColor
 } from "./chunk-TLVIHFRO.js";
@@ -164,4 +164,4 @@ export {
   formatPct,
   buildLegend
 };
-//# sourceMappingURL=chunk-UVCXZEGU.js.map
+//# sourceMappingURL=chunk-CVV36CWI.js.map

package/dist/{chunk-TC3YWBFO.js → chunk-DMJJ3CEQ.js}

@@ -1,19 +1,20 @@
 import {
+  BODY_TERMS,
   getFigure,
   resolvePartKey
-} from "./chunk-3NFJWFNP.js";
+} from "./chunk-BDXC7MDK.js";
 import {
   AUTO_TAG_COLOR_SENTINEL,
   finalizeAutoTagColors,
   matchTagBlockHeading,
   stripDefaultModifier,
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   extractColor,
   measureIndent,
   parseFirstLine
-} from "./chunk-ZNQX6QWH.js";
+} from "./chunk-OTAL43EH.js";
 import {
   emit
 } from "./chunk-CXK4DZH3.js";
@@ -189,17 +190,28 @@ function parseBody(content, palette) {
       if (m) {
         contentStarted = true;
         currentTagGroup = null;
+        let name = m[1];
+        let rest = m[2] ?? "";
+        let side;
+        if (/^(left|right)$/i.test(name)) {
+          const m2 = rest.match(PART_RE);
+          if (m2) {
+            side = name.toLowerCase();
+            name = m2[1];
+            rest = m2[2] ?? "";
+          }
+        }
         const metadata = {};
-        const rest = m[2] ?? "";
         for (const pair of rest.matchAll(META_PAIR_RE)) {
           const key = aliasMap.get(pair[1].toLowerCase()) ?? tagAttrKey(pair[1]);
           metadata[key] = pair[2].trim();
         }
         currentPart = {
-          name: m[1],
+          name,
           metadata,
           notes: [],
-          lineNumber
+          lineNumber,
+          ...side && { side }
         };
         parts.push(currentPart);
         continue;
@@ -225,9 +237,18 @@ function parseBody(content, palette) {
     diagnostics
   };
 }
+function extractSymbols(docText) {
+  const parsed = parseBody(docText);
+  const figures = (parsed.options.views.length ? parsed.options.views : ["front"]).map((v) => getFigure(parsed.options.sex, v));
+  const entities = BODY_TERMS.filter(
+    (t) => t === "left" || t === "right" || figures.some((f) => resolvePartKey(f, t))
+  );
+  return { kind: "body", entities };
+}
 
 export {
   BODY_DIAGNOSTICS,
-  parseBody
+  parseBody,
+  extractSymbols
 };
-//# sourceMappingURL=chunk-TC3YWBFO.js.map
+//# sourceMappingURL=chunk-DMJJ3CEQ.js.map

package/dist/{chunk-NVT6C2VE.js → chunk-EJTKV7CY.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-YYVTBZZC.js";
 import {
   renderIntegratedLegend
-} from "./chunk-4UDKKGHH.js";
+} from "./chunk-QUJGFNFN.js";
 import {
   getMaxLegendReservedHeight
 } from "./chunk-7UEMZREK.js";
@@ -29,7 +29,7 @@ import {
 } from "./chunk-5LWQH6QV.js";
 import {
   parseKanban
-} from "./chunk-O5MQPK7E.js";
+} from "./chunk-I4IFRCUB.js";
 import {
   contrastText,
   mix,
@@ -37,7 +37,7 @@ import {
 } from "./chunk-P6T66CCZ.js";
 import {
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-WCUHAQKB.js";
 
 // src/kanban/renderer.ts
 import * as d3Selection from "d3-selection";
@@ -882,4 +882,4 @@ export {
   renderKanban,
   renderKanbanForExport
 };
-//# sourceMappingURL=chunk-NVT6C2VE.js.map
+//# sourceMappingURL=chunk-EJTKV7CY.js.map

package/dist/{chunk-4NQ3IKUM.js → chunk-ER5SCQWQ.js}

@@ -17,7 +17,7 @@ import {
 import {
   resolveTagColor,
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-WCUHAQKB.js";
 import {
   CATEGORICAL_COLOR_ORDER,
   resolveColor
@@ -113,7 +113,7 @@ function renderSwimlaneForExport(container, parsed, layout, palette, isDark, opt
   });
   const root = svg.append("g").attr("transform", `translate(0, ${titleOffset})`);
   if (parsed.title) {
-    svg.append("text").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).text(parsed.title);
+    svg.append("text").attr("class", "chart-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).attr("data-line-number", String(parsed.titleLineNumber ?? 1)).text(parsed.title);
   }
   const laneColorById = /* @__PURE__ */ new Map();
   parsed.lanes.forEach((lane, i) => {
@@ -223,7 +223,7 @@ function renderSwimlaneForExport(container, parsed, layout, palette, isDark, opt
       marker = `sw-arrow-${ev.success.replace("#", "")}`;
     }
     const d = roundedPolyline(e.points, EDGE_CORNER_R);
-    edgeG.append("path").attr("d", d).attr("fill", "none").attr("stroke", stroke).attr("stroke-width", EDGE_STROKE).attr("stroke-dasharray", e.back ? "5 4" : null).attr("marker-end", `url(#${marker})`).attr("data-line-number", String(e.lineNumber));
+    edgeG.append("path").attr("class", "sw-edge sw-edge-group").attr("d", d).attr("fill", "none").attr("stroke", stroke).attr("stroke-width", EDGE_STROKE).attr("stroke-dasharray", e.back ? "5 4" : null).attr("marker-end", `url(#${marker})`).attr("data-line-number", String(e.lineNumber));
     if (e.label) {
       const segLen = [];
       let total = 0;
@@ -300,7 +300,7 @@ function renderSwimlaneForExport(container, parsed, layout, palette, isDark, opt
   const nodesG = root.append("g").attr("class", "dgmo-swimlane-nodes");
   for (const n of layout.nodes) {
     const { fill, stroke } = nodeFill(n);
-    const g = nodesG.append("g").attr("data-line-number", String(n.lineNumber)).attr("data-lane", n.lane);
+    const g = nodesG.append("g").attr("class", "sw-node").attr("data-node-id", n.id).attr("data-line-number", String(n.lineNumber)).attr("data-lane", n.lane);
     const cx = n.x;
     const cy = n.y;
     if (n.shape === "exclusive" || n.shape === "parallel") {
@@ -391,4 +391,4 @@ function drawCenteredLabel(g, label, cx, cy, fill, fontSize, tight = false, halo
 export {
   renderSwimlaneForExport
 };
-//# sourceMappingURL=chunk-4NQ3IKUM.js.map
+//# sourceMappingURL=chunk-ER5SCQWQ.js.map

package/dist/{chunk-7VLUGEMJ.js → chunk-F5UDBSJY.js}

@@ -5,10 +5,10 @@ import {
   formatPct,
   resolveCellColor,
   resolveColorMode
-} from "./chunk-UVCXZEGU.js";
+} from "./chunk-CVV36CWI.js";
 import {
   renderIntegratedLegend
-} from "./chunk-4UDKKGHH.js";
+} from "./chunk-QUJGFNFN.js";
 import {
   getMaxLegendReservedHeight
 } from "./chunk-7UEMZREK.js";
@@ -33,7 +33,7 @@ import {
 } from "./chunk-P6T66CCZ.js";
 import {
   tagAttrKey
-} from "./chunk-HBVD67XG.js";
+} from "./chunk-WCUHAQKB.js";
 
 // src/treemap/renderer.ts
 import * as d3Selection from "d3-selection";
@@ -381,4 +381,4 @@ export {
   renderTreemapForExport,
   renderTreemap
 };
-//# sourceMappingURL=chunk-7VLUGEMJ.js.map
+//# sourceMappingURL=chunk-F5UDBSJY.js.map