noteloom 0.3.2 → 0.4.0

package/dist/shared/VersionHistory-Bg6fufP5.js

@@ -0,0 +1,1120 @@
+import { jsxs as b, Fragment as D, jsx as k } from "react/jsx-runtime";
+import { useState as v, useCallback as Z, useEffect as M, useRef as H, useMemo as $ } from "react";
+import { createPortal as tt } from "react-dom";
+import { g as et, O as m, p as st, q as nt, t as it, f as rt, e as ot, v as ct, c as dt, d as at, w as lt, x as ht, y as ut, o as mt, r as ft, s as kt, m as bt, n as pt, i as yt, j as It, z, l as K, k as _t, a as gt, A as wt, B as Tt, D as Rt, X as Et, R as St } from "./icons-C1_s0jKK.js";
+import { f as Ct, c as V, b as Ot } from "./indexedDbPersistence-BKlGPFTP.js";
+import { c as q, r as vt, s as J } from "./serialize-T9Odwx24.js";
+import { g as xt, H as Pt, F as At, L } from "./fieldRegistry-PjJWXFoB.js";
+import { C as j, f as Mt } from "./CommentAvatar-TKqsM8vG.js";
+function Nt(a, t) {
+  const i = Array.from(a ?? ""), e = Array.from(t ?? "");
+  let s = 0;
+  const n = Math.min(i.length, e.length);
+  for (; s < n && i[s] === e[s]; ) s += 1;
+  let r = i.length, o = e.length;
+  for (; r > s && o > s && i[r - 1] === e[o - 1]; )
+    r -= 1, o -= 1;
+  return { start: s, oldEnd: r, newEnd: o, oldChars: i, newChars: e };
+}
+const B = "$fieldTypes", R = "$comments", O = "$people";
+class F {
+  constructor(t) {
+    this.blocks = new Map(((t == null ? void 0 : t.blocks) ?? []).map((i) => [i.id, i])), this.runs = new Map(((t == null ? void 0 : t.runs) ?? []).map((i) => [i.id, i])), this.rootId = (t == null ? void 0 : t.rootId) ?? null, this.fieldTypes = new Map(((t == null ? void 0 : t.fieldTypes) ?? []).map((i) => [i.id, i])), this._fieldTypesSnapshot = null, this.comments = new Map(((t == null ? void 0 : t.comments) ?? []).map((i) => [i.id, i])), this._commentsSnapshot = null, this.people = new Map(((t == null ? void 0 : t.people) ?? []).map((i) => [i.id, i])), this._peopleSnapshot = null, this._listeners = /* @__PURE__ */ new Map(), this._globalListeners = /* @__PURE__ */ new Set(), this._peerId = xt(), this._clock = new Pt(this._peerId), this._fieldClocks = new At(), this._orders = /* @__PURE__ */ new Map(), this._runOrders = /* @__PURE__ */ new Map(), this._runChars = /* @__PURE__ */ new Map(), this._runValueSnapshots = /* @__PURE__ */ new Map();
+  }
+  /** Lazily seeds a block's ordering CRDT state from its current (plain-array) contentIds the first time it's touched. */
+  _getOrder(t) {
+    let i = this._orders.get(t);
+    if (!i) {
+      const e = this.blocks.get(t);
+      i = L.fromArray((e == null ? void 0 : e.contentIds) ?? [], { peerId: "legacy" }), this._orders.set(t, i);
+    }
+    return i;
+  }
+  /**
+   * Lazily seeds a run's character-ordering CRDT state from its current
+   * (plain-string) value the first time it's touched. Unlike blocks,
+   * individual characters have no pre-existing stable id of their own —
+   * BUT a fresh *random* one (genId()) can't be minted here the way
+   * `_getRunOrder`'s block equivalent doesn't need to, because a block's
+   * seed ids (its real `.id`s) are already identical on every peer (the
+   * document itself was already synced); a run's *characters* aren't
+   * separately synced at all, only its plain `value` string is. Two peers
+   * independently lazy-seeding the same pre-existing text with random ids
+   * would each invent a DIFFERENT id for "the same" character, so a
+   * remote edit's `afterId` (anchored to the sender's random id) would
+   * never resolve on the receiving side. Fix: ids for this initial seed
+   * are DETERMINISTIC — `` `${runId}:legacyChar:${index}` `` — so any peer
+   * seeding from the same starting string (guaranteed, since a peer only
+   * ever needs to seed a run it has already received the full document
+   * for) always mints the identical ids independently, with no
+   * coordination required. Only ever used for this one-time seed; every
+   * character inserted after that (by typing, on any peer) gets a real
+   * `genId()`.
+   */
+  _getRunOrder(t) {
+    let i = this._runOrders.get(t);
+    if (!i) {
+      const e = this.runs.get(t), s = /* @__PURE__ */ new Map();
+      i = new L();
+      let n = null, r = 0;
+      for (const o of Array.from((e == null ? void 0 : e.value) ?? "")) {
+        const c = `${t}:legacyChar:${r}`;
+        s.set(c, o), i.insert(c, n, { wallTime: 0, counter: 0, peerId: "legacy" }, "legacy"), n = c, r += 1;
+      }
+      this._runOrders.set(t, i), this._runChars.set(t, s);
+    }
+    return i;
+  }
+  /** Materializes a run's current text from its character CRDT, memoized until that run's char order next changes. */
+  _materializeRunValue(t) {
+    let i = this._runValueSnapshots.get(t);
+    if (i === void 0) {
+      const e = this._getRunOrder(t), s = this._runChars.get(t);
+      i = e.toArray().map((n) => s.get(n)).join(""), this._runValueSnapshots.set(t, i);
+    }
+    return i;
+  }
+  /**
+   * Diffs `newValue` against the run's current materialized value (common
+   * prefix/suffix, code-point aware — see diffCodePoints) and translates
+   * only the changed region into character-CRDT insert/delete ops. One
+   * shared clock covers the whole edit — matching how a single
+   * INSERT_BLOCK/REMOVE_BLOCK op already uses one tick() each — since
+   * these characters are never independently reordered relative to each
+   * other regardless of how many ticks they'd otherwise get.
+   */
+  _editRunText(t, i) {
+    const e = this._materializeRunValue(t), { start: s, oldEnd: n, newEnd: r, newChars: o } = Nt(e, i), c = this._getRunOrder(t), d = this._runChars.get(t), l = c.toArray(), h = this._clock.tick(), u = [];
+    for (let w = s; w < n; w += 1) {
+      const g = l[w];
+      c.delete(g, h), u.push({ id: g, clock: h });
+    }
+    const f = [];
+    let T = s > 0 ? l[s - 1] : null;
+    for (let w = s; w < r; w += 1) {
+      const g = et(), _ = o[w];
+      d.set(g, _), c.insert(g, T, h, this._peerId), f.push({ id: g, char: _, afterId: T, clock: h }), T = g;
+    }
+    return this._runValueSnapshots.delete(t), { oldValue: e, insertedChars: f, deletedCharIds: u, clock: h };
+  }
+  /**
+   * Replays a previously-resolved text edit's EXACT character ids (from
+   * `op._charEdit`, cached on first application — see the UPDATE_RUN case)
+   * instead of re-diffing and minting fresh ones. Needed for `History`'s
+   * redo, which replays the same op OBJECT a second time: re-diffing would
+   * mint a brand-new set of ids rather than restoring the ones the
+   * matching undo had only tombstoned, breaking a subsequent undo/redo
+   * cycle (mirrors how INSERT_BLOCK's own handler restores an existing
+   * slot via `order.restore()` on redo instead of creating a new one,
+   * since a block's id is already stable across replay — characters have
+   * no such built-in stable id, so this cache is what gives them one).
+   */
+  _replayRunTextEdit(t, i) {
+    const e = this._getRunOrder(t), s = this._runChars.get(t);
+    for (const n of i.insertedChars)
+      e.has(n.id) ? e.restore(n.id) : (s.set(n.id, n.char), e.insert(n.id, n.afterId, n.clock, this._peerId));
+    for (const n of i.deletedCharIds) e.delete(n.id, n.clock);
+    this._runValueSnapshots.delete(t);
+  }
+  getBlock(t) {
+    return this.blocks.get(t);
+  }
+  getRun(t) {
+    return this.runs.get(t);
+  }
+  /**
+   * Persisted, user-created custom select field types (static only) —
+   * insertion order. Returns the SAME array reference across calls unless
+   * a fieldTypes op ran in between — required for useSyncExternalStore
+   * (see useFieldTypes), same reference-stability contract as
+   * getBlock/getRun.
+   */
+  getFieldTypes() {
+    return this._fieldTypesSnapshot || (this._fieldTypesSnapshot = [...this.fieldTypes.values()]), this._fieldTypesSnapshot;
+  }
+  getFieldType(t) {
+    return this.fieldTypes.get(t);
+  }
+  /**
+   * Every comment thread — insertion order. Returns the SAME array
+   * reference across calls unless a comments op ran in between — required
+   * for useSyncExternalStore (see useComments), same contract as
+   * getFieldTypes.
+   */
+  getComments() {
+    return this._commentsSnapshot || (this._commentsSnapshot = [...this.comments.values()]), this._commentsSnapshot;
+  }
+  getComment(t) {
+    return this.comments.get(t);
+  }
+  /**
+   * The document's own people list (see src/people/people.js's addPerson —
+   * the documented entry point, and createSelectFieldType's "Assignee"
+   * usage, which sources its options from this instead of any device-local
+   * list, so every collaborator on the same document sees the same
+   * assignable people). Same reference-stability contract as getFieldTypes/
+   * getComments — required for useSyncExternalStore (see usePeople).
+   */
+  getPeople() {
+    return this._peopleSnapshot || (this._peopleSnapshot = [...this.people.values()]), this._peopleSnapshot;
+  }
+  getPerson(t) {
+    return this.people.get(t);
+  }
+  /**
+   * Every run id in the whole document, regardless of reachability from
+   * the root — used by removeCommentMarkEverywhere (see
+   * src/comments/commentMarks.js) to strip a deleted comment's id from
+   * any run that still carries it, without needing a separate index.
+   */
+  getAllRunIds() {
+    return [...this.runs.keys()];
+  }
+  getRootId() {
+    return this.rootId;
+  }
+  subscribe(t, i) {
+    let e = this._listeners.get(t);
+    return e || (e = /* @__PURE__ */ new Set(), this._listeners.set(t, e)), e.add(i), () => {
+      e.delete(i), e.size === 0 && this._listeners.delete(t);
+    };
+  }
+  /**
+   * Fires on every mutation, local or remote (applyOperation and
+   * applyRemoteOperation both funnel through _notify), regardless of
+   * which specific id(s) changed — unlike subscribe(id, ...), which is
+   * scoped to one id for render-isolation purposes. Meant for
+   * whole-document concerns like auto-persistence, not for UI rendering
+   * (a component re-rendering on every edit anywhere defeats the point of
+   * per-id subscriptions).
+   */
+  subscribeAll(t) {
+    return this._globalListeners.add(t), () => this._globalListeners.delete(t);
+  }
+  _notify(t) {
+    for (const i of t) {
+      const e = this._listeners.get(i);
+      if (e)
+        for (const s of [...e]) s();
+    }
+    if (this._globalListeners.size > 0)
+      for (const i of [...this._globalListeners]) i();
+  }
+  /** Recursively collects a block (or run) and everything reachable under it. */
+  _captureSubtree(t) {
+    const i = [], e = [], s = (n) => {
+      var o;
+      if (this.runs.has(n)) {
+        e.push(this.runs.get(n));
+        return;
+      }
+      const r = this.blocks.get(n);
+      if (r) {
+        i.push(r);
+        for (const c of r.contentIds) s(c);
+        for (const c of ((o = r.props) == null ? void 0 : o.titleRunIds) ?? []) s(c);
+      }
+    };
+    return s(t), { blocks: i, runs: e };
+  }
+  _deleteSubtree(t) {
+    const i = (e) => {
+      var n;
+      if (this.runs.has(e)) {
+        this.runs.delete(e);
+        return;
+      }
+      const s = this.blocks.get(e);
+      if (s) {
+        for (const r of s.contentIds) i(r);
+        for (const r of ((n = s.props) == null ? void 0 : n.titleRunIds) ?? []) i(r);
+        this.blocks.delete(e);
+      }
+    };
+    i(t);
+  }
+  /**
+   * Applies one operation, mutating only the affected map entries, and
+   * returns the inverse operation (computed from state captured *before* the
+   * mutation, per-op — never reconstructed afterward).
+   */
+  applyOperation(t) {
+    var i;
+    switch (t.type) {
+      case m.UPDATE_RUN: {
+        const e = this.runs.get(t.id), s = Object.keys(t.patch);
+        if (s.length === 1 && s[0] === "value") {
+          let o = t._charEdit;
+          if (o)
+            this._replayRunTextEdit(t.id, o);
+          else {
+            const { oldValue: d, insertedChars: l, deletedCharIds: h, clock: u } = this._editRunText(
+              t.id,
+              t.patch.value
+            );
+            o = { oldValue: d, insertedChars: l, deletedCharIds: h, clock: u }, t._charEdit = o;
+          }
+          const c = this._materializeRunValue(t.id);
+          return this.runs.set(t.id, { ...e, value: c }), this._lastEnvelope = {
+            kind: "runTextEdit",
+            runId: t.id,
+            insertedChars: o.insertedChars,
+            deletedCharIds: o.deletedCharIds,
+            clock: o.clock
+          }, this._notify([t.id]), z(
+            t.id,
+            o.insertedChars.map((d) => d.id),
+            // undo: tombstone what was just inserted...
+            o.deletedCharIds.map((d) => d.id),
+            // ...and restore what was just deleted
+            o.oldValue
+            // cosmetic-only, for History's caret restoration/change log -- see editRunChars's own doc comment
+          );
+        }
+        const n = {}, r = {};
+        for (const o of s)
+          n[o] = e[o], r[o] = this._clock.tick(), this._fieldClocks.recordLocal(t.id, o, r[o]);
+        return this.runs.set(t.id, { ...e, ...t.patch }), this._lastEnvelope = {
+          kind: "fieldWrite",
+          target: "run",
+          id: t.id,
+          patch: t.patch,
+          clocks: r
+        }, this._notify([t.id]), K(t.id, n);
+      }
+      case m.EDIT_RUN_CHARS: {
+        const e = this._getRunOrder(t.id), s = this._clock.tick();
+        for (const o of t.tombstoneIds) e.delete(o, s);
+        for (const o of t.restoreIds) e.restore(o);
+        this._runValueSnapshots.delete(t.id);
+        const n = this.runs.get(t.id), r = this._materializeRunValue(t.id);
+        return this.runs.set(t.id, { ...n, value: r }), this._lastEnvelope = {
+          kind: "runCharEdit",
+          runId: t.id,
+          tombstoneIds: t.tombstoneIds,
+          restoreIds: t.restoreIds,
+          clock: s
+        }, this._notify([t.id]), z(t.id, t.restoreIds, t.tombstoneIds);
+      }
+      case m.UPDATE_BLOCK_PROPS: {
+        const e = this.blocks.get(t.id), s = {}, n = {};
+        for (const r of Object.keys(t.patch))
+          s[r] = e.props[r], n[r] = this._clock.tick(), this._fieldClocks.recordLocal(t.id, `props.${r}`, n[r]);
+        return this.blocks.set(t.id, { ...e, props: { ...e.props, ...t.patch } }), this._lastEnvelope = {
+          kind: "fieldWrite",
+          target: "blockProps",
+          id: t.id,
+          patch: t.patch,
+          clocks: n
+        }, this._notify([t.id]), It(t.id, s);
+      }
+      case m.CHANGE_BLOCK_TYPE: {
+        const e = this.blocks.get(t.id), s = e.type, n = e.props, r = this._clock.tick();
+        return this._fieldClocks.recordLocal(t.id, "type", r), this.blocks.set(t.id, { ...e, type: t.blockType, props: t.props }), this._lastEnvelope = {
+          kind: "fieldWrite",
+          target: "blockType",
+          id: t.id,
+          blockType: t.blockType,
+          props: t.props,
+          clock: r
+        }, this._notify([t.id]), yt(t.id, s, n);
+      }
+      case m.INSERT_BLOCK: {
+        if (t.subtree) {
+          for (const n of t.subtree.blocks) this.blocks.set(n.id, n);
+          for (const n of t.subtree.runs) this.runs.set(n.id, n);
+        } else
+          this.blocks.set(t.block.id, t.block);
+        const e = this.blocks.get(t.parentId), s = this._getOrder(t.parentId);
+        if (s.has(t.block.id))
+          s.restore(t.block.id);
+        else {
+          const n = s.toArray(), r = t.index ?? n.length, o = r > 0 ? n[r - 1] : null;
+          s.insert(t.block.id, o, this._clock.tick(), this._peerId);
+        }
+        return this.blocks.set(t.parentId, { ...e, contentIds: s.toArray() }), this._lastEnvelope = {
+          kind: "insertSlot",
+          parentId: t.parentId,
+          blockId: t.block.id,
+          slot: s.getSlot(t.block.id),
+          subtree: t.subtree ?? { blocks: [t.block], runs: [] }
+        }, this._notify([t.block.id, t.parentId]), pt(t.block.id);
+      }
+      case m.REMOVE_BLOCK: {
+        const e = this.blocks.get(t.id), s = e.parentId, n = this.blocks.get(s), r = this._getOrder(s), o = r.toArray().indexOf(t.id), c = this._captureSubtree(t.id);
+        this._deleteSubtree(t.id);
+        const d = this._clock.tick();
+        return r.delete(t.id, d), this.blocks.set(s, { ...n, contentIds: r.toArray() }), this._lastEnvelope = { kind: "deleteSlot", parentId: s, blockId: t.id, clock: d }, this._notify([s]), { type: m.INSERT_BLOCK, block: e, parentId: s, index: o, subtree: c };
+      }
+      case m.MOVE_BLOCK: {
+        const s = this.blocks.get(t.id).parentId, n = this._getOrder(s), r = n.toArray().indexOf(t.id);
+        n.delete(t.id, this._clock.tick()), this.blocks.set(s, {
+          ...this.blocks.get(s),
+          contentIds: n.toArray()
+        });
+        const o = this._getOrder(t.toParentId), c = o.toArray(), d = t.toIndex ?? c.length, l = d > 0 ? c[d - 1] : null, h = this._clock.tick();
+        o.has(t.id) ? o.move(t.id, l, h, this._peerId) : o.insert(t.id, l, h, this._peerId), this.blocks.set(t.toParentId, {
+          ...this.blocks.get(t.toParentId),
+          contentIds: o.toArray()
+        }), this.blocks.set(t.id, { ...this.blocks.get(t.id), parentId: t.toParentId }), this._lastEnvelope = {
+          kind: "moveSlot",
+          fromParentId: s,
+          toParentId: t.toParentId,
+          blockId: t.id,
+          slot: o.getSlot(t.id)
+        };
+        const u = /* @__PURE__ */ new Set([t.id, s, t.toParentId]);
+        return this._notify(u), bt(t.id, s, r);
+      }
+      case m.SET_BLOCK_CONTENT_IDS: {
+        const e = this.blocks.get(t.blockId), s = e.contentIds;
+        return this.blocks.set(t.blockId, { ...e, contentIds: t.contentIds }), this._orders.set(t.blockId, L.fromArray(t.contentIds, { peerId: "legacy" })), this._lastEnvelope = null, this._notify([t.blockId]), kt(t.blockId, s);
+      }
+      case m.REPLACE_RUN_SPAN: {
+        const e = this.blocks.get(t.blockId), s = e.contentIds.indexOf(t.oldRunIds[0]) !== -1, n = s ? e.contentIds : ((i = e.props) == null ? void 0 : i.titleRunIds) ?? [], r = n.indexOf(t.oldRunIds[0]), o = t.oldRunIds.map((d) => this.runs.get(d));
+        for (const d of t.oldRunIds) this.runs.delete(d);
+        for (const d of t.newRuns) this.runs.set(d.id, d);
+        const c = [...n];
+        return c.splice(r, t.oldRunIds.length, ...t.newRuns.map((d) => d.id)), s ? this.blocks.set(t.blockId, { ...e, contentIds: c }) : this.blocks.set(t.blockId, {
+          ...e,
+          props: { ...e.props, titleRunIds: c }
+        }), this._lastEnvelope = null, this._notify([t.blockId, ...t.oldRunIds, ...t.newRuns.map((d) => d.id)]), ft(
+          t.blockId,
+          t.newRuns.map((d) => d.id),
+          o
+        );
+      }
+      case m.SET_BLOCK_RUNS: {
+        const e = this.blocks.get(t.blockId), s = e.props && "titleRunIds" in e.props, n = s ? e.props.titleRunIds : e.contentIds, r = n.map((c) => this.runs.get(c)).filter(Boolean);
+        for (const c of n) this.runs.delete(c);
+        for (const c of t.runs) this.runs.set(c.id, c);
+        const o = t.runs.map((c) => c.id);
+        return s ? this.blocks.set(t.blockId, {
+          ...e,
+          props: { ...e.props, titleRunIds: o }
+        }) : this.blocks.set(t.blockId, { ...e, contentIds: o }), this._lastEnvelope = null, this._notify([t.blockId, ...n, ...o]), mt(t.blockId, r);
+      }
+      case m.ADD_FIELD_TYPE:
+        return this.fieldTypes.set(t.fieldType.id, t.fieldType), this._fieldTypesSnapshot = null, this._notify([B]), ut(t.fieldType.id);
+      case m.UPDATE_FIELD_TYPE: {
+        const e = this.fieldTypes.get(t.id), s = {};
+        for (const n of Object.keys(t.patch)) s[n] = e[n];
+        return this.fieldTypes.set(t.id, { ...e, ...t.patch }), this._fieldTypesSnapshot = null, this._notify([B]), ht(t.id, s);
+      }
+      case m.REMOVE_FIELD_TYPE: {
+        const e = this.fieldTypes.get(t.id);
+        return this.fieldTypes.delete(t.id), this._fieldTypesSnapshot = null, this._notify([B]), lt(e);
+      }
+      case m.ADD_COMMENT_THREAD:
+        return this.comments.set(t.thread.id, t.thread), this._commentsSnapshot = null, this._lastEnvelope = { kind: "commentWrite", op: "addThread", thread: t.thread }, this._notify([R]), at(t.thread.id);
+      case m.REMOVE_COMMENT_THREAD: {
+        const e = this.comments.get(t.commentId);
+        return this.comments.delete(t.commentId), this._commentsSnapshot = null, this._lastEnvelope = { kind: "commentWrite", op: "removeThread", commentId: t.commentId }, this._notify([R]), dt(e);
+      }
+      case m.ADD_COMMENT_REPLY: {
+        const e = this.comments.get(t.commentId);
+        return this.comments.set(t.commentId, { ...e, messages: [...e.messages, t.message] }), this._commentsSnapshot = null, this._lastEnvelope = {
+          kind: "commentWrite",
+          op: "addReply",
+          commentId: t.commentId,
+          message: t.message
+        }, this._notify([R]), ct(t.commentId, t.message.id);
+      }
+      case m.REMOVE_COMMENT_REPLY: {
+        const e = this.comments.get(t.commentId), s = e.messages.find((n) => n.id === t.messageId);
+        return this.comments.set(t.commentId, {
+          ...e,
+          messages: e.messages.filter((n) => n.id !== t.messageId)
+        }), this._commentsSnapshot = null, this._lastEnvelope = {
+          kind: "commentWrite",
+          op: "removeReply",
+          commentId: t.commentId,
+          messageId: t.messageId
+        }, this._notify([R]), ot(t.commentId, s);
+      }
+      case m.RESOLVE_COMMENT: {
+        const e = this.comments.get(t.commentId), s = e.resolved;
+        return this.comments.set(t.commentId, { ...e, resolved: t.resolved }), this._commentsSnapshot = null, this._lastEnvelope = {
+          kind: "commentWrite",
+          op: "resolve",
+          commentId: t.commentId,
+          resolved: t.resolved
+        }, this._notify([R]), rt(t.commentId, s);
+      }
+      case m.ADD_PERSON:
+        return this.people.set(t.person.id, t.person), this._peopleSnapshot = null, this._lastEnvelope = { kind: "peopleWrite", op: "add", person: t.person }, this._notify([O]), it(t.person.id);
+      case m.UPDATE_PERSON: {
+        const e = this.people.get(t.id), s = {};
+        for (const n of Object.keys(t.patch)) s[n] = e[n];
+        return this.people.set(t.id, { ...e, ...t.patch }), this._peopleSnapshot = null, this._lastEnvelope = { kind: "peopleWrite", op: "update", id: t.id, patch: t.patch }, this._notify([O]), nt(t.id, s);
+      }
+      case m.REMOVE_PERSON: {
+        const e = this.people.get(t.id);
+        return this.people.delete(t.id), this._peopleSnapshot = null, this._lastEnvelope = { kind: "peopleWrite", op: "remove", id: t.id }, this._notify([O]), st(e);
+      }
+      default:
+        throw new Error(`Unknown operation type: ${t.type}`);
+    }
+  }
+  /** Applies a batch as one transaction: all mutations first, one notify pass, one combined inverse list. */
+  applyOperations(t) {
+    return t.map((i) => this.applyOperation(i));
+  }
+  /**
+   * The CRDT-native wire envelope for whatever `applyOperation` just did —
+   * read this immediately after each call to broadcast the change to
+   * other peers. `null` for op types with no CRDT-safe representation yet
+   * (the coarse resync ops: setBlockContentIds/replaceRunSpan/
+   * setBlockRuns/fieldType ops) — those remain local-only in this phase.
+   */
+  getLastEnvelope() {
+    return this._lastEnvelope;
+  }
+  /**
+   * Applies a change received from another peer. Deliberately separate
+   * from `applyOperation`/`History.perform` — a remote change must never
+   * enter the local undo stack (only `perform`/`performBatch` push onto
+   * it), so this method is the only way for a remote envelope to reach
+   * the store. Idempotent and order-independent per envelope kind: safe
+   * to call more than once, or with envelopes arriving out of order.
+   */
+  applyRemoteOperation(t) {
+    var i, e;
+    if (t)
+      switch (t.kind) {
+        case "insertSlot": {
+          for (const r of t.subtree.blocks)
+            this.blocks.has(r.id) || this.blocks.set(r.id, r);
+          for (const r of t.subtree.runs) this.runs.has(r.id) || this.runs.set(r.id, r);
+          const s = this._getOrder(t.parentId);
+          s.merge([t.slot]);
+          const n = this.blocks.get(t.parentId);
+          this.blocks.set(t.parentId, { ...n, contentIds: s.toArray() }), this._clock.receive(t.slot.clock), this._notify([t.blockId, t.parentId]);
+          return;
+        }
+        case "deleteSlot": {
+          const s = this._getOrder(t.parentId);
+          this.blocks.has(t.blockId) && this._deleteSubtree(t.blockId), s.delete(t.blockId, t.clock), t.clock && this._clock.receive(t.clock);
+          const n = this.blocks.get(t.parentId);
+          this.blocks.set(t.parentId, { ...n, contentIds: s.toArray() }), this._notify([t.parentId]);
+          return;
+        }
+        case "moveSlot": {
+          const s = this._getOrder(t.fromParentId);
+          s.delete(t.blockId, (i = t.slot) == null ? void 0 : i.clock), this.blocks.set(t.fromParentId, {
+            ...this.blocks.get(t.fromParentId),
+            contentIds: s.toArray()
+          });
+          const n = this._getOrder(t.toParentId), r = n.has(t.blockId);
+          n.merge([t.slot]), r && n.move(
+            t.blockId,
+            t.slot.originId,
+            t.slot.clock,
+            t.slot.peerId
+          ), this.blocks.set(t.toParentId, {
+            ...this.blocks.get(t.toParentId),
+            contentIds: n.toArray()
+          }), this.blocks.has(t.blockId) && this.blocks.set(t.blockId, {
+            ...this.blocks.get(t.blockId),
+            parentId: t.toParentId
+          }), this._clock.receive(t.slot.clock), this._notify([t.blockId, t.fromParentId, t.toParentId]);
+          return;
+        }
+        case "fieldWrite": {
+          if (t.target === "run") {
+            const s = this.runs.get(t.id);
+            if (s) {
+              const n = {};
+              for (const r of Object.keys(t.patch)) {
+                const o = t.clocks[r];
+                this._fieldClocks.shouldApplyRemote(t.id, r, o) && (n[r] = t.patch[r], this._fieldClocks.recordRemote(t.id, r, o));
+              }
+              Object.keys(n).length > 0 && (this.runs.set(t.id, { ...s, ...n }), this._notify([t.id]));
+            }
+          } else if (t.target === "blockProps") {
+            const s = this.blocks.get(t.id);
+            if (s) {
+              const n = {};
+              for (const r of Object.keys(t.patch)) {
+                const o = t.clocks[r];
+                this._fieldClocks.shouldApplyRemote(t.id, `props.${r}`, o) && (n[r] = t.patch[r], this._fieldClocks.recordRemote(t.id, `props.${r}`, o));
+              }
+              Object.keys(n).length > 0 && (this.blocks.set(t.id, { ...s, props: { ...s.props, ...n } }), this._notify([t.id]));
+            }
+          } else if (t.target === "blockType") {
+            const s = this.blocks.get(t.id);
+            s && this._fieldClocks.shouldApplyRemote(t.id, "type", t.clock) && (this._fieldClocks.recordRemote(t.id, "type", t.clock), this.blocks.set(t.id, {
+              ...s,
+              type: t.blockType,
+              props: t.props
+            }), this._notify([t.id]));
+          }
+          for (const s of Object.values(t.clocks ?? {})) this._clock.receive(s);
+          t.clock && this._clock.receive(t.clock);
+          return;
+        }
+        case "runTextEdit": {
+          const s = this._getRunOrder(t.runId), n = this._runChars.get(t.runId);
+          for (const o of t.insertedChars)
+            s.has(o.id) || n.set(o.id, o.char), s.insert(o.id, o.afterId, o.clock, (e = o.clock) == null ? void 0 : e.peerId);
+          for (const o of t.deletedCharIds) s.delete(o.id, o.clock);
+          this._runValueSnapshots.delete(t.runId);
+          const r = this.runs.get(t.runId);
+          r && (this.runs.set(t.runId, {
+            ...r,
+            value: this._materializeRunValue(t.runId)
+          }), this._notify([t.runId])), this._clock.receive(t.clock);
+          return;
+        }
+        case "runCharEdit": {
+          const s = this._getRunOrder(t.runId);
+          for (const r of t.tombstoneIds) s.delete(r, t.clock);
+          for (const r of t.restoreIds) s.restore(r);
+          this._runValueSnapshots.delete(t.runId);
+          const n = this.runs.get(t.runId);
+          n && (this.runs.set(t.runId, {
+            ...n,
+            value: this._materializeRunValue(t.runId)
+          }), this._notify([t.runId])), this._clock.receive(t.clock);
+          return;
+        }
+        case "commentWrite": {
+          if (t.op === "addThread")
+            this.comments.has(t.thread.id) || (this.comments.set(t.thread.id, t.thread), this._commentsSnapshot = null, this._notify([R]));
+          else if (t.op === "removeThread")
+            this.comments.delete(t.commentId) && (this._commentsSnapshot = null, this._notify([R]));
+          else if (t.op === "addReply") {
+            const s = this.comments.get(t.commentId);
+            s && !s.messages.some((n) => n.id === t.message.id) && (this.comments.set(t.commentId, {
+              ...s,
+              messages: [...s.messages, t.message]
+            }), this._commentsSnapshot = null, this._notify([R]));
+          } else if (t.op === "removeReply") {
+            const s = this.comments.get(t.commentId);
+            s && s.messages.some((n) => n.id === t.messageId) && (this.comments.set(t.commentId, {
+              ...s,
+              messages: s.messages.filter((n) => n.id !== t.messageId)
+            }), this._commentsSnapshot = null, this._notify([R]));
+          } else if (t.op === "resolve") {
+            const s = this.comments.get(t.commentId);
+            s && (this.comments.set(t.commentId, { ...s, resolved: t.resolved }), this._commentsSnapshot = null, this._notify([R]));
+          }
+          return;
+        }
+        case "peopleWrite": {
+          if (t.op === "add")
+            this.people.has(t.person.id) || (this.people.set(t.person.id, t.person), this._peopleSnapshot = null, this._notify([O]));
+          else if (t.op === "update") {
+            const s = this.people.get(t.id);
+            s && (this.people.set(t.id, { ...s, ...t.patch }), this._peopleSnapshot = null, this._notify([O]));
+          } else t.op === "remove" && this.people.delete(t.id) && (this._peopleSnapshot = null, this._notify([O]));
+          return;
+        }
+        default:
+          throw new Error(`Unknown remote envelope kind: ${t.kind}`);
+      }
+  }
+  /** Total tombstoned (deleted but still retained) slots across every parent's ordering CRDT and every run's character CRDT — a cheap signal for whether pruneTombstones() is worth calling, or just for observing growth over a long session. */
+  getTombstoneCount() {
+    let t = 0;
+    for (const i of this._orders.values()) t += i.tombstoneCount();
+    for (const i of this._runOrders.values()) t += i.tombstoneCount();
+    return t;
+  }
+  /**
+   * Permanently removes tombstones older than `maxAgeMs` (default 24h)
+   * across every parent's ordering CRDT — see ListCrdtState.pruneTombstones
+   * for the safety argument this relies on (this package's reconnect model
+   * always resyncs via a full snapshot, never a replayed op log, which is
+   * what makes a time-based threshold safe here specifically). Opt-in:
+   * never called automatically by anything in this store — call it
+   * yourself on whatever schedule fits (see createPeriodicTombstoneGC for
+   * a ready-made "just handle it" helper). Returns the number of slots
+   * removed.
+   */
+  pruneTombstones({ maxAgeMs: t = 24 * 60 * 60 * 1e3, now: i = Date.now() } = {}) {
+    const e = { wallTime: i - t, counter: 0, peerId: "" };
+    let s = 0;
+    for (const n of this._orders.values()) s += n.pruneTombstones(e);
+    for (const n of this._runOrders.values()) s += n.pruneTombstones(e);
+    return s;
+  }
+  toJSON() {
+    return {
+      blocks: [...this.blocks.values()],
+      runs: [...this.runs.values()],
+      rootId: this.rootId,
+      fieldTypes: [...this.fieldTypes.values()],
+      comments: [...this.comments.values()],
+      people: [...this.people.values()]
+    };
+  }
+  static fromJSON(t) {
+    return new F(t);
+  }
+}
+function Dt(a, t) {
+  if (typeof a.performBatch == "function") a.performBatch(t);
+  else for (const i of t) a.applyOperation(i);
+}
+function ne(a, t) {
+  return { roots: t.map((i) => q(a, i)) };
+}
+function Lt(a, t, { parentId: i, index: e }) {
+  const s = [];
+  let n = e;
+  for (const r of t.roots) {
+    const { block: o, runs: c, subtreeBlocks: d } = vt(r);
+    o.parentId = i, s.push(_t(o, i, n, { blocks: [o, ...d], runs: c })), n += 1;
+  }
+  Dt(a, s);
+}
+function Bt(a, t) {
+  const i = a.store ?? a;
+  i.blocks = new Map((t.blocks ?? []).map((e) => [e.id, e])), i.runs = new Map((t.runs ?? []).map((e) => [e.id, e])), i.rootId = t.rootId ?? null, i.fieldTypes = new Map((t.fieldTypes ?? []).map((e) => [e.id, e])), i._fieldTypesSnapshot = null, i.comments = new Map((t.comments ?? []).map((e) => [e.id, e])), i._commentsSnapshot = null, i._orders = /* @__PURE__ */ new Map(), i._notify([
+    ...i.blocks.keys(),
+    ...i.runs.keys(),
+    "$fieldTypes",
+    "$comments"
+  ]);
+}
+function ie(a, t) {
+  for (const i of t)
+    a.register(`__blockTemplate:${i.id}`, {
+      component: () => null,
+      isLeaf: !0,
+      slashCommand: {
+        label: i.label,
+        icon: i.icon,
+        keywords: i.keywords ?? [i.label],
+        run(e, { blockId: s, runId: n, sliceStart: r, sliceEnd: o }) {
+          const c = e.getRun(n), d = (c == null ? void 0 : c.value) ?? "";
+          e.applyOperation(
+            K(n, { value: d.slice(0, r) + d.slice(o) })
+          );
+          const l = e.getBlock(s), u = e.getBlock(l.parentId).contentIds.indexOf(s) + 1;
+          Lt(e, i, { parentId: l.parentId, index: u });
+        }
+      }
+    });
+}
+function Vt(a, { pretty: t = !0 } = {}) {
+  const i = a.getRootId(), { blocks: e, runs: s } = q(a, i);
+  return JSON.stringify({ version: 1, rootId: i, blocks: e, runs: s }, null, t ? 2 : 0);
+}
+function X(a, t, i) {
+  const e = a.getBlock(a.getRootId());
+  return e ? J(a, t, e.contentIds, i).html : "";
+}
+function re(a, t, i) {
+  const e = a.getBlock(a.getRootId());
+  return e ? J(a, t, e.contentIds, i).text : "";
+}
+function oe(a, t, i) {
+  return `<html xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:w="urn:schemas-microsoft-com:office:word" xmlns="http://www.w3.org/TR/REC-html40">
+<head>
+<meta charset="utf-8">
+<title>Document</title>
+<!--[if gte mso 9]><xml><w:WordDocument><w:View>Print</w:View><w:DoNotOptimizeForBrowser/></w:WordDocument></xml><![endif]-->
+</head>
+<body>${X(a, t, i)}</body>
+</html>`;
+}
+function ce(a, t, i) {
+  const e = a.getBlock(a.getRootId());
+  if (!e) return "";
+  const s = { store: a, registry: t, inlineRegistry: i }, n = e.contentIds;
+  let r = "", o = null;
+  for (const c of n) {
+    const d = a.getBlock(c), l = t.get(d.type), h = (l.toMarkdown ?? l.toPlainText)(d, s);
+    if (o) {
+      const u = d.type === "listItem" && o.type === "listItem" && !!d.props.ordered == !!o.props.ordered, f = d.type === "blockquote" && o.type === "blockquote";
+      r += u || f ? `
+` : `
+
+`;
+    }
+    r += h, o = d;
+  }
+  return r;
+}
+const Ft = 5 * 60 * 1e3, Ht = 200;
+function $t({
+  store: a,
+  docId: t,
+  idleMs: i = Ft,
+  maxVersions: e = Ht,
+  onSnapshot: s,
+  onError: n
+}) {
+  let r = null, o = a.getHistoryLog().length, c = !1;
+  function d() {
+    r && (clearTimeout(r), r = null);
+  }
+  async function l() {
+    if (d(), !c) return;
+    c = !1;
+    const u = a.getHistoryLog(), f = u.slice(o);
+    if (o = u.length, f.length === 0) return;
+    const T = new Set(f.map((_) => _.id).filter(Boolean)), w = [...new Set(f.map((_) => _.actorId).filter(Boolean))], g = f[f.length - 1].actorId ?? null;
+    try {
+      const _ = JSON.parse(Vt(a)), S = {
+        id: crypto.randomUUID(),
+        docId: t,
+        timestamp: Date.now(),
+        authorId: g,
+        authorIds: w,
+        summary: `${T.size} block${T.size === 1 ? "" : "s"} changed`,
+        doc: _
+      };
+      await Ct(S), s == null || s(S);
+      const y = await V(t);
+      if (y.length > e) {
+        const C = y.slice(e);
+        await Promise.all(C.map((N) => Ot(N.id)));
+      }
+    } catch (_) {
+      n == null || n(_);
+    }
+  }
+  const h = a.subscribeToHistory(() => {
+    c = !0, d(), r = setTimeout(l, i);
+  });
+  return {
+    /** Stops listening. Does NOT flush a final in-progress window -- call `flush()` first if you want that (e.g. right before navigating away). */
+    stop() {
+      d(), h();
+    },
+    /** Closes and saves the current window immediately, without waiting for `idleMs` of inactivity. A no-op if nothing's happened since the last save. */
+    flush: l
+  };
+}
+function zt(a, t) {
+  const i = W(a), e = W(t), s = i.length, n = e.length, r = Array.from({ length: s + 1 }, () => new Uint32Array(n + 1));
+  for (let h = s - 1; h >= 0; h -= 1)
+    for (let u = n - 1; u >= 0; u -= 1)
+      r[h][u] = i[h] === e[u] ? r[h + 1][u + 1] + 1 : Math.max(r[h + 1][u], r[h][u + 1]);
+  const o = [], c = (h, u) => {
+    const f = o[o.length - 1];
+    f && f.type === h ? f.text += u : o.push({ type: h, text: u });
+  };
+  let d = 0, l = 0;
+  for (; d < s && l < n; )
+    i[d] === e[l] ? (c("equal", i[d]), d += 1, l += 1) : r[d + 1][l] >= r[d][l + 1] ? (c("removed", i[d]), d += 1) : (c("added", e[l]), l += 1);
+  for (; d < s; )
+    c("removed", i[d]), d += 1;
+  for (; l < n; )
+    c("added", e[l]), l += 1;
+  return o;
+}
+function W(a) {
+  return (a ?? "").match(/\s+|[^\s]+/g) ?? [];
+}
+const jt = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+function A(a) {
+  return a.replace(/[&<>"']/g, (t) => jt[t]);
+}
+function U(a) {
+  const t = new Map(a.blocks.map((r) => [r.id, r])), i = new Map(a.runs.map((r) => [r.id, r])), e = [], s = (r) => r.map((o) => {
+    var c;
+    return ((c = i.get(o)) == null ? void 0 : c.value) ?? "";
+  }).join(""), n = (r) => {
+    var d;
+    const o = t.get(r);
+    if (!o) return;
+    const c = (d = o.props) == null ? void 0 : d.titleRunIds;
+    Array.isArray(c) && c.length > 0 ? e.push({ id: r, text: s(c) }) : o.contentIds.length > 0 && o.contentIds.every((l) => i.has(l)) && e.push({ id: r, text: s(o.contentIds) });
+    for (const l of o.contentIds)
+      i.has(l) || n(l);
+  };
+  return n(a.rootId), e;
+}
+const Y = {
+  rootId: "root",
+  blocks: [{ id: "root", type: "page", parentId: null, contentIds: [], props: {} }],
+  runs: []
+};
+function Wt(a, t) {
+  const i = U(a ?? Y), e = U(t ?? Y), s = new Map(i.map((o) => [o.id, o])), n = new Set(e.map((o) => o.id)), r = [];
+  for (const o of e) {
+    const c = s.get(o.id);
+    if (!c) {
+      const h = A(o.text) || "&nbsp;";
+      r.push(
+        `<p class="be-version-diff-block"><span class="be-version-diff-added">${h}</span></p>`
+      );
+      continue;
+    }
+    if (c.text === o.text) {
+      r.push(`<p class="be-version-diff-block">${A(o.text) || "&nbsp;"}</p>`);
+      continue;
+    }
+    const l = zt(c.text, o.text).map((h) => {
+      const u = A(h.text);
+      return h.type === "added" ? `<span class="be-version-diff-added">${u}</span>` : h.type === "removed" ? `<span class="be-version-diff-removed">${u}</span>` : u;
+    }).join("");
+    r.push(`<p class="be-version-diff-block">${l}</p>`);
+  }
+  for (const o of i)
+    if (!n.has(o.id)) {
+      const c = A(o.text) || "&nbsp;";
+      r.push(
+        `<p class="be-version-diff-block"><span class="be-version-diff-removed">${c}</span></p>`
+      );
+    }
+  return r.length === 0 ? '<p class="be-version-diff-empty">No text changes.</p>' : r.join("");
+}
+function Ut(a) {
+  const [t, i] = v([]), [e, s] = v(!1), n = Z(() => a ? (s(!1), V(a).then((r) => {
+    i(r), s(!0);
+  })) : Promise.resolve(), [a]);
+  return M(() => {
+    if (!a) {
+      i([]), s(!0);
+      return;
+    }
+    let r = !1;
+    return s(!1), V(a).then((o) => {
+      r || (i(o), s(!0));
+    }), () => {
+      r = !0;
+    };
+  }, [a]), { versions: t, isLoaded: e, refresh: n };
+}
+const Yt = 'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
+function Kt(a) {
+  const t = new Date(a), i = /* @__PURE__ */ new Date(), e = (n) => new Date(n.getFullYear(), n.getMonth(), n.getDate()).getTime(), s = Math.round((e(i) - e(t)) / (24 * 60 * 60 * 1e3));
+  return s === 0 ? "Today" : s === 1 ? "Yesterday" : t.toLocaleDateString(void 0, {
+    month: "long",
+    day: "numeric",
+    year: t.getFullYear() !== i.getFullYear() ? "numeric" : void 0
+  });
+}
+function de({ docId: a, idleMs: t, maxVersions: i }) {
+  const e = gt(), s = wt(), n = Tt(), { versions: r, isLoaded: o, refresh: c } = Ut(a), [d, l] = v(!1), [h, u] = v(null), [f, T] = v("changes"), w = H(null), g = H(null);
+  M(() => {
+    if (typeof e.getHistoryLog != "function") return;
+    const p = $t({
+      store: e,
+      docId: a,
+      idleMs: t,
+      maxVersions: i,
+      onSnapshot: c
+    });
+    return () => p.stop();
+  }, [e, a]);
+  function _() {
+    l(!1), u(null), T("changes");
+  }
+  M(() => {
+    if (!d) return;
+    const p = (I) => {
+      I.key === "Escape" && _();
+    };
+    return document.addEventListener("keydown", p), () => document.removeEventListener("keydown", p);
+  }, [d]), M(() => {
+    var p, I, E;
+    if (d) {
+      g.current = document.activeElement;
+      const P = w.current;
+      (p = (P == null ? void 0 : P.querySelector(Yt)) ?? P) == null || p.focus();
+      return;
+    }
+    (E = (I = g.current) == null ? void 0 : I.focus) == null || E.call(I), g.current = null;
+  }, [d]);
+  const S = r.findIndex((p) => p.id === h), y = S >= 0 ? r[S] : null, C = S >= 0 ? r[S + 1] ?? null : null, N = $(() => {
+    if (!y) return "";
+    const p = new F(y.doc);
+    return X(p, s, n);
+  }, [y, s, n]), G = $(() => y ? Wt((C == null ? void 0 : C.doc) ?? null, y.doc) : "", [y, C]);
+  function Q() {
+    y && window.confirm("Restore this version? This replaces the current document.") && (Bt(e, y.doc), _());
+  }
+  const x = [];
+  for (const p of r) {
+    const I = Kt(p.timestamp);
+    let E = x[x.length - 1];
+    (!E || E.label !== I) && (E = { label: I, versions: [] }, x.push(E)), E.versions.push(p);
+  }
+  return /* @__PURE__ */ b(D, { children: [
+    /* @__PURE__ */ b(
+      "button",
+      {
+        type: "button",
+        className: "be-version-history-trigger",
+        onClick: () => l(!0),
+        title: "Version history",
+        children: [
+          /* @__PURE__ */ k(Rt, { size: 15 }),
+          "Version history"
+        ]
+      }
+    ),
+    d && tt(
+      /* @__PURE__ */ b(D, { children: [
+        /* @__PURE__ */ k("div", { className: "be-version-history-backdrop", onClick: _ }),
+        /* @__PURE__ */ b(
+          "div",
+          {
+            ref: w,
+            className: "be-version-history-drawer",
+            role: "dialog",
+            "aria-modal": "true",
+            "aria-label": "Version history",
+            tabIndex: -1,
+            children: [
+              /* @__PURE__ */ b("div", { className: "be-version-history-header", children: [
+                /* @__PURE__ */ k("span", { children: y ? "Preview" : "Version history" }),
+                /* @__PURE__ */ k(
+                  "button",
+                  {
+                    type: "button",
+                    className: "be-version-history-close",
+                    onClick: _,
+                    "aria-label": "Close",
+                    children: /* @__PURE__ */ k(Et, { size: 14 })
+                  }
+                )
+              ] }),
+              y ? /* @__PURE__ */ b("div", { className: "be-version-history-preview", children: [
+                /* @__PURE__ */ b("div", { className: "be-version-history-preview-meta", children: [
+                  /* @__PURE__ */ k(j, { authorId: y.authorId, size: 24 }),
+                  /* @__PURE__ */ b("div", { children: [
+                    /* @__PURE__ */ k("div", { className: "be-version-history-preview-author", children: y.authorId ?? "Unknown" }),
+                    /* @__PURE__ */ b("div", { className: "be-version-history-preview-time", children: [
+                      new Date(y.timestamp).toLocaleString(),
+                      " · ",
+                      y.summary
+                    ] })
+                  ] })
+                ] }),
+                /* @__PURE__ */ b(
+                  "div",
+                  {
+                    className: "be-version-history-view-toggle",
+                    role: "tablist",
+                    "aria-label": "View mode",
+                    children: [
+                      /* @__PURE__ */ k(
+                        "button",
+                        {
+                          type: "button",
+                          role: "tab",
+                          "aria-selected": f === "changes",
+                          className: f === "changes" ? "is-active" : "",
+                          onClick: () => T("changes"),
+                          children: "Changes"
+                        }
+                      ),
+                      /* @__PURE__ */ k(
+                        "button",
+                        {
+                          type: "button",
+                          role: "tab",
+                          "aria-selected": f === "preview",
+                          className: f === "preview" ? "is-active" : "",
+                          onClick: () => T("preview"),
+                          children: "Preview"
+                        }
+                      )
+                    ]
+                  }
+                ),
+                f === "changes" && /* @__PURE__ */ b(D, { children: [
+                  /* @__PURE__ */ b("div", { className: "be-version-history-diff-legend", children: [
+                    /* @__PURE__ */ k("span", { className: "be-version-diff-added", children: "Added" }),
+                    /* @__PURE__ */ k("span", { className: "be-version-diff-removed", children: "Removed" }),
+                    !C && /* @__PURE__ */ k("span", { className: "be-version-history-diff-legend-note", children: "First saved version — everything shown is new." })
+                  ] }),
+                  /* @__PURE__ */ k(
+                    "div",
+                    {
+                      className: "be-version-history-preview-body be-version-history-diff-body",
+                      dangerouslySetInnerHTML: { __html: G }
+                    }
+                  )
+                ] }),
+                f === "preview" && // Static HTML from a throwaway store (see previewHtml above) -- inherently read-only, not a second live editor.
+                /* @__PURE__ */ k(
+                  "div",
+                  {
+                    className: "be-version-history-preview-body",
+                    dangerouslySetInnerHTML: { __html: N }
+                  }
+                ),
+                /* @__PURE__ */ b("div", { className: "be-version-history-preview-actions", children: [
+                  /* @__PURE__ */ k(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => {
+                        u(null), T("changes");
+                      },
+                      children: "Back"
+                    }
+                  ),
+                  /* @__PURE__ */ b(
+                    "button",
+                    {
+                      type: "button",
+                      className: "be-version-history-restore",
+                      onClick: Q,
+                      children: [
+                        /* @__PURE__ */ k(St, { size: 13 }),
+                        "Restore this version"
+                      ]
+                    }
+                  )
+                ] })
+              ] }) : /* @__PURE__ */ b("div", { className: "be-version-history-list", children: [
+                !o && /* @__PURE__ */ k("p", { className: "be-version-history-empty", children: "Loading…" }),
+                o && r.length === 0 && /* @__PURE__ */ k("p", { className: "be-version-history-empty", children: "No versions yet — one is saved automatically after you make some edits and pause." }),
+                x.map((p) => /* @__PURE__ */ b("div", { className: "be-version-history-group", children: [
+                  /* @__PURE__ */ k("div", { className: "be-version-history-group-label", children: p.label }),
+                  p.versions.map((I) => /* @__PURE__ */ b(
+                    "button",
+                    {
+                      type: "button",
+                      className: "be-version-history-item",
+                      onClick: () => u(I.id),
+                      children: [
+                        /* @__PURE__ */ k(j, { authorId: I.authorId, size: 24 }),
+                        /* @__PURE__ */ b("div", { className: "be-version-history-item-body", children: [
+                          /* @__PURE__ */ k("div", { className: "be-version-history-item-author", children: I.authorId ?? "Unknown" }),
+                          /* @__PURE__ */ b("div", { className: "be-version-history-item-meta", children: [
+                            Mt(I.timestamp),
+                            " · ",
+                            I.summary
+                          ] })
+                        ] })
+                      ]
+                    },
+                    I.id
+                  ))
+                ] }, p.label))
+              ] })
+            ]
+          }
+        )
+      ] }),
+      document.body
+    )
+  ] });
+}
+export {
+  F as E,
+  de as V,
+  X as a,
+  ce as b,
+  $t as c,
+  Wt as d,
+  Vt as e,
+  re as f,
+  oe as g,
+  Bt as h,
+  ne as i,
+  Lt as j,
+  ie as r,
+  Ut as u
+};
+//# sourceMappingURL=VersionHistory-Bg6fufP5.js.map