@50arms/ui 0.0.0-stage → 35.2.0

package/dist/lib/interactive-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-target.js","sources":["../../src/lib/interactive-target.ts"],"sourcesContent":["/* ============================================================================\n   INTERACTIVE TARGET (DX-4398)\n\n   A press that lands on a real control belongs to that control. A pointer\n   gesture that captures the pointer anyway takes the click away from it: the\n   browser retargets the matching pointerup, and the click it synthesises, at the\n   CAPTOR, so the control's own `onClick` never fires and nothing throws — it just\n   looks broken. Every gesture layer that owns pointer capture (the camera's\n   `viewport-gesture`, the node canvas's `use-canvas-gestures`, the file viewer's\n   double-click) asks this one question instead of keeping its own selector.\n   ========================================================================= */\n\nexport const INTERACTIVE_SELECTOR = \"button, a, input, textarea, select, [role='button']\";\n\n/** True when `target` is, or is inside, a control. */\nexport function isInteractiveTarget(target: EventTarget | null): boolean {\n  return target instanceof Element && target.closest(INTERACTIVE_SELECTOR) !== null;\n}\n"],"names":["INTERACTIVE_SELECTOR","isInteractiveTarget","target"],"mappings":"AAYO,MAAMA,IAAuB;AAG7B,SAASC,EAAoBC,GAAqC;AACvE,SAAOA,aAAkB,WAAWA,EAAO,QAAQF,CAAoB,MAAM;AAC/E;"}

package/dist/lib/intl-cache.js

@@ -0,0 +1,69 @@
+const u = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map();
+function s(r, n) {
+  const e = `${r}|${JSON.stringify(n)}`;
+  let t = u.get(e);
+  return t || (t = new Intl.NumberFormat(r, n), u.set(e, t)), t;
+}
+function y(r, n) {
+  const e = `${r}|${JSON.stringify(n)}`;
+  let t = a.get(e);
+  return t || (t = new Intl.DateTimeFormat(r, n), a.set(e, t)), t;
+}
+function d(r, n = {}) {
+  const e = `${r}|${JSON.stringify(n)}`;
+  let t = l.get(e);
+  return t || (t = new Intl.ListFormat(r, n), l.set(e, t)), t;
+}
+function F(r, n = {}) {
+  const e = `${r}|${JSON.stringify(n)}`;
+  let t = c.get(e);
+  return t || (t = new Intl.Collator(r, n), c.set(e, t)), t;
+}
+function $(r, n = {}) {
+  const e = `${r}|${JSON.stringify(n)}`;
+  let t = f.get(e);
+  return t || (t = new Intl.PluralRules(r, n), f.set(e, t)), t;
+}
+function p(r) {
+  const n = s(r, { useGrouping: !0, minimumFractionDigits: 1 }).formatToParts(-12345675e-1);
+  return {
+    group: n.find((e) => e.type === "group").value,
+    decimal: n.find((e) => e.type === "decimal").value
+  };
+}
+function w(r, n, e = []) {
+  const { group: t, decimal: m } = p(n);
+  let i = r;
+  for (const g of e) i = i.split(g).join("");
+  if (/^\s$/.test(t) ? i = i.replace(/\s/g, "") : i = i.split(t).join(""), i = i.split(m).join("."), !/^-?\d+(\.\d+)?$/.test(i)) return null;
+  const o = Number(i);
+  return Number.isFinite(o) ? o : null;
+}
+function N(r, n, e) {
+  const t = /* @__PURE__ */ new Date(0);
+  return t.setUTCFullYear(r, n - 1, e), t;
+}
+function b(r) {
+  const n = [];
+  for (let e = 0; e < 10; e++) {
+    const t = s(r, {}).format(e);
+    n.push(t);
+  }
+  return n;
+}
+function D(r, n, e = 0) {
+  return s(n, { style: "percent", maximumFractionDigits: e }).format(r / 100);
+}
+export {
+  N as asUtcDate,
+  F as collator,
+  y as dateFormat,
+  D as formatPercent,
+  d as listFormat,
+  b as localeDigits,
+  s as numberFormat,
+  p as numberSeparators,
+  w as parseLocalizedNumber,
+  $ as pluralRules
+};
+//# sourceMappingURL=intl-cache.js.map

package/dist/lib/intl-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intl-cache.js","sources":["../../src/lib/intl-cache.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   DX-4740 — ONE Intl FORMATTER PER (LOCALE, OPTIONS), AND THE LOCALE FACTS THE\n   PARSERS NEED.\n\n   Constructing an `Intl.*Format` costs tens of microseconds and a data grid\n   formats thousands of cells, so formatters are cached. The cache key carries the\n   locale: a formatter built for one language is never handed to another.\n\n   NOTHING HERE MAY IMPORT REACT — `@50arms/ui/pure` reaches this file.\n   -------------------------------------------------------------------------- */\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateFormats = new Map<string, Intl.DateTimeFormat>();\nconst listFormats = new Map<string, Intl.ListFormat>();\nconst collators = new Map<string, Intl.Collator>();\nconst pluralRulesCache = new Map<string, Intl.PluralRules>();\n\nexport function numberFormat(locale: string, options: Intl.NumberFormatOptions): Intl.NumberFormat {\n  const key = `${locale}|${JSON.stringify(options)}`;\n  let f = numberFormats.get(key);\n  if (!f) {\n    f = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, f);\n  }\n  return f;\n}\n\nexport function dateFormat(locale: string, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat {\n  const key = `${locale}|${JSON.stringify(options)}`;\n  let f = dateFormats.get(key);\n  if (!f) {\n    f = new Intl.DateTimeFormat(locale, options);\n    dateFormats.set(key, f);\n  }\n  return f;\n}\n\nexport function listFormat(locale: string, options: Intl.ListFormatOptions = {}): Intl.ListFormat {\n  const key = `${locale}|${JSON.stringify(options)}`;\n  let f = listFormats.get(key);\n  if (!f) {\n    f = new Intl.ListFormat(locale, options);\n    listFormats.set(key, f);\n  }\n  return f;\n}\n\n/** A cached `Intl.Collator`: sort names the way `locale` orders them (DX-4740), never by code point. */\nexport function collator(locale: string, options: Intl.CollatorOptions = {}): Intl.Collator {\n  const key = `${locale}|${JSON.stringify(options)}`;\n  let c = collators.get(key);\n  if (!c) {\n    c = new Intl.Collator(locale, options);\n    collators.set(key, c);\n  }\n  return c;\n}\n\n/** A cached `Intl.PluralRules` (DX-4740): which plural category (`one`, `other`, ...) a count takes in `locale`. */\nexport function pluralRules(locale: string, options: Intl.PluralRulesOptions = {}): Intl.PluralRules {\n  const key = `${locale}|${JSON.stringify(options)}`;\n  let r = pluralRulesCache.get(key);\n  if (!r) {\n    r = new Intl.PluralRules(locale, options);\n    pluralRulesCache.set(key, r);\n  }\n  return r;\n}\n\n/** The locale's digit-group and decimal separators (\",\" and \".\" in en-US, \".\" and \",\" in es-AR). */\nexport function numberSeparators(locale: string): { group: string; decimal: string } {\n  const parts = numberFormat(locale, { useGrouping: true, minimumFractionDigits: 1 }).formatToParts(-1234567.5);\n  return {\n    group: parts.find((p) => p.type === \"group\")!.value,\n    decimal: parts.find((p) => p.type === \"decimal\")!.value,\n  };\n}\n\n/**\n * Text a person typed in `locale`'s number convention → a finite `number`, or `null`.\n * `strip` removes locale-specific decoration first (a currency symbol). Group\n * separators are dropped and the decimal separator becomes \".\", then the result\n * must be a plain signed decimal — `\"12abc\"` is a typo, not twelve.\n */\nexport function parseLocalizedNumber(text: string, locale: string, strip: readonly string[] = []): number | null {\n  const { group, decimal } = numberSeparators(locale);\n  let body = text;\n  for (const s of strip) body = body.split(s).join(\"\");\n  /* A whitespace group (fr, ru: U+202F / U+00A0) is typed as a plain space just as often. */\n  if (/^\\s$/.test(group)) body = body.replace(/\\s/g, \"\");\n  else body = body.split(group).join(\"\");\n  body = body.split(decimal).join(\".\");\n  if (!/^-?\\d+(\\.\\d+)?$/.test(body)) return null;\n  const value = Number(body);\n  return Number.isFinite(value) ? value : null;\n}\n\n/**\n * Create a Date from year/month/day values, treating them as UTC (not local time).\n * Used by date formatting and parsing to work in UTC consistently.\n */\nexport function asUtcDate(year: number, month: number, day: number): Date {\n  const d = new Date(0);\n  d.setUTCFullYear(year, month - 1, day);\n  return d;\n}\n\n/**\n * The locale's digit set as an array [0, 1, 2, ..., 9], for normalizing user input\n * or parsing output of locale-specific formatters.\n */\nexport function localeDigits(locale: string): string[] {\n  const digits: string[] = [];\n  for (let i = 0; i < 10; i++) {\n    const s = numberFormat(locale, {}).format(i);\n    digits.push(s);\n  }\n  return digits;\n}\n\n/** A percentage as the locale writes it. `percent` is on the 0-100 scale; it is rounded to `digits` decimals. */\nexport function formatPercent(percent: number, locale: string, digits = 0): string {\n  return numberFormat(locale, { style: \"percent\", maximumFractionDigits: digits }).format(percent / 100);\n}\n"],"names":["numberFormats","dateFormats","listFormats","collators","pluralRulesCache","numberFormat","locale","options","key","f","dateFormat","listFormat","collator","c","pluralRules","r","numberSeparators","parts","p","parseLocalizedNumber","text","strip","group","decimal","body","s","value","asUtcDate","year","month","day","d","localeDigits","digits","i","formatPercent","percent"],"mappings":"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"}

package/dist/lib/legal-document.js

@@ -0,0 +1,37 @@
+function l(e) {
+  return `section-${e.replace(/\./g, "-")}`;
+}
+function i(e) {
+  const n = [];
+  let t = 0;
+  for (const r of e.matchAll(/\[[^\]]+\]/g))
+    r.index > t && n.push({ text: e.slice(t, r.index), unconfirmed: !1 }), n.push({ text: r[0], unconfirmed: !0 }), t = r.index + r[0].length;
+  return t < e.length && n.push({ text: e.slice(t), unconfirmed: !1 }), n;
+}
+function c(e) {
+  return [
+    e.effectiveDate,
+    e.version,
+    ...e.sections.flatMap(
+      (n) => n.blocks.flatMap((t) => t.kind === "list" ? t.items : [t.text])
+    )
+  ];
+}
+function o(e) {
+  return c(e).reduce(
+    (n, t) => n + i(t).filter((r) => r.unconfirmed).length,
+    0
+  );
+}
+const s = 40;
+function f(e) {
+  const n = e.replace(/[^A-Za-z]/g, "");
+  return n.length >= s && n === n.toUpperCase();
+}
+export {
+  o as countUnconfirmed,
+  f as isAllCaps,
+  l as legalSectionAnchor,
+  i as splitUnconfirmed
+};
+//# sourceMappingURL=legal-document.js.map

package/dist/lib/legal-document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legal-document.js","sources":["../../src/lib/legal-document.ts"],"sourcesContent":["/**\n * A legal document as DATA, plus the four pure decisions the `LegalDocument`\n * component makes about it. DX-4022.\n *\n * No React in this file on purpose: the `LegalDocumentValue` shape is what a\n * server holds and serves, so the `./pure` entry re-exports the types and a\n * back end can type its content module without importing the design system's\n * component graph.\n *\n * The shape mirrors a legal text and adds nothing to it: a title block,\n * numbered sections, and in each section the paragraphs and bullet lists in\n * document order. A paragraph that opens a numbered clause (\"4.2 Beta\n * confidentiality. ...\") carries that opening as `clause`, split off only so\n * a renderer can set it as a run-in heading and give it an anchor;\n * `${number} ${heading} ${text}` is the paragraph as written. Nothing in the\n * component writes a word of the document, which is what lets a verbatim check\n * compare the page against its source and expect an exact match.\n */\n\nexport interface LegalDocumentValue {\n  /** The document's own title line, e.g. \"TERMS OF USE\". */\n  title: string;\n  /** The company line under the title. */\n  issuer: string;\n  /** As written in the document, so it may still be an unfilled `[DATE]`. */\n  effectiveDate: string;\n  /** Which version of the text this is, as an acceptance would record it. */\n  version: string;\n  sections: readonly LegalSection[];\n}\n\nexport interface LegalSection {\n  /** \"1\", \"2\", ... the number the document gives the section, and what \"Section N\" cites. */\n  number: string;\n  title: string;\n  blocks: readonly LegalBlock[];\n}\n\nexport type LegalBlock =\n  | {\n      kind: \"paragraph\";\n      /** A numbered clause's opening words, when the paragraph starts one. */\n      clause?: { number: string; heading: string };\n      text: string;\n    }\n  | { kind: \"list\"; items: readonly string[] };\n\n/**\n * The fragment a section or clause is linked by: \"7\" is `section-7`, \"7.2\" is\n * `section-7-2`.\n *\n * Keyed on the NUMBER, never the title: \"Section 7\" is how a document cites\n * itself (and how a lawyer cites it in an email), so a link survives a heading\n * being reworded in a later version.\n */\nexport function legalSectionAnchor(number: string): string {\n  return `section-${number.replace(/\\./g, \"-\")}`;\n}\n\n/** One run of a paragraph: plain text, or a value the document left unfilled. */\nexport interface LegalTextRun {\n  text: string;\n  unconfirmed: boolean;\n}\n\n/**\n * Split text into plain runs and square-bracketed placeholder runs.\n *\n * A draft marks every value it has not settled (a date, a notice period, a\n * dollar cap) by writing it in square brackets. Those spans are kept verbatim,\n * brackets included; this only finds them so they can be SHOWN as unconfirmed\n * rather than read as agreed terms. Concatenating the runs' text always gives\n * back the input unchanged.\n */\nexport function splitUnconfirmed(text: string): LegalTextRun[] {\n  const runs: LegalTextRun[] = [];\n  let cursor = 0;\n  for (const match of text.matchAll(/\\[[^\\]]+\\]/g)) {\n    if (match.index > cursor) runs.push({ text: text.slice(cursor, match.index), unconfirmed: false });\n    runs.push({ text: match[0], unconfirmed: true });\n    cursor = match.index + match[0].length;\n  }\n  if (cursor < text.length) runs.push({ text: text.slice(cursor), unconfirmed: false });\n  return runs;\n}\n\n/** Every string the renderer sets through its placeholder-flagging text (the header values and the body), in reading order. */\nfunction allText(document: LegalDocumentValue): string[] {\n  return [\n    document.effectiveDate,\n    document.version,\n    ...document.sections.flatMap((section) =>\n      section.blocks.flatMap((block) => (block.kind === \"list\" ? block.items : [block.text])),\n    ),\n  ];\n}\n\n/** How many placeholder values a document still carries. */\nexport function countUnconfirmed(document: LegalDocumentValue): number {\n  return allText(document).reduce(\n    (total, text) => total + splitUnconfirmed(text).filter((run) => run.unconfirmed).length,\n    0,\n  );\n}\n\n/** Fewer letters than this is a heading or a name, not a paragraph set in capitals. */\nconst MIN_CAPS_LETTERS = 40;\n\n/**\n * Whether a run of text is written in capitals throughout.\n *\n * Disclaimers and liability limits are set in capitals on purpose (that is what\n * makes them conspicuous in the legal sense), so the renderer keeps every\n * letter as written and makes the block easier to read instead: a rule beside\n * it, looser tracking. A short all-caps fragment is not a paragraph of it.\n */\nexport function isAllCaps(text: string): boolean {\n  const letters = text.replace(/[^A-Za-z]/g, \"\");\n  return letters.length >= MIN_CAPS_LETTERS && letters === letters.toUpperCase();\n}\n"],"names":["legalSectionAnchor","number","splitUnconfirmed","text","runs","cursor","match","allText","document","section","block","countUnconfirmed","total","run","MIN_CAPS_LETTERS","isAllCaps","letters"],"mappings":"AAuDO,SAASA,EAAmBC,GAAwB;AACzD,SAAO,WAAWA,EAAO,QAAQ,OAAO,GAAG,CAAC;AAC9C;AAiBO,SAASC,EAAiBC,GAA8B;AAC7D,QAAMC,IAAuB,CAAA;AAC7B,MAAIC,IAAS;AACb,aAAWC,KAASH,EAAK,SAAS,aAAa;AAC7C,IAAIG,EAAM,QAAQD,KAAQD,EAAK,KAAK,EAAE,MAAMD,EAAK,MAAME,GAAQC,EAAM,KAAK,GAAG,aAAa,IAAO,GACjGF,EAAK,KAAK,EAAE,MAAME,EAAM,CAAC,GAAG,aAAa,IAAM,GAC/CD,IAASC,EAAM,QAAQA,EAAM,CAAC,EAAE;AAElC,SAAID,IAASF,EAAK,UAAQC,EAAK,KAAK,EAAE,MAAMD,EAAK,MAAME,CAAM,GAAG,aAAa,IAAO,GAC7ED;AACT;AAGA,SAASG,EAAQC,GAAwC;AACvD,SAAO;AAAA,IACLA,EAAS;AAAA,IACTA,EAAS;AAAA,IACT,GAAGA,EAAS,SAAS;AAAA,MAAQ,CAACC,MAC5BA,EAAQ,OAAO,QAAQ,CAACC,MAAWA,EAAM,SAAS,SAASA,EAAM,QAAQ,CAACA,EAAM,IAAI,CAAE;AAAA,IAAA;AAAA,EACxF;AAEJ;AAGO,SAASC,EAAiBH,GAAsC;AACrE,SAAOD,EAAQC,CAAQ,EAAE;AAAA,IACvB,CAACI,GAAOT,MAASS,IAAQV,EAAiBC,CAAI,EAAE,OAAO,CAACU,MAAQA,EAAI,WAAW,EAAE;AAAA,IACjF;AAAA,EAAA;AAEJ;AAGA,MAAMC,IAAmB;AAUlB,SAASC,EAAUZ,GAAuB;AAC/C,QAAMa,IAAUb,EAAK,QAAQ,cAAc,EAAE;AAC7C,SAAOa,EAAQ,UAAUF,KAAoBE,MAAYA,EAAQ,YAAA;AACnE;"}

package/dist/lib/line-diff-model.js

@@ -0,0 +1,51 @@
+const r = 2, f = 8, m = (t) => t.length === 0 ? [] : t.split(`
+`);
+function w(t, n) {
+  const a = t.length, u = n.length, d = Array.from({ length: a + 1 }, () => new Array(u + 1).fill(0));
+  for (let i = a - 1; i >= 0; i--)
+    for (let p = u - 1; p >= 0; p--)
+      d[i][p] = t[i] === n[p] ? d[i + 1][p + 1] + 1 : Math.max(d[i + 1][p], d[i][p + 1]);
+  const o = [];
+  let e = 0, s = 0;
+  for (; e < a && s < u; )
+    t[e] === n[s] ? (o.push({ kind: "unchanged", text: t[e] }), e++, s++) : d[e + 1][s] >= d[e][s + 1] ? (o.push({ kind: "removed", text: t[e] }), e++) : (o.push({ kind: "added", text: n[s] }), s++);
+  for (; e < a; e++) o.push({ kind: "removed", text: t[e] });
+  for (; s < u; s++) o.push({ kind: "added", text: n[s] });
+  return o;
+}
+function E(t, n) {
+  const a = t.map(() => !1);
+  t.forEach((o, e) => {
+    if (o.kind !== "unchanged")
+      for (let s = Math.max(0, e - n); s <= Math.min(t.length - 1, e + n); s++) a[s] = !0;
+  });
+  const u = [];
+  let d = -1;
+  for (let o = 0; o <= t.length; o++) {
+    const e = o < t.length && !a[o];
+    e && d < 0 && (d = o), !e && d >= 0 && (u.push({ start: d, end: o, atStart: d === 0, atEnd: o === t.length }), d = -1);
+  }
+  return u;
+}
+const h = { down: 0, up: 0 }, c = (t) => t.end - t.start;
+function l(t, n = h) {
+  const a = c(t), u = t.atStart && !t.atEnd ? 0 : Math.min(n.down, a), d = t.atEnd ? 0 : Math.min(n.up, a - u);
+  return { top: u, bottom: d, hidden: a - u - d };
+}
+function g(t, n, a, u = 8) {
+  const { hidden: d } = l(t, n);
+  if (a === "all") return t.atStart && !t.atEnd ? { down: n.down, up: n.up + d } : { down: n.down + d, up: n.up };
+  const o = Math.min(u, d);
+  return a === "down" ? { down: n.down + o, up: n.up } : { down: n.down, up: n.up + o };
+}
+export {
+  r as DEFAULT_CONTEXT,
+  f as EXPAND_STEP,
+  h as NOTHING,
+  w as diffLines,
+  g as expand,
+  E as foldGaps,
+  l as gapState,
+  m as splitLines
+};
+//# sourceMappingURL=line-diff-model.js.map

package/dist/lib/line-diff-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-diff-model.js","sources":["../../src/lib/line-diff-model.ts"],"sourcesContent":["// DXUI-38: the pure logic of LineDiff's expandable mode, ported from the approved DX-6188 review design. A diff of two texts' lines keeps its line\n// numbers, folds each unchanged run further than `context` lines from every change into a gap, and tracks how much of a gap a person has opened\n// (downward from the change above, upward from the change below, or whole). No React: LineDiff draws what this decides.\n\nexport type DiffKind = \"unchanged\" | \"added\" | \"removed\";\n\nexport interface DiffLine {\n  kind: DiffKind;\n  text: string;\n}\n\n/** Unchanged lines shown either side of a change when the caller names none. */\nexport const DEFAULT_CONTEXT = 2;\n/** Lines one press of an expand-up / expand-down control reveals. */\nexport const EXPAND_STEP = 8;\n\n/** `\"\".split(\"\\n\")` is `[\"\"]`: an empty string has no lines at all. */\nexport const splitLines = (text: string): string[] => (text.length === 0 ? [] : text.split(\"\\n\"));\n\n/** The line diff of `after` against `before` (LCS): a line in both once, one only in `before` removed, one only in `after` added; an edited line is its removal then its addition. */\nexport function diffLines(before: string[], after: string[]): DiffLine[] {\n  const n = before.length;\n  const m = after.length;\n  const dp: number[][] = Array.from({ length: n + 1 }, () => new Array<number>(m + 1).fill(0));\n  for (let i = n - 1; i >= 0; i--) {\n    for (let j = m - 1; j >= 0; j--) {\n      dp[i]![j] = before[i] === after[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);\n    }\n  }\n  const result: DiffLine[] = [];\n  let i = 0;\n  let j = 0;\n  while (i < n && j < m) {\n    if (before[i] === after[j]) {\n      result.push({ kind: \"unchanged\", text: before[i]! });\n      i++;\n      j++;\n    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {\n      result.push({ kind: \"removed\", text: before[i]! });\n      i++;\n    } else {\n      result.push({ kind: \"added\", text: after[j]! });\n      j++;\n    }\n  }\n  for (; i < n; i++) result.push({ kind: \"removed\", text: before[i]! });\n  for (; j < m; j++) result.push({ kind: \"added\", text: after[j]! });\n  return result;\n}\n\n/** A folded run of unchanged lines: rows `[start, end)` of the diff. */\nexport interface Gap {\n  start: number;\n  end: number;\n  /** No change above it: only the lines just above the change below can be revealed. */\n  atStart: boolean;\n  /** No change below it: only the lines just below the change above can be revealed. */\n  atEnd: boolean;\n}\n\n/** The unchanged runs further than `context` lines from every change. A diff with no change at all is one gap. */\nexport function foldGaps(lines: readonly DiffLine[], context: number): Gap[] {\n  const near = lines.map(() => false);\n  lines.forEach((line, i) => {\n    if (line.kind === \"unchanged\") return;\n    for (let k = Math.max(0, i - context); k <= Math.min(lines.length - 1, i + context); k++) near[k] = true;\n  });\n  const gaps: Gap[] = [];\n  let start = -1;\n  for (let i = 0; i <= lines.length; i++) {\n    const hidden = i < lines.length && !near[i];\n    if (hidden && start < 0) start = i;\n    if (!hidden && start >= 0) {\n      gaps.push({ start, end: i, atStart: start === 0, atEnd: i === lines.length });\n      start = -1;\n    }\n  }\n  return gaps;\n}\n\n/** What a person has opened of one gap: lines revealed just below the change above (`down`) and just above the change below (`up`). */\nexport interface Reveal {\n  down: number;\n  up: number;\n}\nexport const NOTHING: Reveal = { down: 0, up: 0 };\n\nconst gapSize = (g: Gap): number => g.end - g.start;\n\n/** How the gap reads now: rows revealed under the change above, rows revealed over the change below, and how many stay folded between them. */\nexport function gapState(g: Gap, r: Reveal = NOTHING): { top: number; bottom: number; hidden: number } {\n  const size = gapSize(g);\n  // A gap touching both edges (no change at all) opens from the top.\n  const top = g.atStart && !g.atEnd ? 0 : Math.min(r.down, size);\n  const bottom = g.atEnd ? 0 : Math.min(r.up, size - top);\n  return { top, bottom, hidden: size - top - bottom };\n}\n\nexport type Expand = \"down\" | \"up\" | \"all\";\n\n/** The reveal after one press. \"down\" and \"up\" open `step` more lines (never past the gap); \"all\" opens the rest. */\nexport function expand(g: Gap, r: Reveal, how: Expand, step: number = EXPAND_STEP): Reveal {\n  const { hidden } = gapState(g, r);\n  // The rest opens toward the change the gap sits next to; a gap above the first change has nothing above it to open from (gapState ignores `down` there), so it opens upward.\n  if (how === \"all\") return g.atStart && !g.atEnd ? { down: r.down, up: r.up + hidden } : { down: r.down + hidden, up: r.up };\n  const by = Math.min(step, hidden);\n  return how === \"down\" ? { down: r.down + by, up: r.up } : { down: r.down, up: r.up + by };\n}\n"],"names":["DEFAULT_CONTEXT","EXPAND_STEP","splitLines","text","diffLines","before","after","n","m","dp","i","j","result","foldGaps","lines","context","near","line","k","gaps","start","hidden","NOTHING","gapSize","g","gapState","r","size","top","bottom","expand","how","step","by"],"mappings":"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"}

package/dist/lib/markdown/attachments.js

@@ -0,0 +1,71 @@
+import { escapeReferenceName as g, referenceLabel as u } from "./images.js";
+import { project as l } from "./project.js";
+function o(e) {
+  const n = [];
+  for (const t of e.frames) {
+    const r = t.frame;
+    r.kind === "image" ? n.push({ record: t, url: r.src, image: !0 }) : r.kind === "link" && n.push({ record: t, url: r.href, image: !1 });
+  }
+  return n.sort((t, r) => t.record.start - r.record.start);
+}
+function p(e, n, t) {
+  return e === "image" ? n.trim() !== "" : t.isFileUrl(n);
+}
+function f(e, n) {
+  return e.source.includes("[") ? o(e).filter((t) => p(t.image ? "image" : "link", t.url, n)) : [];
+}
+function w(e, n) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of f(e, n))
+    t.has(r.url) || t.set(r.url, { url: r.url, name: u(e.source, r.record.content), image: r.image });
+  return [...t.values()];
+}
+const x = /(?:^|\s)(\d+)$/;
+function N(e, n) {
+  let t = 0;
+  for (const r of f(l(e), n)) {
+    const s = x.exec(u(e, r.record.content));
+    s && (t = Math.max(t, Number(s[1])));
+  }
+  return t + 1;
+}
+function m(e, n) {
+  return e.includes("[") ? o(l(e)).filter((t) => t.url === n) : [];
+}
+function d(e) {
+  return e.filter((n) => !e.some((t) => t !== n && t.start <= n.start && n.end <= t.end && (t.start < n.start || n.end < t.end)));
+}
+function h(e, n) {
+  let t = e;
+  for (const r of [...n].sort((s, c) => c.start - s.start)) t = t.slice(0, r.start) + r.text + t.slice(r.end);
+  return t;
+}
+function A(e, n, t) {
+  const r = g(t), s = m(e, n).map(({ record: c }) => {
+    const i = c.content[0] ?? { start: c.start + (c.frame.kind === "image" ? 2 : 1), end: c.start + (c.frame.kind === "image" ? 2 : 1) };
+    return { start: i.start, end: i.end, text: r };
+  });
+  return h(e, d(s));
+}
+function M(e, n) {
+  const t = d(m(e, n).map(({ record: i }) => ({ start: i.start, end: i.end }))), r = /* @__PURE__ */ new Set(), s = (i) => e[i] === " " && !r.has(i) && !t.some((a) => i >= a.start && i < a.end), c = t.map(({ start: i, end: a }) => (s(i - 1) ? (r.add(i - 1), i--) : s(a) && (r.add(a), a++), { start: i, end: a, text: "" }));
+  return h(e, c);
+}
+function v(e, n) {
+  if (e === n) return null;
+  let t = 0;
+  const r = Math.min(e.length, n.length);
+  for (; t < r && e[t] === n[t]; ) t++;
+  let s = 0;
+  for (; s < r - t && e[e.length - 1 - s] === n[n.length - 1 - s]; ) s++;
+  return { start: t, end: e.length - s, text: n.slice(t, n.length - s) };
+}
+export {
+  w as attachmentsOf,
+  v as coveringSplice,
+  p as isAttachmentReference,
+  N as nextReferenceNumber,
+  M as removeAttachment,
+  A as renameAttachment
+};
+//# sourceMappingURL=attachments.js.map

package/dist/lib/markdown/attachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.js","sources":["../../../src/lib/markdown/attachments.ts"],"sourcesContent":["/* ============================================================================\n   ATTACHMENTS - the pure half of \"a file in a markdown document is a named\n   reference in the text and a tile under it\".\n\n   DXUI-74. The text is the only record. A file the editor stores is written as\n   `![Image 1](url)` (a picture) or `[PDF 2](url)` (anything else), the\n   bracket text is the reference name, and the URL is the file's identity: no\n   attachment table, no id. The strip under the editor is computed from the\n   text on every change (`attachmentsOf`), so deleting a reference removes its\n   tile and an undo brings it back with nothing to keep in step.\n\n   Everything here is a function of strings, like ./images.ts: no DOM, no React.\n   ========================================================================= */\n\nimport { escapeReferenceName, referenceLabel } from \"./images\";\nimport { project, type Projection } from \"./project\";\nimport type { FrameRecord } from \"../syntax/markdown/frames\";\n\n/** One file the document references: a tile in the strip. */\nexport interface AttachmentRow {\n  /** The file's identity: the destination exactly as the parser reads it. */\n  url: string;\n  /** The reference name of its first reference in the text. */\n  name: string;\n  /** Whether the first reference is an image construct. */\n  image: boolean;\n}\n\nexport interface AttachmentOptions {\n  /** Whether a LINK's destination is a file the app stores. An image construct always counts; a typed link only through this. */\n  isFileUrl: (url: string) => boolean;\n}\n\n/** A link or image construct and where it points. */\ninterface Reference {\n  record: FrameRecord;\n  url: string;\n  image: boolean;\n}\n\nfunction referencesOf(projection: Projection): Reference[] {\n  const found: Reference[] = [];\n  for (const record of projection.frames) {\n    const frame = record.frame;\n    if (frame.kind === \"image\") found.push({ record, url: frame.src, image: true });\n    else if (frame.kind === \"link\") found.push({ record, url: frame.href, image: false });\n  }\n  return found.sort((a, b) => a.record.start - b.record.start);\n}\n\n/**\n * Whether a construct is an attachment reference: an image with a destination, or a link `isFileUrl` accepts. The ONE\n * definition: the strip, the numbering and the construct bar (which never opens over a reference) all use it.\n */\nexport function isAttachmentReference(kind: \"image\" | \"link\", url: string, options: AttachmentOptions): boolean {\n  /* An image construct always counts, except one with no destination at all: `![]()` names no file. */\n  return kind === \"image\" ? url.trim() !== \"\" : options.isFileUrl(url);\n}\n\n/** The attachment references of a parsed document: every image, and every link `isFileUrl` accepts. */\nfunction attachmentReferences(projection: Projection, options: AttachmentOptions): Reference[] {\n  /* The overwhelmingly common document holds no bracket at all, and this runs on every edit. */\n  if (!projection.source.includes(\"[\")) return [];\n  return referencesOf(projection).filter((ref) => isAttachmentReference(ref.image ? \"image\" : \"link\", ref.url, options));\n}\n\n/**\n * One row per distinct URL the text references as a file, in the order it first appears. It reads the parse the\n * editor's surface already holds, so a keystroke never parses the text a second time.\n */\nexport function attachmentsOf(projection: Projection, options: AttachmentOptions): AttachmentRow[] {\n  const rows = new Map<string, AttachmentRow>();\n  for (const ref of attachmentReferences(projection, options)) {\n    if (rows.has(ref.url)) continue;\n    rows.set(ref.url, { url: ref.url, name: referenceLabel(projection.source, ref.record.content), image: ref.image });\n  }\n  return [...rows.values()];\n}\n\n/** A trailing number in a reference name: the \"2\" of \"PDF 2\". */\nconst TRAILING_NUMBER = /(?:^|\\s)(\\d+)$/;\n\n/**\n * The number the next file referenced takes: one more than the highest number any ATTACHMENT in the text already\n * ends in, whatever its kind. Numbers are never renumbered when a file is removed, because the person may have\n * written \"see Image 2\" in the text; a renamed reference that no longer ends in a number takes no part, and a typed\n * ordinary link (\"[RFC 2119](...)\") never does.\n */\nexport function nextReferenceNumber(source: string, options: AttachmentOptions): number {\n  let highest = 0;\n  for (const ref of attachmentReferences(project(source), options)) {\n    const match = TRAILING_NUMBER.exec(referenceLabel(source, ref.record.content));\n    if (match) highest = Math.max(highest, Number(match[1]));\n  }\n  return highest + 1;\n}\n\n/** The name for the next file referenced: `kindWord` and `nextReferenceNumber`. */\nexport function nextReferenceName(source: string, kindWord: string, options: AttachmentOptions): string {\n  return `${kindWord} ${nextReferenceNumber(source, options)}`;\n}\n\n/** Every construct that points at `url`, in source order. */\nfunction constructsOf(source: string, url: string): Reference[] {\n  if (!source.includes(\"[\")) return [];\n  return referencesOf(project(source)).filter((ref) => ref.url === url);\n}\n\n/** The ranges no other range of the list contains: a construct nested in another that is edited too goes with it. */\nfunction outermost<T extends { start: number; end: number }>(ranges: T[]): T[] {\n  return ranges.filter((r) => !ranges.some((o) => o !== r && o.start <= r.start && r.end <= o.end && (o.start < r.start || r.end < o.end)));\n}\n\n/** Replaces the given source ranges (non-overlapping), last first so offsets hold. */\nfunction splice(source: string, edits: Array<{ start: number; end: number; text: string }>): string {\n  let out = source;\n  for (const edit of [...edits].sort((a, b) => b.start - a.start)) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);\n  return out;\n}\n\n/** Rewrites the bracket text of EVERY construct that points at `url`; the destination and everything else stay byte for byte. */\nexport function renameAttachment(source: string, url: string, name: string): string {\n  const text = escapeReferenceName(name);\n  /* A construct inside another one's label (`![a [b](u) c](u)`) is rewritten with it: two edits over one range would corrupt the text. */\n  const edits = constructsOf(source, url).map(({ record }) => {\n    /* An EMPTY label (`![](url)`) declares no range: the name goes right after the opening bracket. */\n    const label = record.content[0] ?? { start: record.start + (record.frame.kind === \"image\" ? 2 : 1), end: record.start + (record.frame.kind === \"image\" ? 2 : 1) };\n    return { start: label.start, end: label.end, text };\n  });\n  return splice(source, outermost(edits));\n}\n\n/**\n * Deletes EVERY construct that points at `url`, and one separating space beside each (the one before it, else\n * the one after), so `a ![x](u) b` becomes `a b`. A space two constructs share is taken once, so two references\n * side by side never reach into the text after them.\n */\nexport function removeAttachment(source: string, url: string): string {\n  /* A construct inside another that is also deleted goes with it. */\n  const ranges = outermost(constructsOf(source, url).map(({ record }) => ({ start: record.start, end: record.end })));\n  const taken = new Set<number>();\n  const free = (at: number) => source[at] === \" \" && !taken.has(at) && !ranges.some((r) => at >= r.start && at < r.end);\n  const edits = ranges.map(({ start, end }) => {\n    if (free(start - 1)) {\n      taken.add(start - 1);\n      start--;\n    } else if (free(end)) {\n      taken.add(end);\n      end++;\n    }\n    return { start, end, text: \"\" };\n  });\n  return splice(source, edits);\n}\n\n/**\n * The one splice that turns `before` into `after`: the span between their common prefix and common suffix.\n * Several constructs changing at once (a rename, a remove) is still ONE edit, and so one undo step.\n */\nexport function coveringSplice(before: string, after: string): { start: number; end: number; text: string } | null {\n  if (before === after) return null;\n  let start = 0;\n  const shortest = Math.min(before.length, after.length);\n  while (start < shortest && before[start] === after[start]) start++;\n  let tail = 0;\n  while (tail < shortest - start && before[before.length - 1 - tail] === after[after.length - 1 - tail]) tail++;\n  return { start, end: before.length - tail, text: after.slice(start, after.length - tail) };\n}\n"],"names":["referencesOf","projection","found","record","frame","a","b","isAttachmentReference","kind","url","options","attachmentReferences","ref","attachmentsOf","rows","referenceLabel","TRAILING_NUMBER","nextReferenceNumber","source","highest","project","match","constructsOf","outermost","ranges","r","o","splice","edits","out","edit","renameAttachment","name","text","escapeReferenceName","label","removeAttachment","taken","free","at","start","end","coveringSplice","before","after","shortest","tail"],"mappings":"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"}

package/dist/lib/markdown/caret-map.js

@@ -0,0 +1,153 @@
+const y = /* @__PURE__ */ new Set([
+  "inline",
+  "emphasis",
+  "strong",
+  "strike",
+  "codeSpan",
+  "link",
+  "image",
+  "autolink",
+  "footnoteRef",
+  "hardBreak"
+]), C = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function M(o, s = []) {
+  for (const r of o)
+    r.type === "text" ? s.push(r) : M(r.children, s);
+  return s;
+}
+function L(o) {
+  const { source: s } = o, r = M(o.children), l = new Uint8Array(s.length);
+  for (const t of r)
+    if (t.syntax)
+      for (let e = t.start; e < t.end; e++) l[e] = 1;
+  const c = [], f = /* @__PURE__ */ new Set([0, s.length]);
+  for (const t of r) {
+    if (t.syntax) {
+      f.add(t.start), f.add(t.end);
+      continue;
+    }
+    f.add(t.start);
+    for (const e of C.segment(t.text)) {
+      const n = t.start + e.index, a = n + e.segment.length;
+      c.push({ start: n, end: a }), f.add(a);
+    }
+  }
+  c.sort((t, e) => t.start - e.start);
+  const b = o.frames.map((t) => ({
+    start: t.start,
+    end: t.end,
+    inline: y.has(t.frame.kind)
+  })), k = (t) => {
+    let e = 0;
+    for (const n of b) n.inline && n.start < t && t < n.end && e++;
+    return e;
+  }, v = (t, e) => {
+    let n = null;
+    for (const a of b)
+      a.start > t || e > a.end || (!n || a.end - a.start <= n.end - n.start) && (n = a);
+    return n;
+  }, A = (t) => t === 0 || s[t - 1] === `
+`, D = o.frames.filter((t) => t.frame.kind === "tableCell" || t.frame.kind === "tableGutter" || t.frame.kind === "tableDelimiter").map((t) => ({ start: t.start, end: t.end, cell: t.frame.kind === "tableCell" })), I = o.frames.filter((t) => y.has(t.frame.kind) && t.content.length === 0 && t.end > t.start).map((t) => ({ start: t.start, end: t.end })), N = (t, e) => I.some((n) => t <= n.start && n.end <= e && e > t), p = (t) => {
+    let e = null;
+    for (const n of D)
+      t < n.start || t > n.end || (!e || n.cell && !e.cell || n.cell === e.cell && n.end - n.start < e.end - e.start) && (e = n);
+    return e;
+  }, B = [...f].sort((t, e) => t - e), u = [], d = new Array(s.length + 1).fill(-1);
+  let i = [];
+  const S = () => {
+    if (!i.length) return;
+    const t = i[0], e = i[i.length - 1], n = e, a = v(t, e);
+    let h;
+    if (a && a.inline) {
+      h = t;
+      let g = k(t);
+      for (const m of i) {
+        const x = k(m);
+        (x < g || x === g && m > h) && (h = m, g = x);
+      }
+    } else A(t) ? h = n : h = t;
+    const w = p(h);
+    if (w && !w.cell) {
+      i = [];
+      return;
+    }
+    u.push(h);
+    for (let g = t; g <= e; g++) d[g] = h;
+    i = [];
+  };
+  for (const t of B) {
+    if (i.length) {
+      const e = i[i.length - 1];
+      let n = !0;
+      for (let a = e; a < t; a++)
+        if (!l[a]) {
+          n = !1;
+          break;
+        }
+      (!n || p(e) !== p(t) || N(e, t)) && S();
+    }
+    i.push(t);
+  }
+  if (S(), u.length)
+    for (let t = 0; t <= s.length; t++) {
+      if (d[t] !== -1) continue;
+      let e = u[0];
+      for (const n of u) {
+        if (n > t) break;
+        e = n;
+      }
+      d[t] = e;
+    }
+  else
+    d.fill(0), u.push(0);
+  return d[s.length] !== s.length && (u.push(s.length), d[s.length] = s.length), { source: s, stops: u, graphemes: c, representative: d };
+}
+function E(o, s) {
+  const r = Math.max(0, Math.min(s, o.source.length));
+  return o.representative[r] ?? 0;
+}
+function O(o, s, r) {
+  const l = E(o, s), f = o.stops.indexOf(l) + r;
+  return f < 0 || f >= o.stops.length ? l : o.stops[f];
+}
+function G(o, s) {
+  let r = null;
+  for (const l of o.graphemes)
+    if (l.end <= s) r = l;
+    else break;
+  return r;
+}
+function K(o, s) {
+  for (const r of o.graphemes) if (r.start >= s) return r;
+  return null;
+}
+function R(o, s) {
+  const { source: r } = o;
+  let l = Math.max(0, Math.min(s, r.length));
+  for (; l > 0 && r[l - 1] !== `
+`; ) l--;
+  for (const c of o.stops) if (c >= l) return c;
+  return l;
+}
+function U(o, s) {
+  const { source: r } = o;
+  let l = Math.max(0, Math.min(s, r.length));
+  for (; l < r.length && r[l] !== `
+`; ) l++;
+  let c = 0;
+  for (const f of o.stops) {
+    if (f > l) break;
+    c = f;
+  }
+  return c;
+}
+export {
+  L as caretMap,
+  K as graphemeAfter,
+  G as graphemeBefore,
+  U as lineEndStop,
+  R as lineStartStop,
+  E as nearestStop,
+  O as stepStop
+};
+//# sourceMappingURL=caret-map.js.map

package/dist/lib/markdown/caret-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caret-map.js","sources":["../../../src/lib/markdown/caret-map.ts"],"sourcesContent":["/* ============================================================================\n   THE CARET MAP — which source offsets are places the caret can be, now that\n   markup is never shown.\n\n   WHY THIS MODULE EXISTS, AND WHAT IT REPLACES. The first caret contract said\n   \"EVERY SOURCE OFFSET IS A CARET POSITION\", and reveal-on-active-line existed\n   to make that true: a caret cannot be placed inside a zero-size box, so a\n   marker had to become visible for its offsets to have geometry. The operator's\n   requirement is the opposite one — the markdown is NEVER shown — so the\n   markers keep no geometry at any time, and offsets inside them stop being\n   places at all.\n\n   That is the trade the old contract deliberately refused, and it named the bug\n   class it was refusing: caret trapped in a widget, cannot delete across a\n   hidden run, hidden start/end not covered. CodeMirror needed a dedicated\n   `atomicRanges` facet for exactly this. So this module owes those cases an\n   answer rather than an argument:\n\n     trapped        Impossible by construction — `stops` never contains an\n                    offset strictly inside a syntax run, so the caret is never\n                    put in one and never has to escape.\n     delete across  Deletion does not work between stops, it works on the\n                    adjacent VISIBLE grapheme (`graphemeBefore`/`graphemeAfter`),\n                    so a marker between the caret and the character being\n                    deleted is simply not involved.\n     hidden edges   A syntax run's own start and end are both candidate stops,\n                    so a construct at the very start or very end of a document\n                    still has a caret position outside it.\n\n   ── THE BOUNDARY RULE, which is the only interesting decision here ──────────\n\n   Where a marker sits between two pieces of text, the offset before it and the\n   offset after it are the SAME PLACE on screen. One of them has to be chosen,\n   and the choice decides what typing there does.\n\n     `- item`     Before the marker (0) and after it (2) are both column zero.\n                  Choosing 2 means typing at the start of the line appends to\n                  the ITEM. Choosing 0 would insert before the `- ` and silently\n                  destroy the list.\n     `**bold**`   Before the opening `**` (0) and after it (2) are the same\n                  place. Choosing 0 means typing there is NOT bold, which is\n                  what every editor does at the left edge of a formatted run.\n                  The closing edge is the mirror: 8, not 6.\n\n   So the two cases want OPPOSITE answers, and what separates them is the kind\n   of frame the marker belongs to. A block frame's markup is a PREFIX declaring\n   what the line is — the caret belongs inside it. An inline frame's markup\n   DELIMITS a span — the caret belongs outside it.\n\n   The rule, therefore: prefer the candidate inside FEWER INLINE frames, and\n   break the tie by preferring the one inside more BLOCK frames.\n\n   THE ORDER OF THOSE TWO TESTS IS NOT ARBITRARY, and getting it backwards is\n   the first thing that happened. Asking about block frames first makes\n   `**bold**` choose the inner offset, because the PARAGRAPH containing the\n   whole line is itself a block frame and offset 2 is inside it while offset 0\n   merely touches its edge. The paragraph has nothing to do with this boundary.\n   Inline containment is the sharper question — it is only ever true of a\n   construct whose delimiter is the very markup being stepped over — so it\n   decides, and block depth is left to break the ties it cannot.\n   ========================================================================= */\n\nimport type { Frame } from \"../syntax/markdown/frames\";\nimport type { PNode, PText, Projection } from \"./project\";\n\n/** A half-open source range. */\nexport interface Span {\n  start: number;\n  end: number;\n}\n\nexport interface CaretMap {\n  source: string;\n  /** Every offset the caret may occupy, ascending and unique. */\n  stops: readonly number[];\n  /** The source range of every VISIBLE grapheme, in document order. */\n  graphemes: readonly Span[];\n  /**\n   * The stop that stands for each source offset, indexed by offset.\n   *\n   * NEEDED BECAUSE \"NEAREST\" IS THE WRONG QUESTION. Deleting the \"d\" from\n   * `**bold**` leaves the caret at offset 5, which is the same PLACE as offset\n   * 7 but two characters closer to 4 — so a nearest-by-distance snap puts the\n   * caret before the \"l\" instead of after the construct, and the next keystroke\n   * lands in the wrong word. An offset belongs to the coincident group it falls\n   * in, and only this table knows which that is.\n   */\n  representative: readonly number[];\n}\n\n/**\n * Frame kinds whose markup delimits a span inside a line, rather than declaring\n * what the line is.\n *\n * `inline` is on this list even though it is a container rather than a marker,\n * and that is not an oversight: its hull covers the whole run of prose\n * INCLUDING the markers inside it, so counting it as a block frame would make\n * every inline boundary prefer the inner offset and put the caret inside the\n * emphasis it was trying to stand outside of.\n */\nconst INLINE_KINDS = new Set<Frame[\"kind\"]>([\n  \"inline\",\n  \"emphasis\",\n  \"strong\",\n  \"strike\",\n  \"codeSpan\",\n  \"link\",\n  \"image\",\n  \"autolink\",\n  \"footnoteRef\",\n  \"hardBreak\",\n]);\n\nconst segmenter = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\n\nfunction flatten(nodes: readonly PNode[], out: PText[] = []): PText[] {\n  for (const node of nodes) {\n    if (node.type === \"text\") out.push(node);\n    else flatten(node.children, out);\n  }\n  return out;\n}\n\n/**\n * Builds the map for a projection.\n *\n * Pure, and rebuilt with every projection rather than maintained across edits —\n * the same reasoning the projection itself gives. Nothing is kept in step, so\n * nothing can drift.\n */\nexport function caretMap(projection: Projection): CaretMap {\n  const { source } = projection;\n  const runs = flatten(projection.children);\n\n  /* Which characters are markup. Every source character belongs to exactly one\n     run (the projection invariant), so this is total. */\n  const syntax = new Uint8Array(source.length);\n  for (const run of runs) {\n    if (!run.syntax) continue;\n    for (let at = run.start; at < run.end; at++) syntax[at] = 1;\n  }\n\n  /* Every visible grapheme, and every offset that bounds one. */\n  const graphemes: Span[] = [];\n  const candidates = new Set<number>([0, source.length]);\n  for (const run of runs) {\n    if (run.syntax) {\n      /* A marker's own edges are candidates so a construct at the very start or\n         end of the document still has a caret position outside it. */\n      candidates.add(run.start);\n      candidates.add(run.end);\n      continue;\n    }\n    candidates.add(run.start);\n    for (const piece of segmenter.segment(run.text)) {\n      const start = run.start + piece.index;\n      const end = start + piece.segment.length;\n      graphemes.push({ start, end });\n      candidates.add(end);\n    }\n  }\n  graphemes.sort((a, b) => a.start - b.start);\n\n  /* Frames, with the two questions the boundary rule asks of them. */\n  const frames = projection.frames.map((record) => ({\n    start: record.start,\n    end: record.end,\n    inline: INLINE_KINDS.has(record.frame.kind),\n  }));\n\n  /** How many inline constructs an offset is strictly inside. */\n  const inlineDepth = (at: number): number => {\n    let n = 0;\n    for (const frame of frames) if (frame.inline && frame.start < at && at < frame.end) n++;\n    return n;\n  };\n\n  /** The innermost frame wholly containing a span — the one that OWNS it. */\n  const owner = (lo: number, hi: number): { start: number; end: number; inline: boolean } | null => {\n    let best: { start: number; end: number; inline: boolean } | null = null;\n    for (const frame of frames) {\n      if (frame.start > lo || hi > frame.end) continue;\n      /* `<=`, not `<`, and that is the whole difference between this working\n         and not. A paragraph, its inline run and a `**strong**` filling it all\n         span exactly the same offsets, so \"smallest wins\" is a three-way tie\n         that keeps whichever the parser happened to emit first — the paragraph\n         — and the boundary is then judged as a block's. Frames arrive in\n         emission order and a child is always opened after its parent, so on a\n         tie the LAST one is the innermost. */\n      if (!best || frame.end - frame.start <= best.end - best.start) best = frame;\n    }\n    return best;\n  };\n\n  const atLineStart = (at: number): boolean => at === 0 || source[at - 1] === \"\\n\";\n\n  /* THE TABLE IS THE ONE PLACE WITH REAL BOXES, and that changes what\n     \"the same place on screen\" means.\n\n     Everywhere else every block frame is `display: inline`, so two offsets with\n     only zero-width markup between them are genuinely the same pixel. A table's\n     cells are laid-out boxes with borders and padding, so the end of cell A and\n     the start of cell B are separated by a border and two paddings — different\n     places, however wide the pipe between them renders. Merging them made the\n     start of every cell but the first unreachable, and Tab-to-next-cell\n     selected the pipe along with the text.\n\n     So a caret position belongs to exactly one box, groups never span two, and\n     a position whose only box is a gutter or the alignment row is dropped\n     outright: those cells are `width: 0`, and a caret in one has no geometry —\n     the very thing this whole model exists to avoid. */\n  const boxes = projection.frames\n    .filter((r) => r.frame.kind === \"tableCell\" || r.frame.kind === \"tableGutter\" || r.frame.kind === \"tableDelimiter\")\n    .map((r) => ({ start: r.start, end: r.end, cell: r.frame.kind === \"tableCell\" }));\n\n  /* AN ATOMIC CONSTRUCT HAS WIDTH, so its two sides are two places.\n     A footnote reference or a hard break declares no content of its own.\n     Every offset in it is therefore markup, and the merging rule collapsed the\n     whole thing to a single stop: there was nowhere to stand BEFORE one, so a\n     document beginning with one could never gain text in front of it. A group\n     may not swallow one. */\n  const atomics = projection.frames\n    .filter((r) => INLINE_KINDS.has(r.frame.kind) && r.content.length === 0 && r.end > r.start)\n    .map((r) => ({ start: r.start, end: r.end }));\n\n  const spansAtomic = (lo: number, hi: number): boolean =>\n    atomics.some((a) => lo <= a.start && a.end <= hi && hi > lo);\n\n  const boxOf = (at: number): { start: number; end: number; cell: boolean } | null => {\n    let best: { start: number; end: number; cell: boolean } | null = null;\n    for (const box of boxes) {\n      if (at < box.start || at > box.end) continue;\n      /* A cell wins over the gutter it touches: their edges coincide, and the\n         caret belongs with the text rather than with the pipe. */\n      if (!best || (box.cell && !best.cell) || (box.cell === best.cell && box.end - box.start < best.end - best.start)) {\n        best = box;\n      }\n    }\n    return best;\n  };\n\n  /* Candidates separated only by markup are one place on screen. Group them,\n     and keep the one the boundary rule picks. */\n  const sorted = [...candidates].sort((a, b) => a - b);\n  const stops: number[] = [];\n  const representative = new Array<number>(source.length + 1).fill(-1);\n  let group: number[] = [];\n\n  const flush = (): void => {\n    if (!group.length) return;\n    const lo = group[0];\n    const hi = group[group.length - 1];\n    const last = hi;\n    const holder = owner(lo, hi);\n\n    let best: number;\n    if (holder && holder.inline) {\n      /* INLINE: stand outside the construct. Measured by containment rather\n         than by picking an end, because a group can sit BETWEEN two constructs\n         — the `**__` in `**a**__b__` — where the right answer is neither end\n         but the offset between them, and that is the one inside fewest of\n         them. */\n      best = lo;\n      let bestDepth = inlineDepth(lo);\n      for (const at of group) {\n        const d = inlineDepth(at);\n        if (d < bestDepth || (d === bestDepth && at > best)) {\n          best = at;\n          bestDepth = d;\n        }\n      }\n    } else if (atLineStart(lo)) {\n      /* A BLOCK'S PREFIX: the markup declares what the line is, and the text it\n         introduces comes after it, so the caret belongs past it. This is what\n         makes typing at the start of `- item` append to the item instead of\n         destroying the list — and it holds for an EMPTY item too, where no\n         candidate is inside anything and counting containers cannot decide. */\n      best = last;\n    } else {\n      /* A BLOCK'S TRAILING MARKUP — a closing fence, say. Its content is on the\n         near side, so the caret stays with the content rather than stepping out\n         of the block it is in. This is also correct at the very end of the\n         document — SEE THE FORCED BREAK BELOW for why `hi` never actually\n         equals `source.length` here unless `lo` does too. */\n      best = lo;\n    }\n    /* A group whose only home is a zero-width gutter offers no place to stand. */\n    const box = boxOf(best);\n    if (box && !box.cell) {\n      group = [];\n      return;\n    }\n    stops.push(best);\n    for (let at = lo; at <= hi; at++) representative[at] = best;\n    group = [];\n  };\n\n  for (const at of sorted) {\n    if (group.length) {\n      const previous = group[group.length - 1];\n      let onlyMarkup = true;\n      for (let i = previous; i < at; i++) {\n        if (!syntax[i]) {\n          onlyMarkup = false;\n          break;\n        }\n      }\n      if (!onlyMarkup || boxOf(previous) !== boxOf(at) || spansAtomic(previous, at)) flush();\n    }\n    group.push(at);\n  }\n  flush();\n\n  /* Offsets no group covered are inside a run of content — either a stop\n     already, or partway through a multi-unit grapheme, where the enclosing\n     grapheme's own start is the honest answer. */\n  if (stops.length) {\n    for (let at = 0; at <= source.length; at++) {\n      if (representative[at] !== -1) continue;\n      let chosen = stops[0];\n      for (const stop of stops) {\n        if (stop > at) break;\n        chosen = stop;\n      }\n      representative[at] = chosen;\n    }\n  } else {\n    representative.fill(0);\n    stops.push(0);\n  }\n\n  /* SG-800 — THE DOCUMENT'S OWN END IS ALWAYS A STOP IN ITS OWN RIGHT, even\n     when the flush above put its group's caret on the NEAR side of a\n     trailing block marker instead.\n\n     \"A BLOCK'S TRAILING MARKUP\" above is right to stand there ON PURPOSE —\n     Tab indenting the last line of a fence body has to stay inside the\n     fence, not jump past its own closing fence, and an earlier version of\n     this fix that changed the branch's OWN choice (or forced the merge apart\n     at the loop above) broke exactly that case, and separately broke every\n     INLINE closing marker at a document's end too (`**bold**‸` stepping\n     Backspace across the `**` no longer landed outside it) — inline markers\n     already merge the near side and the far side into ONE reachable stop on\n     purpose, and forcing them apart made the near side reachable again,\n     which \"no marker ever has geometry\" exists to forbid.\n\n     So nothing about the merge or the branch changes. This only asks: after\n     all of that, is `source.length` — the actual end of the document — its\n     OWN place, the way \"hidden edges\" above already promises for the very\n     START of one (`candidates` seeds `0` unconditionally for the same\n     reason)? For a document that ends in visible content, or in an INLINE\n     marker's own close, it already is (the group covering the tail resolves\n     to itself). It stops being true only for a BLOCK's own trailing\n     markup — a closed ```fence```, a closing `## heading ##` — with nothing\n     after it: there the near-side choice above is correct for what already\n     existed, but it leaves the document's true end mapped to somewhere\n     inside the block, and an edit computed to land at that true end — Enter\n     on the last line, most plainly — silently lands inside the block\n     instead, one keystroke short of where the document could actually still\n     grow. A real Chromium probe confirmed the shape: pressing Enter after a\n     closed fence that ended the document spliced the new line INSIDE the\n     fence body, and the character typed next landed after the fence with no\n     separator — Enter looked like it did nothing.\n\n     Adding it here, once, after every other stop is already decided, is what\n     keeps this a genuine ADDITION rather than a second vote that could\n     re-open either regression above: every existing representative entry\n     (offset 13 in a fence, offset 6 before a closing `**`) is left exactly as\n     the rules above chose it, and only the one slot that was never anybody's\n     first choice — the offset equal to `source.length` itself — is filled in\n     if nothing already claimed it. */\n  if (representative[source.length] !== source.length) {\n    stops.push(source.length);\n    representative[source.length] = source.length;\n  }\n\n  return { source, stops, graphemes, representative };\n}\n\n/**\n * The legal offset standing for `offset` — the caret's real place.\n *\n * Not \"the closest number in `stops`\": see `representative`. Out-of-range\n * offsets clamp, because a caret that cannot be placed is worse than one placed\n * at the edge.\n */\nexport function nearestStop(map: CaretMap, offset: number): number {\n  const at = Math.max(0, Math.min(offset, map.source.length));\n  return map.representative[at] ?? 0;\n}\n\n/** The next legal offset in `direction`, or the same one at a document edge. */\nexport function stepStop(map: CaretMap, offset: number, direction: 1 | -1): number {\n  const at = nearestStop(map, offset);\n  const index = map.stops.indexOf(at);\n  const next = index + direction;\n  if (next < 0 || next >= map.stops.length) return at;\n  return map.stops[next];\n}\n\n/** The visible grapheme immediately before `offset`, if there is one. */\nexport function graphemeBefore(map: CaretMap, offset: number): Span | null {\n  let found: Span | null = null;\n  for (const span of map.graphemes) {\n    if (span.end <= offset) found = span;\n    else break;\n  }\n  return found;\n}\n\n/** The visible grapheme immediately after `offset`, if there is one. */\nexport function graphemeAfter(map: CaretMap, offset: number): Span | null {\n  for (const span of map.graphemes) if (span.start >= offset) return span;\n  return null;\n}\n\n/** The first legal offset on the line holding `offset` — where Home goes. */\nexport function lineStartStop(map: CaretMap, offset: number): number {\n  const { source } = map;\n  let start = Math.max(0, Math.min(offset, source.length));\n  while (start > 0 && source[start - 1] !== \"\\n\") start--;\n  for (const stop of map.stops) if (stop >= start) return stop;\n  return start;\n}\n\n/**\n * The last legal offset on the line holding `offset` — where End goes.\n *\n * SG-799 — NOT SAFE TO LEAVE TO THE BROWSER, the way `input.ts` leaves\n * vertical movement and word-wise movement to it. A block's own leading\n * markup (`# `, `- `, `> `) renders as `display: inline-block; width: 0`\n * (`styles/markdown.css`'s \"markup is collapsed at all times\" rule) so it can\n * be reached at all without ever having visible geometry — but a zero-size\n * `inline-block` is an ATOMIC box for Chromium's own line-navigation, and a\n * real Chromium probe caught it landing End's selection INSIDE that leading\n * box (`(\"# \", offset 2)`, the same on-screen point as where the caret\n * already stood) instead of at the true end of the visible text — every time,\n * on every block with a leading marker, regardless of heading level and\n * regardless of whether the line was the document's last one. Home already\n * had the model-side half of this fix (`lineStartStop`, above) sitting\n * unused — nothing in `input.ts` ever called it, so Home had the identical\n * exposure and simply hadn't been caught yet. Both are now computed here and\n * written directly, the same way `moveCaret` already computes ArrowLeft/Right\n * instead of trusting the browser.\n */\nexport function lineEndStop(map: CaretMap, offset: number): number {\n  const { source } = map;\n  let end = Math.max(0, Math.min(offset, source.length));\n  while (end < source.length && source[end] !== \"\\n\") end++;\n  let chosen = 0;\n  for (const stop of map.stops) {\n    if (stop > end) break;\n    chosen = stop;\n  }\n  return chosen;\n}\n"],"names":["INLINE_KINDS","segmenter","flatten","nodes","out","node","caretMap","projection","source","runs","syntax","run","at","graphemes","candidates","piece","start","end","a","b","frames","record","inlineDepth","n","frame","owner","lo","hi","best","atLineStart","boxes","r","atomics","spansAtomic","boxOf","box","sorted","stops","representative","group","flush","last","holder","bestDepth","d","previous","onlyMarkup","i","chosen","stop","nearestStop","map","offset","stepStop","direction","next","graphemeBefore","found","span","graphemeAfter","lineStartStop","lineEndStop"],"mappings":"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"}

package/dist/lib/markdown/caret.js

@@ -0,0 +1,35 @@
+const i = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function p(n, f, e) {
+  const t = Math.max(0, Math.min(f, n.length));
+  if (e === 1 && t >= n.length) return n.length;
+  if (e === -1 && t <= 0) return 0;
+  const r = m(n, t), a = r.start, o = n.slice(a, r.end), s = t - a;
+  if (e === -1 && s <= 0) return t - 1;
+  const g = [0];
+  for (const l of i.segment(o)) g.push(l.index + l.segment.length);
+  if (e === 1) {
+    for (const l of g) if (l > s) return a + l;
+    return t + 1;
+  }
+  let h = 0;
+  for (const l of g) {
+    if (l >= s) break;
+    h = l;
+  }
+  return a + h;
+}
+function m(n, f) {
+  const e = Math.max(0, Math.min(f, n.length));
+  let t = e;
+  for (; t > 0 && n[t - 1] !== `
+`; ) t--;
+  let r = e;
+  for (; r < n.length && n[r] !== `
+`; ) r++;
+  return { start: t, end: r };
+}
+export {
+  m as lineAt,
+  p as stepOffset
+};
+//# sourceMappingURL=caret.js.map

package/dist/lib/markdown/caret.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caret.js","sources":["../../../src/lib/markdown/caret.ts"],"sourcesContent":["/* ============================================================================\n   LINE AND GRAPHEME UTILITIES — and the record of a contract that was replaced.\n\n   ── WHAT THIS FILE USED TO BE ───────────────────────────────────────────────\n\n   This was THE CARET CONTRACT, and its first rule was:\n\n     \"EVERY SOURCE OFFSET IS A CARET POSITION. There are no atomic ranges, no\n      positions that cannot be reached, and no node type that is skipped over.\n      Pressing Left once moves back exactly one character, always, everywhere.\"\n\n   That rule was chosen against the decoration-based editors on purpose.\n   CodeMirror needed a dedicated `atomicRanges` facet because hiding syntax\n   with REPLACE decorations breaks the caret by default, and it was still being\n   patched in September 2025. Keeping markers as real, reachable text made the\n   whole bug class — caret trapped in a widget, cannot delete the next line,\n   atomic range not covering a hidden start or end — structurally impossible.\n\n   Its second rule was what paid for the first: markup was REVEALED on the\n   caret's own line, because a caret cannot be placed inside a zero-size box, so\n   an unrevealed marker is an offset with no geometry.\n\n   ── WHY IT IS NOT THAT ANY MORE ─────────────────────────────────────────────\n\n   The operator's requirement is that the markdown is NEVER shown — not even on\n   the line being edited. Rules 1 and 2 stand or fall together, so the reveal\n   going means markers have no geometry at any time, and offsets inside them\n   stop being positions.\n\n   That is the trade this file's original text refused, and refusing it was\n   defensible: the alternative it warned about is real. So the replacement owes\n   those failures an answer rather than an argument, and ./caret-map.ts gives\n   them one apiece — the caret is never PUT in a marker, deletion never works\n   BETWEEN caret stops but on the adjacent visible grapheme, and a marker's own\n   edges are candidate stops so a construct at either end of the document still\n   has a position outside it.\n\n   ── WHAT SURVIVED, AND WHY IT IS STILL HERE ─────────────────────────────────\n\n   Rule 4 survived untouched and is worth restating, because the new model does\n   not weaken it: NOTHING IS EVER REWRITTEN BEHIND THE USER. No input rule turns\n   `# ` into a heading node, because the `# ` IS the heading. Typing `* ` shows\n   a bullet the instant the space lands, and the bytes on disk are still `* `.\n   There is no auto-transform, so there is no \"undo the transform\" hatch to\n   design, and the Slack 2019 failure class — a rollout reversed over closing\n   backticks not being respected and `self._private_member` italicising itself —\n   is structurally absent rather than avoided.\n\n   Vertical, word-wise and Home/End movement remain the BROWSER's, deliberately:\n   they depend on layout, bidi and platform convention, and ProseMirror's author\n   concluded after a decade that reimplementing them is a decade of work. What\n   changed is that horizontal movement is now model-driven for a second reason\n   as well as the first — not only can one offset be two DOM points, but many\n   offsets are no longer points at all.\n\n   The two functions below are what is left: plain string utilities with no\n   opinion about markup. `lineAt` is used by every block command; `stepOffset`\n   steps one grapheme through a string and is the property harness's way of\n   applying an arbitrary SOURCE edit, which is deliberately not the same thing\n   as a user keystroke.\n   ========================================================================= */\n\n/* --- Horizontal movement, which is ours ----------------------------------- */\n\n/**\n * The next grapheme boundary before or after `offset`.\n *\n * WHY THIS IS NOT THE BROWSER'S JOB HERE, when vertical movement still is. One\n * source offset can be TWO DOM points — the end of one node and the start of\n * the next — and the browser rightly treats them as different places. Inside a\n * single inline flow it normalises them to one; across a table-cell boundary it\n * does not, because they genuinely are different cells. The arrow-key torture\n * test caught it there: pressing Right moved the caret from the end of `| ` to\n * the start of `a`, both of which are source offset 2, so the caret appeared to\n * stall. Every construct is exposed to it; the table is only where it shows.\n *\n * Rule 1 of the contract says Left moves back exactly one character, ALWAYS.\n * The only way to mean that is to move in the model and write the result, which\n * is also the only definition that is stable across engines.\n *\n * Graphemes, not code units: a thumbs-up is two UTF-16 units and a family emoji\n * is eleven, and stepping into the middle of either puts the caret somewhere no\n * character begins. `Intl.Segmenter` is the only correct answer and it has been\n * in every target engine since 2024.\n */\nconst segmenter = new Intl.Segmenter(undefined, { granularity: \"grapheme\" });\n\nexport function stepOffset(source: string, offset: number, direction: 1 | -1): number {\n  const at = Math.max(0, Math.min(offset, source.length));\n  if (direction === 1 && at >= source.length) return source.length;\n  if (direction === -1 && at <= 0) return 0;\n\n  /* Segmenting the whole document per keypress would be wasteful on a long\n     one, so only the caret's own line is segmented — a grapheme cluster never\n     spans a line break, so the answer is identical and the work is bounded. */\n  const line = lineAt(source, at);\n  const from = direction === 1 ? line.start : line.start;\n  const text = source.slice(from, line.end);\n  const local = at - from;\n\n  /* Leftward off the start of a line crosses into the previous line's\n     terminator, which is inside no cluster — a plain one-character move. There\n     is deliberately NO matching guard for the rightward case: the boundary scan\n     below already falls through to `at + 1` when nothing is further right, and\n     the mutation harness proved it by staying green with such a guard deleted.\n     A branch that can never change an answer is not insurance, it is noise. */\n  if (direction === -1 && local <= 0) return at - 1;\n\n  const boundaries = [0];\n  for (const piece of segmenter.segment(text)) boundaries.push(piece.index + piece.segment.length);\n\n  if (direction === 1) {\n    for (const edge of boundaries) if (edge > local) return from + edge;\n    return at + 1;\n  }\n  let previous = 0;\n  for (const edge of boundaries) {\n    if (edge >= local) break;\n    previous = edge;\n  }\n  return from + previous;\n}\n\n/** The source range of the line containing `offset`, terminator excluded. */\nexport function lineAt(source: string, offset: number): { start: number; end: number } {\n  const at = Math.max(0, Math.min(offset, source.length));\n  let start = at;\n  while (start > 0 && source[start - 1] !== \"\\n\") start--;\n  let end = at;\n  while (end < source.length && source[end] !== \"\\n\") end++;\n  return { start, end };\n}\n"],"names":["segmenter","stepOffset","source","offset","direction","at","line","lineAt","from","text","local","boundaries","piece","edge","previous","start","end"],"mappings":"AAqFA,MAAMA,IAAY,IAAI,KAAK,UAAU,QAAW,EAAE,aAAa,YAAY;AAEpE,SAASC,EAAWC,GAAgBC,GAAgBC,GAA2B;AACpF,QAAMC,IAAK,KAAK,IAAI,GAAG,KAAK,IAAIF,GAAQD,EAAO,MAAM,CAAC;AACtD,MAAIE,MAAc,KAAKC,KAAMH,EAAO,eAAeA,EAAO;AAC1D,MAAIE,MAAc,MAAMC,KAAM,EAAG,QAAO;AAKxC,QAAMC,IAAOC,EAAOL,GAAQG,CAAE,GACxBG,IAAyBF,EAAK,OAC9BG,IAAOP,EAAO,MAAMM,GAAMF,EAAK,GAAG,GAClCI,IAAQL,IAAKG;AAQnB,MAAIJ,MAAc,MAAMM,KAAS,UAAUL,IAAK;AAEhD,QAAMM,IAAa,CAAC,CAAC;AACrB,aAAWC,KAASZ,EAAU,QAAQS,CAAI,EAAG,CAAAE,EAAW,KAAKC,EAAM,QAAQA,EAAM,QAAQ,MAAM;AAE/F,MAAIR,MAAc,GAAG;AACnB,eAAWS,KAAQF,EAAY,KAAIE,IAAOH,UAAcF,IAAOK;AAC/D,WAAOR,IAAK;AAAA,EACd;AACA,MAAIS,IAAW;AACf,aAAWD,KAAQF,GAAY;AAC7B,QAAIE,KAAQH,EAAO;AACnB,IAAAI,IAAWD;AAAA,EACb;AACA,SAAOL,IAAOM;AAChB;AAGO,SAASP,EAAOL,GAAgBC,GAAgD;AACrF,QAAME,IAAK,KAAK,IAAI,GAAG,KAAK,IAAIF,GAAQD,EAAO,MAAM,CAAC;AACtD,MAAIa,IAAQV;AACZ,SAAOU,IAAQ,KAAKb,EAAOa,IAAQ,CAAC,MAAM;AAAA,IAAM,CAAAA;AAChD,MAAIC,IAAMX;AACV,SAAOW,IAAMd,EAAO,UAAUA,EAAOc,CAAG,MAAM;AAAA,IAAM,CAAAA;AACpD,SAAO,EAAE,OAAAD,GAAO,KAAAC,EAAA;AAClB;"}