@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/markdown/surface.js

@@ -0,0 +1,373 @@
+import { patch as p, CompositionConflictError as f, rangeOf as c } from "./reconcile.js";
+import { caretMap as u, nearestStop as n, stepStop as g, lineStartStop as m, lineEndStop as S } from "./caret-map.js";
+import { project as d } from "./project.js";
+import { readSelection as l, writeSelection as h } from "./position.js";
+import { History as y } from "./history.js";
+import { substituteAll as b } from "./images.js";
+class E {
+  root;
+  source;
+  options;
+  /**
+   * Upload swaps that arrived mid-composition, applied at `compositionend`.
+   *
+   * DX-3134: the composing text node carries the source range it came from,
+   * and `reconcileComposed` writes the composed text back into exactly that
+   * range. A swap applied mid-composition changes the length of the source
+   * before the node — the range would then point at the wrong characters, and
+   * the composed text would land inside a URL. So the swap waits, and runs
+   * right after the composition has been read back.
+   */
+  pendingSubstitutions = [];
+  /** The text node the browser is composing into, if any. */
+  composing = null;
+  /** A projection that arrived while composing, applied at `compositionend`. */
+  deferred = !1;
+  observer = null;
+  /** Depth of "this mutation is ours, ignore it". */
+  writing = 0;
+  history;
+  /** True while applying an undo, so the undo is not itself recorded. */
+  restoring = !1;
+  /**
+   * Where the caret is allowed to be, rebuilt with every projection.
+   *
+   * Held rather than recomputed per keystroke because every deletion and every
+   * arrow key needs it, and it is a pure function of the projection that was
+   * just built anyway. It is never mutated — a new projection replaces it
+   * whole, which is the same "nothing is kept in step so nothing can drift"
+   * argument the projection itself rests on.
+   */
+  caretStops;
+  /**
+   * The projection those stops were built from.
+   *
+   * Held for the same reason and handed to callers rather than re-derived: a
+   * deletion has to know which characters are markup and which construct owns
+   * them, and re-projecting to ask would parse the document twice per keypress.
+   */
+  projection;
+  constructor(t, r, e) {
+    this.root = t, this.source = r, this.options = e, this.history = new y({ source: r, selection: null }, e.history), this.projection = d(r, { highlight: e.highlight }), this.caretStops = u(this.projection), this.render(null);
+  }
+  getSource() {
+    return this.source;
+  }
+  /** The projection the DOM currently shows, for callers that must read it. */
+  getProjection() {
+    return this.projection;
+  }
+  /** Where the caret may legally be, for callers that have to reason about it. */
+  getCaretMap() {
+    return this.caretStops;
+  }
+  /**
+   * The selection, snapped to positions that exist.
+   *
+   * SNAPPED RATHER THAN RETURNED RAW, because a click can land anywhere — the
+   * browser will happily put the caret at the edge of a zero-width marker, and
+   * every offset inside markup is now a place with no geometry. Normalising on
+   * the way IN means no caller downstream has to remember to.
+   */
+  getSelection() {
+    const t = l(this.root);
+    return t ? {
+      anchor: n(this.caretStops, t.anchor),
+      head: n(this.caretStops, t.head)
+    } : null;
+  }
+  /* --- Editing ------------------------------------------------------------ */
+  /**
+   * Applies one splice and puts the caret where the inserted text ends.
+   *
+   * The caret is computed from the MODEL, never preserved from the DOM. That is
+   * the whole point of the design and also why it must be tested with a real
+   * caret in a real browser rather than asserted: a model-derived caret is
+   * exactly right or exactly wrong, with nothing in between.
+   */
+  apply(t, r, e = "other") {
+    const o = Math.max(0, Math.min(t.start, this.source.length)), s = Math.max(o, Math.min(t.end, this.source.length));
+    this.source = this.source.slice(0, o) + t.text + this.source.slice(s);
+    const i = o + t.text.length, a = r ?? { anchor: i, head: i };
+    this.restoring || this.history.record({ source: this.source, selection: a }, e, i), this.render(a), this.options.onChange?.(this.source);
+  }
+  /**
+   * Replaces every occurrence of `from` with `to` — in the document AND in
+   * every undo and redo entry — without recording an edit.
+   *
+   * THIS IS THE UPLOAD SWAP (DX-3134), and it is deliberately not an edit.
+   * When an image finishes uploading, its object URL is replaced by the stored
+   * URL. Recorded as an ordinary edit, Ctrl+Z would hand the object URL back —
+   * and a document holding it is a document that cannot be saved, for an image
+   * that WAS saved. Rewriting the history too means no undo, redo or later
+   * edit can resurrect a URL that no longer means anything.
+   *
+   * The caret stays where it was in the text the user can see: it is mapped
+   * through the substitution rather than moved, and only written back if it was
+   * in this surface to begin with — an upload finishing must never pull focus
+   * out of whatever the user moved on to. `onChange` fires, because the value
+   * genuinely changed and the consumer is the one who saves it.
+   *
+   * WHILE COMPOSING, the swap is queued and applied at `compositionend` — see
+   * `pendingSubstitutions`. A caller that needs to know when it has landed
+   * watches for `from` to leave the source (`onChange` fires when it does).
+   */
+  substitute(t, r) {
+    if (this.composing) {
+      this.pendingSubstitutions.push([t, r]);
+      return;
+    }
+    this.history.substitute(t, r);
+    const e = b(this.source, t, r);
+    if (!e) return;
+    const o = this.focusedSelection();
+    this.source = e.source, this.render(o ? { anchor: e.map(o.anchor), head: e.map(o.head) } : null), this.options.onChange?.(this.source);
+  }
+  /**
+   * The selection, but only while this surface HAS FOCUS.
+   *
+   * DX-3134: a render that is not the user's own edit — an upload finishing, an
+   * image's state moving — writes the caret back only when the author is
+   * actually in this document. The document selection can still sit inside the
+   * surface after focus has gone to a button or another field, and writing a
+   * selection into an editing host is one of the things that pulls focus back
+   * into it: an upload landing would then yank the author out of whatever they
+   * moved on to.
+   */
+  focusedSelection() {
+    return this.root.ownerDocument.activeElement === this.root ? this.getSelection() : null;
+  }
+  /** Whether any undo or redo entry still holds `text` — see `History.includes`. */
+  remembers(t) {
+    return this.history.includes(t);
+  }
+  /** Replaces the whole document, e.g. when the consumer's value prop changes. */
+  setSource(t) {
+    t !== this.source && (this.source = t, this.restoring || this.history.record({ source: t, selection: null }, "other", 0), this.render(null));
+  }
+  /* --- History ------------------------------------------------------------ */
+  get canUndo() {
+    return this.history.canUndo;
+  }
+  get canRedo() {
+    return this.history.canRedo;
+  }
+  undo() {
+    return this.restore(this.history.undo());
+  }
+  redo() {
+    return this.restore(this.history.redo());
+  }
+  /**
+   * Ends the current undo group.
+   *
+   * Called when the user moves the caret deliberately, because an edit after a
+   * selection change is a different thought however soon it arrives — one of
+   * the three coalescing rules, and the one a timer alone cannot express.
+   */
+  breakUndoGroup() {
+    this.history.break();
+  }
+  restore(t) {
+    if (!t) return !1;
+    this.restoring = !0;
+    try {
+      this.source = t.source, this.render(t.selection), this.options.onChange?.(this.source);
+    } finally {
+      this.restoring = !1;
+    }
+    return !0;
+  }
+  /* --- Rendering ---------------------------------------------------------- */
+  /**
+   * Re-projects and patches, then restores the caret.
+   *
+   * Refuses outright while composing. The deferral is recorded rather than
+   * dropped, so `compositionend` knows it owes a render — a skipped render that
+   * nobody remembers is a DOM that disagrees with the model forever.
+   */
+  render(t, r = "after") {
+    if (this.composing) {
+      this.deferred = !0;
+      return;
+    }
+    const e = d(this.source, { highlight: this.options.highlight });
+    this.projection = e, this.caretStops = u(e), this.write(() => {
+      try {
+        p(this.root, e.children, {});
+      } catch (s) {
+        if (s instanceof f) {
+          this.deferred = !0, this.options.onDesync?.(s.message);
+          return;
+        }
+        throw s;
+      }
+      const o = t ? {
+        anchor: n(this.caretStops, t.anchor),
+        head: n(this.caretStops, t.head)
+      } : null;
+      o && h(this.root, o, r);
+    }), this.verifySelection();
+  }
+  /**
+   * Puts the caret back on a legal position after the USER moved it.
+   *
+   * A click, a drag or a vertical arrow key can leave the browser's selection
+   * at the edge of a collapsed marker, which is a place with no geometry and no
+   * meaning. Snapping costs one write and no re-projection — re-rendering here
+   * would be wasted work AND a risk, since every patch is a chance to disturb a
+   * caret that was already where it belonged.
+   *
+   * Replaces `refreshActive`, which existed only to move the reveal.
+   */
+  snapCaret() {
+    const t = l(this.root);
+    if (!t) return;
+    const r = {
+      anchor: n(this.caretStops, t.anchor),
+      head: n(this.caretStops, t.head)
+    };
+    r.anchor === t.anchor && r.head === t.head || this.write(() => h(this.root, r, "after"));
+  }
+  /**
+   * Moves the caret one VISIBLE character, in the model, and writes the result.
+   *
+   * Returns false when there is no selection to move, so the caller can let the
+   * browser have the key rather than swallowing it.
+   *
+   * One press crosses a whole marker, however many characters it holds, because
+   * the positions inside it are not positions. That is the difference between
+   * this and the grapheme step it replaces: `stepOffset` counted source
+   * characters, and under a contract where markup is never shown, counting
+   * source characters makes the caret appear to stall.
+   */
+  moveCaret(t, r) {
+    const e = this.getSelection();
+    if (!e) return !1;
+    const o = !r && e.anchor !== e.head ? t === 1 ? Math.max(e.anchor, e.head) : Math.min(e.anchor, e.head) : g(this.caretStops, e.head, t), s = r ? { anchor: e.anchor, head: o } : { anchor: o, head: o };
+    return this.write(() => h(this.root, s, t === 1 ? "after" : "before")), !0;
+  }
+  /**
+   * Moves the caret to the start or end of its current line, in the model,
+   * and writes the result. Home and End both have to be computed here rather
+   * than left to the browser — SG-799 — because a block's leading markup
+   * renders as a zero-size `inline-block` (`styles/markdown.css`), which
+   * Chromium treats as an atomic box for its own native line navigation, and
+   * a real Chromium probe caught End landing the browser's OWN selection
+   * inside that leading box instead of at the true end of the line.
+   *
+   * Returns false when there is no selection to move, matching `moveCaret`.
+   */
+  moveToLineEdge(t, r) {
+    const e = this.getSelection();
+    if (!e) return !1;
+    const o = t === "start" ? m(this.caretStops, e.head) : S(this.caretStops, e.head), s = r ? { anchor: e.anchor, head: o } : { anchor: o, head: o };
+    return this.write(() => h(this.root, s, t === "start" ? "after" : "before")), !0;
+  }
+  /**
+   * Detects the third caret rule's failure: our own write left the browser's
+   * selection somewhere that is no longer a position in this document.
+   *
+   * Both mature codebases carry a detector for this because Chrome does it, and
+   * because the symptom — a caret that has silently moved to the top of the
+   * document — is indistinguishable from a bug in the edit itself.
+   */
+  verifySelection() {
+    const t = this.root.ownerDocument.getSelection();
+    if (!t || t.rangeCount === 0) return;
+    const r = t.anchorNode;
+    !r || !this.root.contains(r) || r.nodeType === 3 && !c(r) && this.options.onDesync?.("the selection is anchored in a text node this surface did not build");
+  }
+  /* --- Composition -------------------------------------------------------- */
+  /**
+   * Binds the composition lifecycle. Returns the unbind function.
+   *
+   * `compositionstart` captures the node the browser will mutate — read from
+   * the live selection, because that is the only place the browser says which
+   * one it chose.
+   */
+  bind() {
+    const t = () => {
+      const o = this.root.ownerDocument.getSelection()?.anchorNode ?? null;
+      this.composing = o && o.nodeType === 3 && this.root.contains(o) ? o : null;
+    }, r = () => {
+      const e = this.composing;
+      this.composing = null, e && this.reconcileComposed(e);
+      for (const [o, s] of this.pendingSubstitutions.splice(0)) this.substitute(o, s);
+      this.deferred && (this.deferred = !1, this.render(null));
+    };
+    return this.root.addEventListener("compositionstart", t), this.root.addEventListener("compositionend", r), this.observer = new MutationObserver((e) => this.onMutations(e)), this.observer.observe(this.root, { childList: !0, characterData: !0, subtree: !0 }), () => {
+      this.root.removeEventListener("compositionstart", t), this.root.removeEventListener("compositionend", r), this.observer?.disconnect(), this.observer = null;
+    };
+  }
+  /**
+   * Reads a finished composition back into the model.
+   *
+   * A composition is confined to ONE text node inside one inline element, and
+   * that node carries the source range it came from — so reconciling is
+   * "replace source characters a..b with this node's current text". A handful
+   * of lines against a known range, rather than the 407-line document-wide
+   * DOM-to-markdown serialiser this design exists to avoid.
+   */
+  reconcileComposed(t) {
+    const r = c(t);
+    if (!r) {
+      this.options.onDesync?.("composition landed in a text node with no source range"), this.render(null);
+      return;
+    }
+    const e = this.source.slice(r.start, r.end);
+    t.data !== e && this.apply(
+      { start: r.start, end: r.end, text: t.data },
+      { anchor: r.start + t.data.length, head: r.start + t.data.length },
+      "compose"
+    );
+  }
+  /* --- The repair path ---------------------------------------------------- */
+  /**
+   * Everything `preventDefault` could not cancel arrives here.
+   *
+   * This path is not a safety net, it is a REQUIREMENT: Chrome on Android
+   * reports `cancelable: true` on `deleteContentBackward` and deletes anyway,
+   * `insertCompositionText` is non-cancelable by spec, and iOS dictation fires
+   * no composition events at all. An editor with no observation path is simply
+   * broken on those inputs, and cannot be told that it is.
+   *
+   * The repair is deliberately narrow: a character-data change to a stamped
+   * node is read back into its range. Anything structural means the browser
+   * built nodes we cannot map, and the honest response is to re-project from
+   * the model we still trust, not to guess at what it did.
+   */
+  onMutations(t) {
+    if (this.writing > 0 || this.composing) return;
+    let r = !1;
+    for (const e of t) {
+      if (e.type !== "characterData") {
+        this.render(this.getSelection());
+        return;
+      }
+      const o = e.target, s = c(o);
+      if (!s) {
+        this.render(this.getSelection());
+        return;
+      }
+      const i = this.source.slice(s.start, s.end);
+      if (i !== o.data) {
+        this.apply({ start: s.start, end: s.end, text: o.data }, void 0, o.data.length >= i.length ? "type" : "delete"), r = !0;
+        break;
+      }
+    }
+  }
+  /** Runs `fn` with our own mutations invisible to the observer. */
+  write(t) {
+    this.writing++;
+    try {
+      t();
+    } finally {
+      this.observer?.takeRecords(), this.writing--;
+    }
+  }
+}
+export {
+  E as MarkdownSurface
+};
+//# sourceMappingURL=surface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surface.js","sources":["../../../src/lib/markdown/surface.ts"],"sourcesContent":["/* ============================================================================\n   THE SURFACE — the markdown string, the DOM that shows it, and the caret that\n   has to survive between them.\n\n   ONE PIECE OF STATE: the source string. The DOM is a projection of it, the\n   caret is a pair of offsets into it, and every edit is a splice. There is no\n   document model, no transaction log, and nothing to serialise — which is what\n   makes \"open a file, touch nothing, the bytes do not move\" true by\n   construction rather than by test.\n\n   THE COMPOSITION CARVE-OUT IS THE LOAD-BEARING PART, and it is built in from\n   the first commit because retrofitting it is what killed Slate's. While the\n   browser is composing — an IME, a long-press accent, dictation, an Android\n   keyboard, which is almost always composing — this surface:\n\n     - does not re-project, because re-rendering during composition CANCELS the\n       IME, which is Chrome's own stated reason for building EditContext;\n     - hands the reconciler the composing text node as PROTECTED, so a patch\n       that would disturb it throws instead of corrupting it;\n     - reconciles afterwards from the DOM the browser produced, by reading the\n       composing node's new text back into the range it came from.\n\n   THE THREE CARET RULES, verbatim from ProseMirror and CodeMirror: do not write\n   the selection when it already matches (./position.ts); disconnect the\n   observer around our own writes (below); and keep a detector for \"my own write\n   corrupted the browser's selection state\" (also below).\n   ========================================================================= */\n\nimport { patch, rangeOf, CompositionConflictError } from \"./reconcile\";\nimport { caretMap, lineEndStop, lineStartStop, nearestStop, stepStop, type CaretMap } from \"./caret-map\";\nimport { project, type Projection, type ProjectOptions } from \"./project\";\nimport { readSelection, writeSelection, type Association, type SourceSelection } from \"./position\";\nimport { History, type EditKind, type HistoryOptions } from \"./history\";\nimport { substituteAll } from \"./images\";\n\nexport interface SurfaceOptions {\n  /** Called after every committed change, with the new source. */\n  onChange?: (source: string) => void;\n  /** Undo tuning. The defaults are the constants the mature editors landed on. */\n  history?: HistoryOptions;\n  /**\n   * Highlights a fenced block. Injected, never imported: reaching for the\n   * grammar registry from the pure layer would make a projection depend on\n   * which languages happened to be registered when it ran. The component\n   * passes the real tokenizer; a test can pass none and get plain text.\n   */\n  highlight?: ProjectOptions[\"highlight\"];\n  /**\n   * Called when the DOM stopped agreeing with the model and could not be\n   * repaired from it. Loud by default: this is the one failure that silently\n   * eats the user's text if it is swallowed.\n   */\n  onDesync?: (detail: string) => void;\n}\n\nexport interface Splice {\n  start: number;\n  end: number;\n  text: string;\n}\n\nexport class MarkdownSurface {\n  readonly root: HTMLElement;\n  private source: string;\n  private readonly options: SurfaceOptions;\n\n  /**\n   * Upload swaps that arrived mid-composition, applied at `compositionend`.\n   *\n   * DX-3134: the composing text node carries the source range it came from,\n   * and `reconcileComposed` writes the composed text back into exactly that\n   * range. A swap applied mid-composition changes the length of the source\n   * before the node — the range would then point at the wrong characters, and\n   * the composed text would land inside a URL. So the swap waits, and runs\n   * right after the composition has been read back.\n   */\n  private pendingSubstitutions: Array<[from: string, to: string]> = [];\n\n  /** The text node the browser is composing into, if any. */\n  private composing: Text | null = null;\n  /** A projection that arrived while composing, applied at `compositionend`. */\n  private deferred = false;\n\n  private observer: MutationObserver | null = null;\n  /** Depth of \"this mutation is ours, ignore it\". */\n  private writing = 0;\n\n  private readonly history: History;\n  /** True while applying an undo, so the undo is not itself recorded. */\n  private restoring = false;\n\n  /**\n   * Where the caret is allowed to be, rebuilt with every projection.\n   *\n   * Held rather than recomputed per keystroke because every deletion and every\n   * arrow key needs it, and it is a pure function of the projection that was\n   * just built anyway. It is never mutated — a new projection replaces it\n   * whole, which is the same \"nothing is kept in step so nothing can drift\"\n   * argument the projection itself rests on.\n   */\n  private caretStops: CaretMap;\n\n  /**\n   * The projection those stops were built from.\n   *\n   * Held for the same reason and handed to callers rather than re-derived: a\n   * deletion has to know which characters are markup and which construct owns\n   * them, and re-projecting to ask would parse the document twice per keypress.\n   */\n  private projection: Projection;\n\n  constructor(root: HTMLElement, source: string, options: SurfaceOptions) {\n    this.root = root;\n    this.source = source;\n    this.options = options;\n    this.history = new History({ source, selection: null }, options.history);\n    this.projection = project(source, { highlight: options.highlight });\n    this.caretStops = caretMap(this.projection);\n    this.render(null);\n  }\n\n  getSource(): string {\n    return this.source;\n  }\n\n  /** The projection the DOM currently shows, for callers that must read it. */\n  getProjection(): Projection {\n    return this.projection;\n  }\n\n  /** Where the caret may legally be, for callers that have to reason about it. */\n  getCaretMap(): CaretMap {\n    return this.caretStops;\n  }\n\n  /**\n   * The selection, snapped to positions that exist.\n   *\n   * SNAPPED RATHER THAN RETURNED RAW, because a click can land anywhere — the\n   * browser will happily put the caret at the edge of a zero-width marker, and\n   * every offset inside markup is now a place with no geometry. Normalising on\n   * the way IN means no caller downstream has to remember to.\n   */\n  getSelection(): SourceSelection | null {\n    const raw = readSelection(this.root);\n    if (!raw) return null;\n    return {\n      anchor: nearestStop(this.caretStops, raw.anchor),\n      head: nearestStop(this.caretStops, raw.head),\n    };\n  }\n\n  /* --- Editing ------------------------------------------------------------ */\n\n  /**\n   * Applies one splice and puts the caret where the inserted text ends.\n   *\n   * The caret is computed from the MODEL, never preserved from the DOM. That is\n   * the whole point of the design and also why it must be tested with a real\n   * caret in a real browser rather than asserted: a model-derived caret is\n   * exactly right or exactly wrong, with nothing in between.\n   */\n  apply(splice: Splice, select?: SourceSelection, kind: EditKind = \"other\"): void {\n    const start = Math.max(0, Math.min(splice.start, this.source.length));\n    const end = Math.max(start, Math.min(splice.end, this.source.length));\n    this.source = this.source.slice(0, start) + splice.text + this.source.slice(end);\n    const at = start + splice.text.length;\n    const caret = select ?? { anchor: at, head: at };\n    if (!this.restoring) this.history.record({ source: this.source, selection: caret }, kind, at);\n    this.render(caret);\n    this.options.onChange?.(this.source);\n  }\n\n  /**\n   * Replaces every occurrence of `from` with `to` — in the document AND in\n   * every undo and redo entry — without recording an edit.\n   *\n   * THIS IS THE UPLOAD SWAP (DX-3134), and it is deliberately not an edit.\n   * When an image finishes uploading, its object URL is replaced by the stored\n   * URL. Recorded as an ordinary edit, Ctrl+Z would hand the object URL back —\n   * and a document holding it is a document that cannot be saved, for an image\n   * that WAS saved. Rewriting the history too means no undo, redo or later\n   * edit can resurrect a URL that no longer means anything.\n   *\n   * The caret stays where it was in the text the user can see: it is mapped\n   * through the substitution rather than moved, and only written back if it was\n   * in this surface to begin with — an upload finishing must never pull focus\n   * out of whatever the user moved on to. `onChange` fires, because the value\n   * genuinely changed and the consumer is the one who saves it.\n   *\n   * WHILE COMPOSING, the swap is queued and applied at `compositionend` — see\n   * `pendingSubstitutions`. A caller that needs to know when it has landed\n   * watches for `from` to leave the source (`onChange` fires when it does).\n   */\n  substitute(from: string, to: string): void {\n    if (this.composing) {\n      this.pendingSubstitutions.push([from, to]);\n      return;\n    }\n    this.history.substitute(from, to);\n    const swap = substituteAll(this.source, from, to);\n    if (!swap) return;\n    const before = this.focusedSelection();\n    this.source = swap.source;\n    this.render(before ? { anchor: swap.map(before.anchor), head: swap.map(before.head) } : null);\n    this.options.onChange?.(this.source);\n  }\n\n  /**\n   * The selection, but only while this surface HAS FOCUS.\n   *\n   * DX-3134: a render that is not the user's own edit — an upload finishing, an\n   * image's state moving — writes the caret back only when the author is\n   * actually in this document. The document selection can still sit inside the\n   * surface after focus has gone to a button or another field, and writing a\n   * selection into an editing host is one of the things that pulls focus back\n   * into it: an upload landing would then yank the author out of whatever they\n   * moved on to.\n   */\n  private focusedSelection(): SourceSelection | null {\n    return this.root.ownerDocument.activeElement === this.root ? this.getSelection() : null;\n  }\n\n  /** Whether any undo or redo entry still holds `text` — see `History.includes`. */\n  remembers(text: string): boolean {\n    return this.history.includes(text);\n  }\n\n  /** Replaces the whole document, e.g. when the consumer's value prop changes. */\n  setSource(source: string): void {\n    if (source === this.source) return;\n    this.source = source;\n    if (!this.restoring) this.history.record({ source, selection: null }, \"other\", 0);\n    this.render(null);\n  }\n\n  /* --- History ------------------------------------------------------------ */\n\n  get canUndo(): boolean {\n    return this.history.canUndo;\n  }\n\n  get canRedo(): boolean {\n    return this.history.canRedo;\n  }\n\n  undo(): boolean {\n    return this.restore(this.history.undo());\n  }\n\n  redo(): boolean {\n    return this.restore(this.history.redo());\n  }\n\n  /**\n   * Ends the current undo group.\n   *\n   * Called when the user moves the caret deliberately, because an edit after a\n   * selection change is a different thought however soon it arrives — one of\n   * the three coalescing rules, and the one a timer alone cannot express.\n   */\n  breakUndoGroup(): void {\n    this.history.break();\n  }\n\n  private restore(entry: { source: string; selection: SourceSelection | null } | null): boolean {\n    if (!entry) return false;\n    this.restoring = true;\n    try {\n      this.source = entry.source;\n      this.render(entry.selection);\n      this.options.onChange?.(this.source);\n    } finally {\n      this.restoring = false;\n    }\n    return true;\n  }\n\n  /* --- Rendering ---------------------------------------------------------- */\n\n  /**\n   * Re-projects and patches, then restores the caret.\n   *\n   * Refuses outright while composing. The deferral is recorded rather than\n   * dropped, so `compositionend` knows it owes a render — a skipped render that\n   * nobody remembers is a DOM that disagrees with the model forever.\n   */\n  private render(caret: SourceSelection | null, association: Association = \"after\"): void {\n    if (this.composing) {\n      this.deferred = true;\n      return;\n    }\n    const projection = project(this.source, { highlight: this.options.highlight });\n    this.projection = projection;\n    this.caretStops = caretMap(projection);\n    this.write(() => {\n      try {\n        patch(this.root, projection.children, {});\n      } catch (error) {\n        if (error instanceof CompositionConflictError) {\n          /* Reached only if `this.composing` was cleared while a patch was in\n             flight. Recorded, never swallowed. */\n          this.deferred = true;\n          this.options.onDesync?.(error.message);\n          return;\n        }\n        throw error;\n      }\n      /* SNAPPED AT THE LAST MOMENT, because the caret a command asked for was\n         computed against the source BEFORE this projection existed — an edit\n         that removes a marker can leave a perfectly reasonable offset sitting\n         inside one. There is no reveal step to run first any more: markup has\n         no geometry at any time, so the only way a written selection lands\n         where it was asked to is for it to be a stop. */\n      const snapped = caret\n        ? {\n            anchor: nearestStop(this.caretStops, caret.anchor),\n            head: nearestStop(this.caretStops, caret.head),\n          }\n        : null;\n      if (snapped) writeSelection(this.root, snapped, association);\n    });\n    this.verifySelection();\n  }\n\n  /**\n   * Puts the caret back on a legal position after the USER moved it.\n   *\n   * A click, a drag or a vertical arrow key can leave the browser's selection\n   * at the edge of a collapsed marker, which is a place with no geometry and no\n   * meaning. Snapping costs one write and no re-projection — re-rendering here\n   * would be wasted work AND a risk, since every patch is a chance to disturb a\n   * caret that was already where it belonged.\n   *\n   * Replaces `refreshActive`, which existed only to move the reveal.\n   */\n  snapCaret(): void {\n    const raw = readSelection(this.root);\n    if (!raw) return;\n    const next: SourceSelection = {\n      anchor: nearestStop(this.caretStops, raw.anchor),\n      head: nearestStop(this.caretStops, raw.head),\n    };\n    if (next.anchor === raw.anchor && next.head === raw.head) return;\n    this.write(() => writeSelection(this.root, next, \"after\"));\n  }\n\n  /**\n   * Moves the caret one VISIBLE character, in the model, and writes the result.\n   *\n   * Returns false when there is no selection to move, so the caller can let the\n   * browser have the key rather than swallowing it.\n   *\n   * One press crosses a whole marker, however many characters it holds, because\n   * the positions inside it are not positions. That is the difference between\n   * this and the grapheme step it replaces: `stepOffset` counted source\n   * characters, and under a contract where markup is never shown, counting\n   * source characters makes the caret appear to stall.\n   */\n  moveCaret(direction: 1 | -1, extend: boolean): boolean {\n    const current = this.getSelection();\n    if (!current) return false;\n    /* A non-empty selection collapses to its near edge rather than stepping —\n       every text field behaves this way and it is the one case where \"move by\n       one\" is not what the user means. */\n    const from =\n      !extend && current.anchor !== current.head\n        ? direction === 1\n          ? Math.max(current.anchor, current.head)\n          : Math.min(current.anchor, current.head)\n        : stepStop(this.caretStops, current.head, direction);\n    const next: SourceSelection = extend ? { anchor: current.anchor, head: from } : { anchor: from, head: from };\n    this.write(() => writeSelection(this.root, next, direction === 1 ? \"after\" : \"before\"));\n    return true;\n  }\n\n  /**\n   * Moves the caret to the start or end of its current line, in the model,\n   * and writes the result. Home and End both have to be computed here rather\n   * than left to the browser — SG-799 — because a block's leading markup\n   * renders as a zero-size `inline-block` (`styles/markdown.css`), which\n   * Chromium treats as an atomic box for its own native line navigation, and\n   * a real Chromium probe caught End landing the browser's OWN selection\n   * inside that leading box instead of at the true end of the line.\n   *\n   * Returns false when there is no selection to move, matching `moveCaret`.\n   */\n  moveToLineEdge(edge: \"start\" | \"end\", extend: boolean): boolean {\n    const current = this.getSelection();\n    if (!current) return false;\n    const from = edge === \"start\" ? lineStartStop(this.caretStops, current.head) : lineEndStop(this.caretStops, current.head);\n    const next: SourceSelection = extend ? { anchor: current.anchor, head: from } : { anchor: from, head: from };\n    this.write(() => writeSelection(this.root, next, edge === \"start\" ? \"after\" : \"before\"));\n    return true;\n  }\n\n  /**\n   * Detects the third caret rule's failure: our own write left the browser's\n   * selection somewhere that is no longer a position in this document.\n   *\n   * Both mature codebases carry a detector for this because Chrome does it, and\n   * because the symptom — a caret that has silently moved to the top of the\n   * document — is indistinguishable from a bug in the edit itself.\n   */\n  private verifySelection(): void {\n    const selection = this.root.ownerDocument.getSelection();\n    if (!selection || selection.rangeCount === 0) return;\n    const node = selection.anchorNode;\n    if (!node || !this.root.contains(node)) return;\n    if (node.nodeType === 3 && !rangeOf(node)) {\n      // I18N-ALLOW: English developer diagnostic passed to onDesync, not user text\n      this.options.onDesync?.(\"the selection is anchored in a text node this surface did not build\");\n    }\n  }\n\n  /* --- Composition -------------------------------------------------------- */\n\n  /**\n   * Binds the composition lifecycle. Returns the unbind function.\n   *\n   * `compositionstart` captures the node the browser will mutate — read from\n   * the live selection, because that is the only place the browser says which\n   * one it chose.\n   */\n  bind(): () => void {\n    const start = () => {\n      const selection = this.root.ownerDocument.getSelection();\n      const node = selection?.anchorNode ?? null;\n      this.composing = node && node.nodeType === 3 && this.root.contains(node) ? (node as Text) : null;\n    };\n\n    const end = () => {\n      const node = this.composing;\n      this.composing = null;\n      if (node) this.reconcileComposed(node);\n      /* AFTER the composition is read back into the range it came from — the\n         order is the whole point of queueing them (DX-3134). */\n      for (const [from, to] of this.pendingSubstitutions.splice(0)) this.substitute(from, to);\n      if (this.deferred) {\n        this.deferred = false;\n        this.render(null);\n      }\n    };\n\n    this.root.addEventListener(\"compositionstart\", start);\n    this.root.addEventListener(\"compositionend\", end);\n    this.observer = new MutationObserver((records) => this.onMutations(records));\n    this.observer.observe(this.root, { childList: true, characterData: true, subtree: true });\n\n    return () => {\n      this.root.removeEventListener(\"compositionstart\", start);\n      this.root.removeEventListener(\"compositionend\", end);\n      this.observer?.disconnect();\n      this.observer = null;\n    };\n  }\n\n  /**\n   * Reads a finished composition back into the model.\n   *\n   * A composition is confined to ONE text node inside one inline element, and\n   * that node carries the source range it came from — so reconciling is\n   * \"replace source characters a..b with this node's current text\". A handful\n   * of lines against a known range, rather than the 407-line document-wide\n   * DOM-to-markdown serialiser this design exists to avoid.\n   */\n  private reconcileComposed(node: Text): void {\n    const range = rangeOf(node);\n    if (!range) {\n      // I18N-ALLOW: English developer diagnostic passed to onDesync, not user text\n      this.options.onDesync?.(\"composition landed in a text node with no source range\");\n      this.render(null);\n      return;\n    }\n    const was = this.source.slice(range.start, range.end);\n    if (node.data === was) return;\n    this.apply(\n      { start: range.start, end: range.end, text: node.data },\n      { anchor: range.start + node.data.length, head: range.start + node.data.length },\n      \"compose\",\n    );\n  }\n\n  /* --- The repair path ---------------------------------------------------- */\n\n  /**\n   * Everything `preventDefault` could not cancel arrives here.\n   *\n   * This path is not a safety net, it is a REQUIREMENT: Chrome on Android\n   * reports `cancelable: true` on `deleteContentBackward` and deletes anyway,\n   * `insertCompositionText` is non-cancelable by spec, and iOS dictation fires\n   * no composition events at all. An editor with no observation path is simply\n   * broken on those inputs, and cannot be told that it is.\n   *\n   * The repair is deliberately narrow: a character-data change to a stamped\n   * node is read back into its range. Anything structural means the browser\n   * built nodes we cannot map, and the honest response is to re-project from\n   * the model we still trust, not to guess at what it did.\n   */\n  private onMutations(records: MutationRecord[]): void {\n    if (this.writing > 0 || this.composing) return;\n\n    let repaired = false;\n    for (const record of records) {\n      if (record.type !== \"characterData\") {\n        this.render(this.getSelection());\n        return;\n      }\n      const node = record.target as Text;\n      const range = rangeOf(node);\n      if (!range) {\n        this.render(this.getSelection());\n        return;\n      }\n      const was = this.source.slice(range.start, range.end);\n      if (was === node.data) continue;\n      /* Classified so undo still coalesces on the repair path. On Android that\n         path is not an edge case, it is the ONLY path — recording every\n         observed change as \"other\" would mean one undo entry per character,\n         which is the most common complaint about hand-rolled editors. */\n      this.apply({ start: range.start, end: range.end, text: node.data }, undefined, node.data.length >= was.length ? \"type\" : \"delete\");\n      repaired = true;\n      break;\n    }\n    if (!repaired) return;\n  }\n\n  /** Runs `fn` with our own mutations invisible to the observer. */\n  private write(fn: () => void): void {\n    this.writing++;\n    try {\n      fn();\n    } finally {\n      /* The records for our own writes are already queued; taking them here is\n         what actually discards them. Clearing the flag without this leaves them\n         to arrive on the next microtask and be treated as the user's. */\n      this.observer?.takeRecords();\n      this.writing--;\n    }\n  }\n}\n"],"names":["MarkdownSurface","root","source","options","History","project","caretMap","raw","readSelection","nearestStop","splice","select","kind","start","end","at","caret","from","to","swap","substituteAll","before","text","entry","association","projection","patch","error","CompositionConflictError","snapped","writeSelection","next","direction","extend","current","stepStop","edge","lineStartStop","lineEndStop","selection","node","rangeOf","records","range","was","repaired","record","fn"],"mappings":"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"}

package/dist/lib/motion.js

@@ -0,0 +1,22 @@
+import { useSyncExternalStore as r } from "react";
+import { useMediaQuery as n } from "./use-media-query.js";
+function d() {
+  const t = getComputedStyle(document.documentElement).getPropertyValue("--motion-scale").trim(), e = Number.parseFloat(t);
+  return Number.isFinite(e) ? e < 1 : window.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? !1;
+}
+const o = "(prefers-reduced-motion: reduce)";
+function u(t) {
+  const e = new MutationObserver(t);
+  return e.observe(document.documentElement, { attributes: !0, attributeFilter: ["data-motion"] }), () => e.disconnect();
+}
+const c = () => document.documentElement.getAttribute("data-motion");
+function m() {
+  const t = n(o), e = r(u, c, () => null);
+  return e === "reduced" ? !0 : e === "full" ? !1 : t;
+}
+export {
+  o as OS_REDUCE,
+  d as reducedMotion,
+  m as useReducedMotion
+};
+//# sourceMappingURL=motion.js.map

package/dist/lib/motion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.js","sources":["../../src/lib/motion.ts"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\nimport { useMediaQuery } from \"./use-media-query\";\n\n/**\n * The one reduced-motion answer, read from `--motion-scale`.\n *\n * WHY THE TOKEN AND NOT `matchMedia` DIRECTLY. `--motion-scale` is the single\n * place where the OS media query and the app-level `data-motion` override are\n * reconciled (see `styles/motion.css`). Reading the media query alone would\n * ignore the in-app preference control, so a user who set \"reduced\" in the app\n * on a machine with no OS setting would get full-speed motion — the exact case\n * that control exists for. It is also why a raw `motion-reduce:` utility is the\n * wrong tool for anything this system builds (see the note on `Choice`'s\n * thumb): that variant reads the OS query alone and fires even for someone who\n * has explicitly chosen `data-motion=\"full\"`.\n *\n * ONLY THE COMPARISON IS EVER USED, never the value. Multiplying a SPEED by the\n * scale would be backwards — a slower auto-scroll ramp holds the user at the\n * edge longer and produces MORE motion overall — and a scroll has no \"half\"\n * anyway: it is smooth or it is a jump.\n *\n * ITS OWN MODULE because two unrelated layers need it. The drag engine's edge\n * auto-scroll had the only copy, and the tab strip's reveal-the-active-tab\n * scroll needs exactly the same question answered exactly the same way. A\n * second copy is a second place for the token name to go stale.\n */\nexport function reducedMotion(): boolean {\n  const raw = getComputedStyle(document.documentElement)\n    .getPropertyValue(\"--motion-scale\")\n    .trim();\n  const scale = Number.parseFloat(raw);\n  if (Number.isFinite(scale)) return scale < 1;\n  /* The token is missing — the stylesheet is not loaded. Fall back to the OS\n     query so the preference is still honoured rather than silently ignored. */\n  return window.matchMedia?.(\"(prefers-reduced-motion: reduce)\").matches ?? false;\n}\n\n/* DX-4504: the playground showed a static outline to someone whose Appearance menu read \"Reduce motion: off\",\n   because the preference was `system` and Windows had \"Animation effects\" switched off. Anything that tells a\n   person what motion they are getting must say what they ACTUALLY get, so it reads the same two inputs\n   `styles/motion.css` reconciles: the app's `data-motion` override, then the OS preference. Not `reducedMotion()`\n   above: that reads `--motion-scale`, which is also 0 for the single frame a theme change suspends motion, and a\n   label must not flicker to \"reduced\" on every theme switch. */\n// I18N-ALLOW: CSS media query string\nexport const OS_REDUCE = \"(prefers-reduced-motion: reduce)\";\n\nfunction subscribePreference(onChange: () => void): () => void {\n  const observer = new MutationObserver(onChange);\n  observer.observe(document.documentElement, { attributes: true, attributeFilter: [\"data-motion\"] });\n  return () => observer.disconnect();\n}\n\nconst readPreference = () => document.documentElement.getAttribute(\"data-motion\");\n\n/**\n * The effective reduced-motion state, live: it re-renders when the OS preference changes and when any\n * `useMotionPreference` anywhere in the page writes a new `data-motion`.\n */\nexport function useReducedMotion(): boolean {\n  const osReduces = useMediaQuery(OS_REDUCE);\n  const preference = useSyncExternalStore(subscribePreference, readPreference, () => null);\n  if (preference === \"reduced\") return true;\n  if (preference === \"full\") return false;\n  return osReduces;\n}\n"],"names":["reducedMotion","raw","scale","OS_REDUCE","subscribePreference","onChange","observer","readPreference","useReducedMotion","osReduces","useMediaQuery","preference","useSyncExternalStore"],"mappings":";;AA0BO,SAASA,IAAyB;AACvC,QAAMC,IAAM,iBAAiB,SAAS,eAAe,EAClD,iBAAiB,gBAAgB,EACjC,KAAA,GACGC,IAAQ,OAAO,WAAWD,CAAG;AACnC,SAAI,OAAO,SAASC,CAAK,IAAUA,IAAQ,IAGpC,OAAO,aAAa,kCAAkC,EAAE,WAAW;AAC5E;AASO,MAAMC,IAAY;AAEzB,SAASC,EAAoBC,GAAkC;AAC7D,QAAMC,IAAW,IAAI,iBAAiBD,CAAQ;AAC9C,SAAAC,EAAS,QAAQ,SAAS,iBAAiB,EAAE,YAAY,IAAM,iBAAiB,CAAC,aAAa,GAAG,GAC1F,MAAMA,EAAS,WAAA;AACxB;AAEA,MAAMC,IAAiB,MAAM,SAAS,gBAAgB,aAAa,aAAa;AAMzE,SAASC,IAA4B;AAC1C,QAAMC,IAAYC,EAAcP,CAAS,GACnCQ,IAAaC,EAAqBR,GAAqBG,GAAgB,MAAM,IAAI;AACvF,SAAII,MAAe,YAAkB,KACjCA,MAAe,SAAe,KAC3BF;AACT;"}

package/dist/lib/pad.js

@@ -0,0 +1,7 @@
+function n(t, r = 2) {
+  return String(t).padStart(r, "0");
+}
+export {
+  n as pad
+};
+//# sourceMappingURL=pad.js.map

package/dist/lib/pad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pad.js","sources":["../../src/lib/pad.ts"],"sourcesContent":["/** Zero-pad a non-negative integer to `width` digits — `pad(9)` → `\"09\"`,\n *  `pad(7, 3)` → `\"007\"`. Internal only: shared by the time and value\n *  formatters that print fixed-width calendar/clock fields, not part of the\n *  public package surface (DX-3254 — this one-liner used to be redefined\n *  independently in four places). */\nexport function pad(n: number, width = 2): string {\n  return String(n).padStart(width, \"0\");\n}\n"],"names":["pad","n","width"],"mappings":"AAKO,SAASA,EAAIC,GAAWC,IAAQ,GAAW;AAChD,SAAO,OAAOD,CAAC,EAAE,SAASC,GAAO,GAAG;AACtC;"}

package/dist/lib/paged-window/layout.js

@@ -0,0 +1,15 @@
+function i(t) {
+  return t ? t.shown ? "ready" : t.status === "ready" ? "waiting" : t.status : "unheld";
+}
+function o(t, r) {
+  return t > 0 ? t : r > 0 ? 1 : 0;
+}
+function e(t, r, n, u) {
+  return Math.min(r, n - t * r) * u;
+}
+export {
+  o as blockCountFor,
+  i as blockStatus,
+  e as placeholderHeight
+};
+//# sourceMappingURL=layout.js.map

package/dist/lib/paged-window/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sources":["../../../src/lib/paged-window/layout.ts"],"sourcesContent":["import type { PageSnapshot } from \"./store\";\n\n/**\n * What a page's block is showing. One name for every case, so the list renders\n * ONE kind of block and only this changes:\n *   ready    the page's cards are shown\n *   loading  resident, its request is in flight\n *   error    resident, its request failed\n *   waiting  resident and ready, but past a hole in the loaded run — not shown until\n *            the page that closes the hole arrives (see the store header)\n *   unheld   outside the window (its rows may be kept, not drawn): empty space of the right height\n */\nexport type BlockStatus = \"ready\" | \"loading\" | \"error\" | \"waiting\" | \"unheld\";\n\nexport function blockStatus<T>(page: PageSnapshot<T> | undefined): BlockStatus {\n  if (!page) return \"unheld\";\n  if (page.shown) return \"ready\";\n  if (page.status === \"ready\") return \"waiting\";\n  return page.status;\n}\n\n/**\n * How many page blocks to render. One per page of the list; before the first\n * response the length is unknown but page 0 is being asked for, and one block\n * stands in for it, so a new query does not flash an empty list.\n */\nexport function blockCountFor(pageCount: number, drawnPageCount: number): number {\n  if (pageCount > 0) return pageCount;\n  return drawnPageCount > 0 ? 1 : 0;\n}\n\n/** The height of a page's placeholder: the items it holds (the last page is short) times one item's height. */\nexport function placeholderHeight(page: number, pageSize: number, total: number, pitch: number): number {\n  return Math.min(pageSize, total - page * pageSize) * pitch;\n}\n"],"names":["blockStatus","page","blockCountFor","pageCount","drawnPageCount","placeholderHeight","pageSize","total","pitch"],"mappings":"AAcO,SAASA,EAAeC,GAAgD;AAC7E,SAAKA,IACDA,EAAK,QAAc,UACnBA,EAAK,WAAW,UAAgB,YAC7BA,EAAK,SAHM;AAIpB;AAOO,SAASC,EAAcC,GAAmBC,GAAgC;AAC/E,SAAID,IAAY,IAAUA,IACnBC,IAAiB,IAAI,IAAI;AAClC;AAGO,SAASC,EAAkBJ,GAAcK,GAAkBC,GAAeC,GAAuB;AACtG,SAAO,KAAK,IAAIF,GAAUC,IAAQN,IAAOK,CAAQ,IAAIE;AACvD;"}

package/dist/lib/paged-window/list-owner.js

@@ -0,0 +1,21 @@
+import { jsx as n } from "react/jsx-runtime";
+import { useContext as o, useLayoutEffect as u, createContext as i } from "react";
+const e = i(null);
+function c({ value: t, children: r }) {
+  return /* @__PURE__ */ n(e.Provider, { value: t, children: r });
+}
+function p() {
+  return o(e);
+}
+function x(t, r) {
+  u(() => {
+    if (!(!t || !r))
+      return t.reportBusy(1), () => t.reportBusy(-1);
+  }, [t, r]);
+}
+export {
+  c as ListOwnerProvider,
+  p as useListOwner,
+  x as useReportBusy
+};
+//# sourceMappingURL=list-owner.js.map

package/dist/lib/paged-window/list-owner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-owner.js","sources":["../../../src/lib/paged-window/list-owner.tsx"],"sourcesContent":["import { createContext, useContext, useLayoutEffect, type ReactNode } from \"react\";\n\n/* DX-5084: WHO OWNS THE `role=\"list\"` A PAGED WINDOW SITS IN.\n\n   A board lane puts a `role=\"list\"` around its cards, and a `PagedWindowList` renders\n   inside it. A list may own only listitems (axe `aria-required-children`), so two things\n   the window draws are invalid there:\n   - its root box carrying `aria-busy` (a global ARIA attribute makes a role-less box a\n     non-generic, non-listitem child), and\n   - a page's `role=\"alert\"` retry row.\n   The lane provides this context. The window then reports \"I am loading\" to the lane,\n   which puts `aria-busy` on the list element itself (valid there, and the element an\n   assistive technology reads as the busy region), and wraps the retry row in a\n   `role=\"listitem\"`. Outside a lane there is no owner: `aria-busy` stays on the window's\n   own root and the retry row stands alone. */\nexport interface ListOwner {\n  /** Called with +1 when a window under this list starts loading and -1 when it stops. */\n  reportBusy: (delta: 1 | -1) => void;\n}\n\nconst ListOwnerContext = createContext<ListOwner | null>(null);\n\nexport function ListOwnerProvider({ value, children }: { value: ListOwner; children: ReactNode }) {\n  return <ListOwnerContext.Provider value={value}>{children}</ListOwnerContext.Provider>;\n}\n\nexport function useListOwner(): ListOwner | null {\n  return useContext(ListOwnerContext);\n}\n\n/** Tell the enclosing list (if any) whether this window is loading. */\nexport function useReportBusy(owner: ListOwner | null, busy: boolean): void {\n  /* A layout effect: the lane's `aria-busy` must land in the SAME commit as the loading\n     state it reports, because capture tools poll `[aria-busy=\"true\"]` and a passive\n     effect would leave a painted frame of loading content that reads as idle. */\n  useLayoutEffect(() => {\n    if (!owner || !busy) return;\n    owner.reportBusy(1);\n    return () => owner.reportBusy(-1);\n  }, [owner, busy]);\n}\n"],"names":["ListOwnerContext","createContext","ListOwnerProvider","value","children","jsx","useListOwner","useContext","useReportBusy","owner","busy","useLayoutEffect"],"mappings":";;AAoBA,MAAMA,IAAmBC,EAAgC,IAAI;AAEtD,SAASC,EAAkB,EAAE,OAAAC,GAAO,UAAAC,KAAuD;AAChG,SAAO,gBAAAC,EAACL,EAAiB,UAAjB,EAA0B,OAAAG,GAAe,UAAAC,EAAA,CAAS;AAC5D;AAEO,SAASE,IAAiC;AAC/C,SAAOC,EAAWP,CAAgB;AACpC;AAGO,SAASQ,EAAcC,GAAyBC,GAAqB;AAI1E,EAAAC,EAAgB,MAAM;AACpB,QAAI,GAACF,KAAS,CAACC;AACf,aAAAD,EAAM,WAAW,CAAC,GACX,MAAMA,EAAM,WAAW,EAAE;AAAA,EAClC,GAAG,CAACA,GAAOC,CAAI,CAAC;AAClB;"}