@arbidocs/blocks 0.4.20 → 0.4.22

package/dist/chunk-UOLMFC5K.js

@@ -0,0 +1,846 @@
+"use client";
+import { filterMentionCandidates, MentionMenu, findMentionQuery, extractMentions } from './chunk-AA3PT6KR.js';
+import { unzipSync, strFromU8, strToU8, zipSync } from 'fflate';
+import React2, { useRef, useEffect, useState, useLayoutEffect } from 'react';
+import { useReview, DocxEditorReview, reviewModule } from '@docx-editor.dev/pro/react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import * as Y from 'yjs';
+import { useChromeTranslate, DocxEditor, createFontSource } from '@docx-editor.dev/react';
+import { collaborationModule } from '@docx-editor.dev/pro';
+import { DOCUMENT_COLLABORATION_VERSIONS } from '@docx-editor.dev/pro/collaboration';
+import { createHocuspocusCollaboration } from '@docx-editor.dev/pro/collaboration/hocuspocus';
+import { Type, Ellipsis, WifiOff, Check, Download, Save, RefreshCw } from 'lucide-react';
+
+function normalizeDocxExport(data) {
+  const files = unzipSync(new Uint8Array(data));
+  const part = "[Content_Types].xml";
+  const xml = new DOMParser().parseFromString(strFromU8(files[part]), "application/xml");
+  if (xml.getElementsByTagName("parsererror").length) throw new Error("Invalid DOCX content types.");
+  const namespace = "http://schemas.openxmlformats.org/package/2006/content-types";
+  const types = {
+    "word/comments.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml",
+    "word/commentsExtended.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml",
+    "word/commentsIds.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml",
+    "word/commentsExtensible.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml"
+  };
+  let changed = false;
+  for (const [name, type] of Object.entries(types)) {
+    if (!files[name]) continue;
+    let override = Array.from(xml.getElementsByTagNameNS(namespace, "Override")).find(
+      (node) => node.getAttribute("PartName") === "/" + name
+    );
+    if (!override) {
+      override = xml.createElementNS(namespace, "Override");
+      override.setAttribute("PartName", "/" + name);
+      xml.documentElement.appendChild(override);
+    }
+    if (override.getAttribute("ContentType") !== type) {
+      override.setAttribute("ContentType", type);
+      changed = true;
+    }
+  }
+  if (changed) files[part] = strToU8(new XMLSerializer().serializeToString(xml));
+  const word = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  for (const name of Object.keys(files)) {
+    if (!/^word\/(document|header\d*|footer\d*|footnotes|endnotes|comments)\.xml$/.test(name))
+      continue;
+    const document2 = new DOMParser().parseFromString(strFromU8(files[name]), "application/xml");
+    if (document2.getElementsByTagName("parsererror").length)
+      throw new Error("Invalid Word document XML.");
+    const elements = Array.from(document2.getElementsByTagName("*"));
+    const used = new Set(
+      elements.map((element) => element.getAttributeNS(word, "id")).filter(Boolean)
+    );
+    const seen = /* @__PURE__ */ new Set();
+    let next = 1, repaired = false;
+    for (const element of elements) {
+      if (element.namespaceURI !== word || !["ins", "del", "moveFrom", "moveTo"].includes(element.localName))
+        continue;
+      const id = element.getAttributeNS(word, "id");
+      if (!id) continue;
+      if (seen.has(id)) {
+        while (used.has(String(next))) next++;
+        const unique = String(next++);
+        const attribute = element.getAttributeNodeNS(word, "id");
+        element.setAttributeNS(word, attribute.name, unique);
+        used.add(unique);
+        repaired = true;
+      } else seen.add(id);
+    }
+    if (repaired) {
+      files[name] = strToU8(new XMLSerializer().serializeToString(document2));
+      changed = true;
+    }
+  }
+  if (!changed) return data;
+  return zipSync(files).slice().buffer;
+}
+
+// src/docx/mentions.ts
+function mentionCandidates(mentions) {
+  return [
+    { id: "arbi", label: "ARBI", kind: "assistant" },
+    ...mentions.filter((person) => person.name.trim()).map((person) => ({
+      id: person.id,
+      label: person.name,
+      kind: person.kind === "agent" ? "assistant" : "user"
+    }))
+  ];
+}
+function mentionedDocxRecipients(text, mentions) {
+  return extractMentions(text, mentionCandidates(mentions)).map((person) => person.id);
+}
+function DocxMentions({
+  children,
+  mentions = [],
+  initialCommentId,
+  requestAgent,
+  notify
+}) {
+  const review = useReview();
+  const activated = useRef(void 0);
+  useEffect(() => {
+    if (!initialCommentId || activated.current === initialCommentId || !review.ready) return;
+    const target = review.items.find(
+      (item) => item.kind === "comment" && item.item.id === initialCommentId
+    );
+    if (!target) return;
+    review.setPaneOpen(true);
+    if (review.setActive(target.key)) activated.current = initialCommentId;
+  }, [initialCommentId, review]);
+  const input = useRef(null);
+  const replyTarget = useRef(null);
+  const pending = useRef(null);
+  const [suggestions, setSuggestions] = useState(null);
+  const [selected, setSelected] = useState(0);
+  const candidates = filterMentionCandidates(
+    mentionCandidates(mentions),
+    suggestions?.query || ""
+  ).slice(0, 8);
+  useEffect(() => {
+    const submission = pending.current;
+    if (!submission || !requestAgent) return;
+    const created = review.items.find(
+      (item) => item.kind === "comment" && !submission.ids.has(item.item.id) && item.text.trim() === submission.text
+    );
+    if (!created || created.kind !== "comment") return;
+    pending.current = null;
+    const commentId = created.parentId || created.item.id;
+    void requestAgent({
+      commentId,
+      instruction: submission.text,
+      requestId: submission.requestId,
+      recipientIds: submission.recipientIds
+    }).catch((error) => {
+      notify?.(
+        error instanceof Error ? error.message : "Could not start the document agent.",
+        "error"
+      );
+    });
+  }, [review.items, requestAgent, notify]);
+  const choose = (name) => {
+    const field = input.current;
+    if (!field || !suggestions) return;
+    const end = field.selectionStart ?? field.value.length;
+    const value = field.value.slice(0, suggestions.from) + "@" + name + " " + field.value.slice(end);
+    Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set?.call(field, value);
+    field.dispatchEvent(new Event("input", { bubbles: true }));
+    field.focus();
+    field.setSelectionRange(suggestions.from + name.length + 2, suggestions.from + name.length + 2);
+    setSuggestions(null);
+  };
+  const captureSubmission = (target) => {
+    const form = target.closest("form");
+    const field = form?.querySelector(
+      '[data-testid="review-draft-input"], [data-testid="review-reply-input"]'
+    );
+    if (!field || field.readOnly || !requestAgent) return false;
+    const recipientIds = mentionedDocxRecipients(field.value, mentions);
+    if (!recipientIds.length) return false;
+    pending.current = {
+      ids: new Set(review.items.filter((i) => i.kind === "comment").map((i) => i.item.id)),
+      text: field.value.trim(),
+      requestId: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`,
+      recipientIds
+    };
+    const pinned = replyTarget.current;
+    const thread = pinned ? review.items.find((item) => item.key === pinned.key && item.kind === "comment") : void 0;
+    if (field.dataset.testid === "review-reply-input" && pinned && !thread) {
+      pending.current = null;
+      notify?.("This comment was removed. Open a current thread before replying.", "error");
+      return true;
+    }
+    if (field.dataset.testid === "review-reply-input" && thread) {
+      if (!review.reply(thread, field.value.trim())) {
+        pending.current = null;
+        notify?.("Could not post this reply. The comment may have been removed.", "error");
+      } else {
+        Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set?.call(field, "");
+        field.dispatchEvent(new Event("input", { bubbles: true }));
+        replyTarget.current = null;
+        review.setActive(thread.key, { reveal: false });
+      }
+      return true;
+    }
+    return false;
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "native-docx-mentions",
+      onInputCapture: (event) => {
+        const field = event.target;
+        if (!(field instanceof HTMLInputElement) || !field.dataset.testid?.startsWith("review-"))
+          return;
+        if (!replyTarget.current && review.activeKey)
+          replyTarget.current = { field, key: review.activeKey };
+        input.current = field;
+        const before = field.value.slice(0, field.selectionStart ?? field.value.length);
+        const match = findMentionQuery(before, before.length);
+        if (!match) return setSuggestions(null);
+        const rect = field.getBoundingClientRect();
+        setSelected(0);
+        setSuggestions({
+          query: match.query,
+          from: match.start,
+          left: rect.left,
+          top: rect.bottom
+        });
+      },
+      onPointerDownCapture: (event) => {
+        const target = event.target;
+        if (target instanceof HTMLElement && target.closest('[data-testid="review-marker"], [data-testid="review-reply-cancel"]'))
+          replyTarget.current = null;
+      },
+      onSubmitCapture: (event) => {
+        if (captureSubmission(event.target)) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      onKeyDownCapture: (event) => {
+        if (suggestions && candidates.length) {
+          if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+            event.preventDefault();
+            event.stopPropagation();
+            setSelected(
+              (s) => (s + (event.key === "ArrowDown" ? 1 : candidates.length - 1)) % candidates.length
+            );
+            return;
+          }
+          if (event.key === "Enter" || event.key === "Tab") {
+            event.preventDefault();
+            event.stopPropagation();
+            choose(candidates[selected]?.label || candidates[0].label);
+            return;
+          }
+          if (event.key === "Escape") {
+            event.preventDefault();
+            event.stopPropagation();
+            setSuggestions(null);
+            return;
+          }
+        }
+        if (event.key === "Enter" && captureSubmission(event.target)) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      },
+      children: [
+        children,
+        suggestions && candidates.length > 0 && /* @__PURE__ */ jsx(
+          "div",
+          {
+            onPointerDown: (event) => event.stopPropagation(),
+            onMouseDown: (event) => {
+              event.preventDefault();
+              event.stopPropagation();
+            },
+            onClick: (event) => event.stopPropagation(),
+            style: {
+              position: "fixed",
+              left: suggestions.left,
+              top: suggestions.top,
+              width: 280,
+              zIndex: 1e3
+            },
+            children: /* @__PURE__ */ jsx(
+              MentionMenu,
+              {
+                open: true,
+                placement: "below",
+                items: candidates,
+                selectedIndex: selected,
+                setSelectedIndex: setSelected,
+                onSelect: (person) => choose(person.label),
+                labels: { list: "Mention workspace member" }
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+var drafts = /* @__PURE__ */ new Map();
+var stateBytes = (room) => Y.encodeStateAsUpdate(room.ydoc);
+var encodeState = (room) => {
+  let binary = "";
+  for (const byte of stateBytes(room)) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+function covered(room, vector, receipt) {
+  const decode = (value) => Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+  const server = Y.decodeStateVector(decode(vector)), local = Y.decodeStateVector(Y.encodeStateVector(room.ydoc));
+  for (const [client, clock] of local) if ((server.get(client) || 0) < clock) return false;
+  const deleted = Y.decodeUpdate(stateBytes(room)).ds.clients;
+  const saved = Y.decodeUpdate(decode(receipt)).ds.clients;
+  for (const [client, ranges] of deleted)
+    for (const range of ranges) {
+      if (!(saved.get(client) || []).some(
+        (s) => s.clock <= range.clock && s.clock + s.len >= range.clock + range.len
+      ))
+        return false;
+    }
+  return true;
+}
+var EditorBoundary = class extends React2.Component {
+  state = {};
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  render() {
+    return this.state.error ? /* @__PURE__ */ jsxs("div", { role: "alert", className: "native-docx-error", children: [
+      "Could not render this Word document: ",
+      this.state.error.message
+    ] }) : this.props.children;
+  }
+};
+function DocxParticipants({ session }) {
+  const [people, setPeople] = useState([]);
+  useEffect(() => {
+    if (!session) return;
+    setPeople(session.participants());
+    return session.subscribeParticipants(setPeople);
+  }, [session]);
+  return /* @__PURE__ */ jsx("div", { className: "native-docx-presence", "aria-label": "People viewing this document", children: people.map((p) => /* @__PURE__ */ jsx("span", { className: "native-docx-avatar", title: p.name, children: p.name.split(" ").map((s) => s[0]).slice(0, 2).join("") }, p.actorId)) });
+}
+function RibbonMenu({
+  label,
+  icon,
+  children
+}) {
+  const [open, setOpen] = useState(false);
+  const element = useRef(null);
+  useEffect(() => {
+    if (!open) return;
+    const dismiss = (event) => {
+      if (!element.current?.contains(event.target)) setOpen(false);
+    };
+    const escape = (event) => {
+      if (event.key === "Escape") setOpen(false);
+    };
+    document.addEventListener("pointerdown", dismiss);
+    document.addEventListener("keydown", escape);
+    return () => {
+      document.removeEventListener("pointerdown", dismiss);
+      document.removeEventListener("keydown", escape);
+    };
+  }, [open]);
+  return /* @__PURE__ */ jsxs("div", { className: "native-docx-ribbon-menu", ref: element, children: [
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "native-docx-ribbon-trigger",
+        "aria-label": label,
+        title: label,
+        "aria-expanded": open,
+        onMouseDown: (event) => event.preventDefault(),
+        onClick: () => setOpen((value) => !value),
+        children: icon
+      }
+    ),
+    open && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "native-docx-ribbon-popover",
+        role: "group",
+        "aria-label": label,
+        onMouseDown: (event) => {
+          if (!(event.target instanceof HTMLInputElement || event.target instanceof HTMLSelectElement))
+            event.preventDefault();
+        },
+        children
+      }
+    )
+  ] });
+}
+function DocxRibbon({ onSave }) {
+  const [tab, setTab] = useState("Home");
+  const t = useChromeTranslate();
+  return /* @__PURE__ */ jsxs("div", { className: "native-docx-ribbon", children: [
+    /* @__PURE__ */ jsxs("select", { "aria-label": "Ribbon tab", value: tab, onChange: (event) => setTab(event.target.value), children: [
+      /* @__PURE__ */ jsx("option", { children: "Home" }),
+      /* @__PURE__ */ jsx("option", { children: "Insert" }),
+      /* @__PURE__ */ jsx("option", { children: "Review" })
+    ] }),
+    /* @__PURE__ */ jsxs(DocxEditor.Toolbar, { t, preset: false, onSave, children: [
+      /* @__PURE__ */ jsx(DocxEditor.Toolbar.Undo, {}),
+      /* @__PURE__ */ jsx(DocxEditor.Toolbar.Redo, {}),
+      tab === "Home" && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Bold, {}),
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Italic, {}),
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Underline, {}),
+        /* @__PURE__ */ jsxs(RibbonMenu, { label: "Font", icon: /* @__PURE__ */ jsx(Type, { size: 16 }), children: [
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.FontFamily, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.FontSize, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.FontColor, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.Highlight, {})
+        ] }),
+        /* @__PURE__ */ jsxs(RibbonMenu, { label: "More formatting", icon: /* @__PURE__ */ jsx(Ellipsis, { size: 16 }), children: [
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.StylePicker, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.Alignment, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.BulletList, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.NumberedList, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.LineSpacing, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.Indent, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.Outdent, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.Strike, {}),
+          /* @__PURE__ */ jsx(DocxEditor.Toolbar.ClearFormatting, {})
+        ] })
+      ] }),
+      tab === "Insert" && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.TableInsert, {}),
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.ImageInsert, {}),
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Link, {})
+      ] }),
+      tab === "Review" && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.EditingMode, {}),
+        /* @__PURE__ */ jsx(DocxEditor.Toolbar.Comments, {}),
+        /* @__PURE__ */ jsx(RibbonMenu, { label: "Review options", icon: /* @__PURE__ */ jsx(Ellipsis, { size: 16 }), children: /* @__PURE__ */ jsx(DocxEditor.Toolbar.Reviewers, {}) })
+      ] })
+    ] })
+  ] });
+}
+var fixedZoomMode = { type: "fixed" };
+function NativeDocxEditor({
+  documentId,
+  title,
+  draftContent,
+  initialCommentId,
+  snapshot = false,
+  onSaved,
+  adapter
+}) {
+  const [ready, setReady] = useState(), [error, setError] = useState(""), [retry, setRetry] = useState(0);
+  const [status, setStatus] = useState("Connecting\u2026"), [dirty, setDirty] = useState(false), [saving, setSaving] = useState(false), [offline, setOffline] = useState(false);
+  const revision = useRef(0);
+  const stageRef = useRef(null), fitCleanup = useRef(void 0);
+  const ref = useRef(null), dirtyRef = useRef(false), draftTimer = useRef(void 0);
+  const isDraft = draftContent !== void 0;
+  useEffect(() => {
+    let cancelled = false;
+    let room;
+    const cleanups = [];
+    setReady(void 0);
+    setError("");
+    setStatus("Connecting\u2026");
+    setDirty(false);
+    dirtyRef.current = false;
+    async function start() {
+      const fonts = await adapter.loadFonts();
+      if (isDraft || snapshot) {
+        const data = isDraft ? drafts.get(documentId) || await (await adapter.request("/prepare", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ content: draftContent })
+        })).arrayBuffer() : await (await adapter.request(`/${documentId}/content`)).arrayBuffer();
+        if (!cancelled) {
+          setReady({
+            document: new Uint8Array(data),
+            fonts,
+            modules: [reviewModule()],
+            canEdit: !snapshot,
+            author: adapter.author || "You",
+            filename: title
+          });
+          setStatus(snapshot ? "Saved version \xB7 read only" : "Unsaved note");
+        }
+        return;
+      }
+      const session = await adapter.open(documentId);
+      const ws = new URL(session.websocket_path, adapter.baseUrl || location.origin);
+      ws.protocol = ws.protocol === "https:" ? "wss:" : "ws:";
+      let initial = true;
+      room = await createHocuspocusCollaboration({
+        url: ws.toString(),
+        roomId: session.room_id,
+        identity: session.identity,
+        bootstrap: { kind: "join" },
+        offlineEditing: true,
+        token: async () => {
+          const next = initial ? session : await adapter.open(documentId);
+          initial = false;
+          if (!cancelled)
+            setReady((previous) => previous ? { ...previous, canEdit: next.can_edit } : previous);
+          return JSON.stringify({
+            capability: next.token,
+            versions: DOCUMENT_COLLABORATION_VERSIONS
+          });
+        }
+      });
+      if (cancelled) {
+        room.destroy();
+        return;
+      }
+      const current = room;
+      cleanups.push(
+        current.session.subscribeStatus((s, _reason, detail) => {
+          const disconnected = s === "disconnected";
+          setOffline(disconnected);
+          if (s === "error") {
+            setError(
+              detail || "The collaboration session failed. Export your local document before reconnecting."
+            );
+            setStatus("Connection failed");
+          } else if (disconnected) setStatus("Offline \xB7 edits buffered locally");
+          else if (s === "ready") {
+            setError("");
+            setStatus(dirtyRef.current ? "Saving changes\u2026" : "Connected");
+          }
+        })
+      );
+      const stateless = ({ payload }) => {
+        try {
+          const message = JSON.parse(payload);
+          if (message.type === "persisted") {
+            if (!cancelled && message.vector && message.receipt && covered(current, message.vector, message.receipt)) {
+              dirtyRef.current = false;
+              setDirty(false);
+              setStatus("All changes saved");
+            }
+          }
+          if (message.type === "pending") setStatus("Saving changes\u2026");
+          if (message.type === "save-error") setStatus(message.message || "Autosave failed");
+        } catch {
+        }
+      };
+      current.provider.on("stateless", stateless);
+      cleanups.push(() => current.provider.off("stateless", stateless));
+      if (adapter.subscribeTokenChanges)
+        cleanups.push(
+          adapter.subscribeTokenChanges(() => {
+            void current.provider.sendToken().catch(() => setStatus("Could not renew the collaboration session"));
+          })
+        );
+      const refresh = setInterval(
+        () => {
+          void current.provider.sendToken().catch(() => setStatus("Could not renew the collaboration session"));
+        },
+        5 * 60 * 1e3
+      );
+      cleanups.push(() => clearInterval(refresh));
+      setReady({
+        document: current.document,
+        fonts,
+        modules: [reviewModule(), collaborationModule({ session: current.session })],
+        room: current,
+        canEdit: session.can_edit,
+        author: session.identity.name,
+        filename: session.filename
+      });
+      setStatus(session.can_edit ? "All changes saved" : "Read only \xB7 live");
+    }
+    void start().catch((e) => {
+      if (!cancelled) setError(e instanceof Error ? e.message : String(e));
+    });
+    return () => {
+      cancelled = true;
+      cleanups.forEach((f) => f());
+      clearTimeout(draftTimer.current);
+      fitCleanup.current?.();
+      room?.destroy();
+    };
+  }, [documentId, isDraft, snapshot, retry]);
+  useEffect(() => {
+    adapter.onDirtyChange?.(dirty);
+    const beforeUnload = (e) => {
+      if (dirtyRef.current) e.preventDefault();
+    };
+    window.addEventListener("beforeunload", beforeUnload);
+    return () => {
+      window.removeEventListener("beforeunload", beforeUnload);
+      adapter.onDirtyChange?.(false);
+    };
+  }, [dirty]);
+  async function exportDocument() {
+    const data = await ref.current?.save();
+    if (!data) return;
+    const url = URL.createObjectURL(
+      new Blob([normalizeDocxExport(data)], {
+        type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+      })
+    );
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = title.replace(/\.[^.]+$/, "") + ".docx";
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 5e3);
+  }
+  useLayoutEffect(() => {
+    const editor = ref.current;
+    return () => {
+      if (isDraft && editor && dirtyRef.current)
+        void editor.save().then((bytes) => {
+          if (bytes) drafts.set(documentId, bytes);
+        }).catch(() => {
+        });
+    };
+  }, [documentId, isDraft, ready]);
+  async function saveVersion() {
+    if (!ready || saving) return;
+    setSaving(true);
+    const atRevision = revision.current;
+    try {
+      const result = isDraft ? await (async () => {
+        const bytes = await ref.current?.save();
+        if (!bytes) throw new Error("The editor is not ready.");
+        return (await adapter.request(`/notes?${new URLSearchParams({ title })}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+          },
+          body: bytes
+        })).json();
+      })() : await adapter.save(documentId, ready.room ? encodeState(ready.room) : void 0);
+      if (revision.current === atRevision) {
+        dirtyRef.current = false;
+        setDirty(false);
+        drafts.delete(documentId);
+      }
+      await Promise.resolve(adapter.onVersionSaved?.(result.document_ext_id)).catch(() => {
+      });
+      onSaved?.(result.document_ext_id);
+      adapter.notify?.(isDraft ? "Word note saved" : "DOCX version saved", "success");
+    } catch (e) {
+      adapter.notify?.(e instanceof Error ? e.message : "Could not save this document.", "error");
+      setStatus("Save failed \xB7 your draft is retained");
+    } finally {
+      setSaving(false);
+    }
+  }
+  function editorReady(editor) {
+    ref.current = editor;
+    fitCleanup.current?.();
+    const viewport = stageRef.current?.querySelector(".native-docx-viewport");
+    if (!viewport) return;
+    const fit = () => {
+      const pageWidth = editor.getPageGeometry()[0]?.box.width;
+      if (!pageWidth) return;
+      const style = getComputedStyle(viewport);
+      const available = viewport.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight);
+      const zoom = Math.max(0.1, Math.min(2.5, available / pageWidth));
+      if (Math.abs(editor.getZoom() - zoom) > 1e-3) editor.setZoom(zoom);
+    };
+    const resize = new ResizeObserver(fit);
+    const chrome = new MutationObserver(fit);
+    resize.observe(viewport);
+    chrome.observe(viewport, { attributes: true, attributeFilter: ["style", "data-review-pane"] });
+    fit();
+    fitCleanup.current = () => {
+      resize.disconnect();
+      chrome.disconnect();
+    };
+  }
+  function changed() {
+    if (snapshot) return;
+    revision.current += 1;
+    dirtyRef.current = true;
+    setDirty(true);
+    setStatus(
+      isDraft ? "Unsaved note" : offline ? "Offline \xB7 edits buffered locally" : "Saving changes\u2026"
+    );
+    if (isDraft) {
+      clearTimeout(draftTimer.current);
+      draftTimer.current = setTimeout(() => {
+        void ref.current?.save().then((bytes) => {
+          if (bytes) drafts.set(documentId, bytes);
+        });
+      }, 200);
+    }
+  }
+  return /* @__PURE__ */ jsxs("section", { className: "native-docx-viewer", "data-testid": "native-docx-editor", children: [
+    /* @__PURE__ */ jsxs("div", { className: "native-docx-actions", children: [
+      /* @__PURE__ */ jsxs("span", { className: "native-docx-status", role: "status", children: [
+        offline ? /* @__PURE__ */ jsx(WifiOff, { size: 14 }) : !dirty && ready ? /* @__PURE__ */ jsx(Check, { size: 14 }) : null,
+        status
+      ] }),
+      /* @__PURE__ */ jsx(DocxParticipants, { session: ready?.room?.session }),
+      /* @__PURE__ */ jsxs("button", { onClick: () => void exportDocument(), disabled: !ready, "aria-label": "Download DOCX", children: [
+        /* @__PURE__ */ jsx(Download, { size: 14 }),
+        "DOCX"
+      ] }),
+      !snapshot && ready?.canEdit && /* @__PURE__ */ jsxs(
+        "button",
+        {
+          className: "native-docx-save",
+          onClick: () => void saveVersion(),
+          disabled: !ready || saving || offline,
+          "data-testid": "native-docx-save",
+          children: [
+            /* @__PURE__ */ jsx(Save, { size: 14 }),
+            saving ? "Saving\u2026" : isDraft ? "Save note" : "Save version"
+          ]
+        }
+      )
+    ] }),
+    offline && /* @__PURE__ */ jsx("div", { className: "native-docx-notice", children: "Changes are buffered in this browser. Keep this tab open until the connection returns, or download your DOCX." }),
+    error && /* @__PURE__ */ jsxs("div", { className: "native-docx-notice", "data-error": "true", role: "alert", children: [
+      error,
+      " ",
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          disabled: dirty,
+          title: dirty ? "Download your unsaved DOCX before reopening the editor" : void 0,
+          onClick: () => setRetry((x) => x + 1),
+          children: [
+            /* @__PURE__ */ jsx(RefreshCw, { size: 12 }),
+            "Retry"
+          ]
+        }
+      )
+    ] }),
+    !ready && !error && /* @__PURE__ */ jsx("div", { className: "native-docx-error", role: "status", children: "Opening Word document\u2026" }),
+    ready && /* @__PURE__ */ jsx("div", { className: "native-docx-body docx-editor", children: /* @__PURE__ */ jsx(EditorBoundary, { children: /* @__PURE__ */ jsxs(
+      DocxEditor.Root,
+      {
+        document: ready.document,
+        modules: ready.modules,
+        fonts: ready.fonts,
+        mode: !ready.canEdit || snapshot ? "view" : "suggesting",
+        reviewDisplayMode: "all-markup",
+        zoomMode: fixedZoomMode,
+        author: ready.author,
+        onReady: editorReady,
+        onChange: (change) => {
+          if (change.source !== "load") changed();
+        },
+        onFontError: (e) => setError(e.message),
+        children: [
+          /* @__PURE__ */ jsx(
+            DocxEditor.RevisionMarkup,
+            {
+              insertions: { mark: "underline", color: "blue" },
+              deletions: { mark: "strikethrough", color: "red" },
+              movedFrom: { mark: "doubleStrikethrough", color: "green" },
+              movedTo: { mark: "doubleUnderline", color: "green" },
+              trackMoves: true
+            }
+          ),
+          /* @__PURE__ */ jsx(DocxRibbon, { onSave: () => void saveVersion() }),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "native-docx-stage",
+              ref: stageRef,
+              onMouseDownCapture: (event) => {
+                if (event.button === 2 && ref.current?.getSelectionPlacement())
+                  event.preventDefault();
+              },
+              children: [
+                /* @__PURE__ */ jsxs(DocxEditor.Viewport, { className: "native-docx-viewport", children: [
+                  /* @__PURE__ */ jsx(DocxEditor.Content, {}),
+                  /* @__PURE__ */ jsx(
+                    DocxMentions,
+                    {
+                      initialCommentId,
+                      mentions: adapter.mentions,
+                      notify: adapter.notify,
+                      requestAgent: adapter.requestAgent ? (request) => adapter.requestAgent(documentId, request) : void 0,
+                      children: /* @__PURE__ */ jsx(DocxEditorReview, {})
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(DocxEditor.HeaderFooterChrome, {}),
+                  /* @__PURE__ */ jsx(DocxEditor.NotesChrome, {}),
+                  /* @__PURE__ */ jsx(DocxEditor.Equation, {}),
+                  /* @__PURE__ */ jsx(DocxEditor.HyperLink, {}),
+                  /* @__PURE__ */ jsx(DocxEditor.ContextMenu, {})
+                ] }),
+                /* @__PURE__ */ jsx(DocxEditor.PageNumber, {})
+              ]
+            }
+          )
+        ]
+      }
+    ) }, retry) })
+  ] });
+}
+var loaded = /* @__PURE__ */ new Map();
+function loadDocxFonts(baseUrl = "/native-docx/fonts") {
+  let promise = loaded.get(baseUrl);
+  if (!promise) {
+    promise = loadFonts(baseUrl).catch((error) => {
+      loaded.delete(baseUrl);
+      throw error;
+    });
+    loaded.set(baseUrl, promise);
+  }
+  return promise;
+}
+async function loadFonts(baseUrl) {
+  const families = ["Liberation Serif", "Liberation Sans", "Liberation Mono"];
+  const variants = [
+    { suffix: "Regular", weight: 400, style: "normal" },
+    { suffix: "Bold", weight: 700, style: "normal" },
+    { suffix: "Italic", weight: 400, style: "italic" },
+    { suffix: "BoldItalic", weight: 700, style: "italic" }
+  ];
+  const sources = await Promise.all(
+    families.flatMap(
+      (family) => variants.map(async (face) => {
+        const r = await fetch(
+          `${baseUrl.replace(/\/$/, "")}/${family.replace(" ", "")}-${face.suffix}.ttf`
+        );
+        if (!r.ok) throw new Error(`Could not load the document font ${family}.`);
+        const result = createFontSource(new Uint8Array(await r.arrayBuffer()), {
+          family,
+          weight: face.weight,
+          style: face.style
+        });
+        if ("failure" in result)
+          throw new Error(`Could not initialize the document font ${family}.`);
+        return result.source;
+      })
+    )
+  );
+  const aliases = {
+    "Times New Roman": "Liberation Serif",
+    Cambria: "Liberation Serif",
+    "DejaVu Serif": "Liberation Serif",
+    Calibri: "Liberation Sans",
+    Aptos: "Liberation Sans",
+    Arial: "Liberation Sans",
+    Helvetica: "Liberation Sans",
+    "Courier New": "Liberation Mono",
+    "DejaVu Sans Mono": "Liberation Mono"
+  };
+  return {
+    epoch: 1,
+    maxFontBytes: 12 * 1024 * 1024,
+    sources,
+    defaultFont: { family: "Liberation Serif", sizeHalfPoints: 22 },
+    supportedFamilies: [...families, ...Object.keys(aliases)],
+    substitutions: Object.entries(aliases).flatMap(
+      ([from, to]) => variants.map((face) => ({
+        from: { family: from, weight: face.weight, style: face.style },
+        to: { family: to, weight: face.weight, style: face.style }
+      }))
+    )
+  };
+}
+
+export { DocxMentions, DocxParticipants, DocxRibbon, NativeDocxEditor, loadDocxFonts, normalizeDocxExport };
+//# sourceMappingURL=chunk-UOLMFC5K.js.map
+//# sourceMappingURL=chunk-UOLMFC5K.js.map