@ai-matrx/office 0.4.0 → 0.5.2

package/dist/docs.cjs

@@ -0,0 +1,657 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkBWMAYLW4cjs = require('./chunk-BWMAYLW4.cjs');
+require('./chunk-2UBGQUXW.cjs');
+
+// src/univer/isSnapshotMutation.ts
+var MUTATION = 2;
+var NON_CONTENT_ID_PATTERN = /(scroll|selection|set-selections|viewport|zoom|hover|cursor|focus|activate)/i;
+function isSnapshotMutation(command) {
+  if (command.type !== MUTATION) return false;
+  if (NON_CONTENT_ID_PATTERN.test(command.id)) return false;
+  return true;
+}
+
+// src/docs/document-model.ts
+var DOCUMENT_SAVE_DELAY_MS = 2500;
+var viewIds = 0;
+var DocumentModel = (_class = class {
+  
+  
+  
+  __init() {this.views = /* @__PURE__ */ new Map()}
+  __init2() {this.lastEditedView = null}
+  /** The document as the last view left it, or as last loaded / saved. */
+  __init3() {this.stored = null}
+  __init4() {this.loading = null}
+  __init5() {this.relaying = false}
+  /** Snapshot rows this tab already holds (loaded or written) — never re-applied. */
+  __init6() {this.knownSnapshots = /* @__PURE__ */ new Set()}
+  __init7() {this.collabListeners = /* @__PURE__ */ new Set()}
+  __init8() {this.collab = null}
+  __init9() {this.collabStarting = null}
+  __init10() {this.awareness = null}
+  __init11() {this.awarenessListeners = /* @__PURE__ */ new Set()}
+  __init12() {this.realtimeClose = null}
+  __init13() {this.pageClose = null}
+  /** The last view's editor, alive and off the page until a view takes it back. */
+  __init14() {this.parked = null}
+  constructor(handle, deps) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);_class.prototype.__init15.call(this);_class.prototype.__init16.call(this);_class.prototype.__init17.call(this);_class.prototype.__init18.call(this);
+    this.documentId = handle.id;
+    this.handle = handle;
+    this.deps = deps;
+  }
+  // ── body ────────────────────────────────────────────────────────────────
+  /** The newest state of the body this tab holds, without a network read. */
+  latest() {
+    const preferred = this.lastEditedView !== null ? this.views.get(this.lastEditedView) : void 0;
+    for (const view of preferred ? [preferred, ...this.views.values()] : this.views.values()) {
+      try {
+        const snapshot = view.port.snapshot();
+        if (snapshot) return snapshot;
+      } catch (error) {
+        console.warn(`[document-model] a view of ${this.documentId} could not report its document`, error);
+      }
+    }
+    return this.stored;
+  }
+  /**
+   * What a NEW view should boot from: the model's latest state, or (only when
+   * this tab holds none) the newest server snapshot. Null = an empty document.
+   * Re-read `latest()` synchronously right before mounting — another view may
+   * have typed while the server read was in flight.
+   */
+  async openingSnapshot(createEmpty) {
+    const held = this.latest();
+    if (held) return held;
+    if (!this.loading) {
+      this.loading = this.deps.loadLatest(this.documentId).then(
+        (row) => {
+          if (row) {
+            this.knownSnapshots.add(row.id);
+            this.savedFingerprint = contentFingerprint(row.snapshot);
+          }
+          if (!this.stored) this.stored = row ? row.snapshot : createEmpty();
+          return _nullishCoalesce(this.latest(), () => ( this.stored));
+        },
+        (error) => {
+          this.loading = null;
+          throw error;
+        }
+      );
+    }
+    return await _asyncNullishCoalesce(await this.loading, async () => ( createEmpty()));
+  }
+  /** A view's Univer instance is ready: it shares the document from now on. */
+  attachView(port) {
+    const id = ++viewIds;
+    const subscription = port.commandService.onMutationExecutedForCollab(
+      (info, options) => this.onViewMutation(id, info, options)
+    );
+    this.views.set(id, { id, port, dispose: () => subscription.dispose() });
+    if (!this.handle.hasPending()) {
+      try {
+        const mounted = port.snapshot();
+        if (mounted) this.savedFingerprint = contentFingerprint(mounted);
+      } catch (error) {
+        console.warn(`[document-model] could not read ${this.documentId}'s mounted document`, error);
+      }
+    }
+    let detached = false;
+    return () => {
+      if (detached) return;
+      detached = true;
+      const view = this.views.get(id);
+      if (!view) return;
+      if (this.views.size === 1) {
+        try {
+          const snapshot = port.snapshot();
+          if (snapshot) this.stored = snapshot;
+        } catch (error) {
+          console.warn(`[document-model] could not keep ${this.documentId}'s last view's document`, error);
+        }
+      }
+      view.dispose();
+      this.views.delete(id);
+      if (this.lastEditedView === id) this.lastEditedView = null;
+    };
+  }
+  /**
+   * The last view of the document is leaving: keep its editor (and Univer's
+   * undo history inside it) for the next view. Call AFTER the view's
+   * `attachView` detach. Refused — the caller disposes its editor — while
+   * another view is still attached (it carries the document) or one is
+   * already kept.
+   */
+  parkEditor(editor) {
+    if (this.closed || this.views.size > 0 || this.parked) return false;
+    this.parked = editor;
+    return true;
+  }
+  /** The kept editor, handed to the view that mounts next (null when none is kept). */
+  takeParkedEditor() {
+    const editor = this.parked;
+    this.parked = null;
+    return editor;
+  }
+  onViewMutation(viewId, info, options) {
+    if (this.relaying || _optionalChain([options, 'optionalAccess', _ => _.fromCollab]) || _optionalChain([options, 'optionalAccess', _2 => _2.fromChangeset])) return;
+    const view = this.views.get(viewId);
+    if (!view || !view.port.editable()) return;
+    this.lastEditedView = viewId;
+    this.relay(info, viewId);
+    for (const listener of this.collabListeners) listener(info);
+    if (isContentMutation(info)) this.markDirty();
+  }
+  /** The unit id a view's document has (what a replayed mutation must be addressed to). */
+  unitIdOf(view) {
+    try {
+      return _nullishCoalesce(_nullishCoalesce(_optionalChain([view, 'access', _3 => _3.port, 'access', _4 => _4.unitId, 'optionalCall', _5 => _5()]), () => ( _optionalChain([view, 'access', _6 => _6.port, 'access', _7 => _7.snapshot, 'call', _8 => _8(), 'optionalAccess', _9 => _9.id]))), () => ( null));
+    } catch (e3) {
+      return null;
+    }
+  }
+  /** Replay one mutation into every view except `exceptViewId`, addressed to each view's own unit. */
+  relay(info, exceptViewId) {
+    if (this.views.size === 0 || this.views.size === 1 && exceptViewId !== null) return;
+    this.relaying = true;
+    let failure = null;
+    try {
+      for (const view of this.views.values()) {
+        if (view.id === exceptViewId) continue;
+        try {
+          const params = info.params;
+          const unitId = this.unitIdOf(view);
+          const addressed = unitId && params && typeof params === "object" && !Array.isArray(params) && typeof params.unitId === "string" && params.unitId !== unitId ? { ...params, unitId } : info.params;
+          view.port.commandService.syncExecuteCommand(info.id, addressed, { onlyLocal: true, fromCollab: true });
+        } catch (error) {
+          failure ??= error;
+          console.error(
+            `[document-model] a second view of ${this.documentId} could not apply "${info.id}" \u2014 it may show an older document until it reopens`,
+            error
+          );
+        }
+      }
+    } finally {
+      this.relaying = false;
+    }
+    if (failure !== null) this.applyFailed(info.id, failure);
+  }
+  /** A view could not follow an edit: say so, then show the saved version (unless this tab has unsaved edits of its own). */
+  applyFailed(mutationId, error) {
+    try {
+      _optionalChain([this, 'access', _10 => _10.deps, 'access', _11 => _11.onApplyFailed, 'optionalCall', _12 => _12(this.documentId, mutationId, error)]);
+    } catch (notifyError) {
+      console.warn(`[document-model] the notice for ${this.documentId}'s failed apply also failed`, notifyError);
+    }
+    if (this.hasUnsaved()) return;
+    void this.deps.loadLatest(this.documentId).then((row) => {
+      if (row && !this.closed) this.show(row);
+    }).catch((e2) => console.warn(`[document-model] could not re-sync ${this.documentId} after a failed apply`, e2));
+  }
+  // ── save (run by the record's one coalesced save — documentModels.ts) ─
+  markDirty() {
+    this.handle.touch();
+  }
+  __init15() {this.saving = false}
+  /**
+   * The content of the version the server holds (loaded or last written). A
+   * save of the same content is no save: attaching, detaching, waking or a
+   * flush of an unchanged document never writes a snapshot row.
+   */
+  __init16() {this.savedFingerprint = null}
+  /**
+   * Write the body as it is now. Returns false when this tab is a collab peer
+   * that does not write (the elected host writes the canonical snapshot; a
+   * peer's edits reach it through the room). An explicit Save always writes.
+   */
+  async write(reason) {
+    const snapshot = this.latest();
+    if (!snapshot) throw new Error("There is no open document to save.");
+    if (this.collab && !this.collab.isHost() && reason !== "manual") return false;
+    const fingerprint = contentFingerprint(snapshot);
+    if (reason !== "manual" && fingerprint === this.savedFingerprint) return false;
+    const origin = reason === "manual" ? "manual" : "autosave";
+    this.saving = true;
+    try {
+      const { id } = await this.deps.save({ documentId: this.documentId, snapshot, origin });
+      this.knownSnapshots.add(id);
+      this.savedFingerprint = fingerprint;
+    } finally {
+      this.saving = false;
+    }
+    if (this.views.size === 0) this.stored = snapshot;
+    _optionalChain([this, 'access', _13 => _13.deps, 'access', _14 => _14.onSaved, 'optionalCall', _15 => _15(this.documentId, origin)]);
+    return true;
+  }
+  hasUnsaved() {
+    return this.handle.hasPending();
+  }
+  hasViews() {
+    return this.views.size > 0;
+  }
+  // ── realtime (snapshot inserts) ─────────────────────────────────────────
+  /** Opened once per document by the first view that asks; idempotent. */
+  connectRealtime(open) {
+    if (this.realtimeClose) return;
+    this.realtimeClose = open((snapshotId) => void this.onRemoteSnapshot(snapshotId));
+  }
+  /**
+   * A snapshot was committed (here or elsewhere): show a foreign one in every
+   * view. Over unsaved edits it is a CONFLICT — the working copy holds it and
+   * no save runs (one would overwrite the collaborator's snapshot) until the
+   * person chooses; `overUnsaved` is "Take theirs" (`./documentModels.ts`).
+   */
+  async onRemoteSnapshot(snapshotId, { overUnsaved = false } = {}) {
+    if (this.collab) return;
+    if (this.knownSnapshots.has(snapshotId)) return;
+    if (this.saving) return;
+    if (this.hasUnsaved() && !overUnsaved) {
+      this.handle.conflict({ ref: snapshotId });
+      return;
+    }
+    const row = await this.deps.loadLatest(this.documentId);
+    if (!row || this.hasUnsaved() && !overUnsaved || this.knownSnapshots.has(row.id)) return;
+    this.show(row);
+  }
+  /**
+   * THE content swap (see @ai-matrx/office/univer openEditorContent): a SAVED snapshot
+   * replaces the document in every view and the kept editor. It is the saved
+   * version from now on, so the pending save compares equal and writes
+   * nothing (it would put the old content back over the new). In a collab
+   * room the peers reload it and the shared log is emptied.
+   */
+  replaceContent(row) {
+    this.show(row);
+    _optionalChain([this, 'access', _16 => _16.collab, 'optionalAccess', _17 => _17.announceReplaced, 'call', _18 => _18(row.id)]);
+  }
+  /** A peer replaced the document: show the newest save (once). */
+  async onPeerReplaced() {
+    const row = await this.deps.loadLatest(this.documentId);
+    if (!row || this.knownSnapshots.has(row.id)) return;
+    this.show(row);
+  }
+  show(row) {
+    this.knownSnapshots.add(row.id);
+    this.savedFingerprint = contentFingerprint(row.snapshot);
+    this.stored = row.snapshot;
+    this.relaying = true;
+    try {
+      for (const view of this.views.values()) view.port.remount(row.snapshot);
+      _optionalChain([this, 'access', _19 => _19.parked, 'optionalAccess', _20 => _20.remount, 'call', _21 => _21(row.snapshot)]);
+    } finally {
+      this.relaying = false;
+    }
+  }
+  // ── collab (one room per document) ──────────────────────────────────────
+  /**
+   * The model's command stream as ONE command service — what the collab room
+   * binds to. Local edits from any view go out once; a peer's edit is applied
+   * to every view.
+   */
+  __init17() {this.virtualCommandService = {
+    onMutationExecutedForCollab: (listener) => {
+      this.collabListeners.add(listener);
+      return { dispose: () => this.collabListeners.delete(listener) };
+    },
+    syncExecuteCommand: (id, params) => {
+      const info = { id, type: 2, params };
+      this.relay(info, null);
+      if (isContentMutation(info)) this.markDirty();
+      return true;
+    }
+  }}
+  /** Join the document's collab room once (the first view that asks). */
+  startCollab(factory) {
+    if (this.collab) return Promise.resolve();
+    if (!this.collabStarting) {
+      this.collabStarting = factory(
+        this.virtualCommandService,
+        (awareness) => {
+          this.awareness = awareness;
+          for (const listener of Array.from(this.awarenessListeners)) listener();
+        },
+        () => {
+          void this.onPeerReplaced().catch(
+            (error) => console.warn(`[document-model] could not load ${this.documentId}'s replaced version`, error)
+          );
+        }
+      ).then((handle) => {
+        if (!handle) return;
+        if (this.views.size === 0) {
+          handle.stop();
+          return;
+        }
+        this.collab = handle;
+      }).finally(() => {
+        this.collabStarting = null;
+      });
+    }
+    return this.collabStarting;
+  }
+  isCollabHost() {
+    return this.collab ? this.collab.isHost() : true;
+  }
+  getAwareness() {
+    return this.awareness;
+  }
+  subscribeAwareness(listener) {
+    this.awarenessListeners.add(listener);
+    return () => this.awarenessListeners.delete(listener);
+  }
+  // ── lifecycle (driven by the record's session) ──────────────────────
+  /** A view arrived on a document with none. */
+  wake() {
+    if (!this.pageClose && this.deps.listenToPage) {
+      this.pageClose = this.deps.listenToPage({
+        flush: () => void this.handle.flush(),
+        hasUnsaved: () => this.hasUnsaved()
+      });
+    }
+  }
+  /**
+   * The last view left: leave the collab room (presence must not outlive the
+   * person). The snapshot channel stays open while the session is kept alive,
+   * so a collaborator's save still reaches the body a returning view boots from.
+   */
+  rest() {
+    _optionalChain([this, 'access', _22 => _22.collab, 'optionalAccess', _23 => _23.stop, 'call', _24 => _24()]);
+    this.collab = null;
+    this.awareness = null;
+  }
+  __init18() {this.closed = false}
+  close() {
+    this.closed = true;
+    const parked = this.parked;
+    this.parked = null;
+    if (parked) {
+      try {
+        parked.dispose();
+      } catch (error) {
+        console.warn(`[document-model] could not dispose ${this.documentId}'s kept editor`, error);
+      }
+    }
+    _optionalChain([this, 'access', _25 => _25.realtimeClose, 'optionalCall', _26 => _26()]);
+    this.realtimeClose = null;
+    _optionalChain([this, 'access', _27 => _27.pageClose, 'optionalCall', _28 => _28()]);
+    this.pageClose = null;
+  }
+}, _class);
+function contentFingerprint(snapshot) {
+  const { id: _id, rev: _rev, ...content } = snapshot;
+  return JSON.stringify(content);
+}
+function isContentMutation(info) {
+  return isSnapshotMutation({ id: info.id, type: info.type, params: info.params });
+}
+
+// src/docs/document-write-validation.ts
+var DOCUMENT_NAME_MAX_LENGTH = 255;
+var DOCUMENT_DESCRIPTION_MAX_LENGTH = 2e3;
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "object") return "an object";
+  return `a ${typeof value}`;
+}
+function validateDocumentName(value) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `document_name must be plain text, not JSON and not JSON-encoded \u2014 received ${describeValue(
+        value
+      )}. Send only the title itself (for example: Q3 Revenue Review) with no surrounding braces, brackets, quotes or escape sequences.`
+    );
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      "document_name cannot be empty or whitespace \u2014 a document must keep a title. Send the title text you want, or leave the current one alone."
+    );
+  }
+  if (/[\r\n]/.test(trimmed)) {
+    throw new Error(
+      "document_name must be a SINGLE line \u2014 it renders in the page header, and line breaks are not a title. Send one line of plain text (this is a title, not the document body)."
+    );
+  }
+  if (trimmed.length > DOCUMENT_NAME_MAX_LENGTH) {
+    throw new Error(
+      `document_name must be ${DOCUMENT_NAME_MAX_LENGTH} characters or fewer (received ${trimmed.length}). Shorten it to a title; the document body is not stored in this field.`
+    );
+  }
+  return trimmed;
+}
+function validateDocumentDescription(value) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `document_description must be plain text, not JSON and not JSON-encoded \u2014 received ${describeValue(
+        value
+      )}. Send only the description prose itself, with no surrounding braces, brackets, quotes or escape sequences.`
+    );
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.length > DOCUMENT_DESCRIPTION_MAX_LENGTH) {
+    throw new Error(
+      `document_description must be ${DOCUMENT_DESCRIPTION_MAX_LENGTH} characters or fewer (received ${trimmed.length}). This is the short blurb shown in the documents library, not the document body.`
+    );
+  }
+  return trimmed;
+}
+
+// src/docs/fit-zoom-ratio.ts
+var MIN_FIT_ZOOM = 0.45;
+function fitZoomRatio(containerWidth, pageWidth, gutter = 8) {
+  if (!(containerWidth > 0) || !(pageWidth > 0)) return 1;
+  const ratio = (containerWidth - gutter * 2) / pageWidth;
+  return Math.min(1, Math.max(MIN_FIT_ZOOM, Math.round(ratio * 100) / 100));
+}
+
+// src/docs/documents-hub-display.ts
+var SOURCE_LABELS = {
+  created: "Created",
+  imported_docx: "Imported DOCX",
+  imported_md: "Imported Markdown",
+  imported_txt: "Imported Text",
+  linked_gdoc: "Imported from Google Docs"
+};
+function documentSourceLabel(source) {
+  return _nullishCoalesce(SOURCE_LABELS[source], () => ( source));
+}
+
+// src/docs/doc-symbols.ts
+var e = (rows) => rows.split("|").map((r) => r.trim()).filter(Boolean).map((r) => {
+  const [char, ...name] = r.split(" ");
+  return { char, name: name.join(" ") };
+});
+var EMOJI_GROUPS = [
+  { id: "faces", label: "Faces", items: e("\u{1F600} grinning|\u{1F603} smile|\u{1F604} happy|\u{1F601} beaming|\u{1F606} laughing|\u{1F605} sweat smile|\u{1F602} tears of joy|\u{1F923} rolling|\u{1F642} slight smile|\u{1F643} upside down|\u{1F609} wink|\u{1F60A} blush|\u{1F607} angel|\u{1F970} love|\u{1F60D} heart eyes|\u{1F929} star struck|\u{1F618} kiss|\u{1F60B} yum|\u{1F60E} cool|\u{1F913} nerd|\u{1F914} thinking|\u{1F928} skeptical|\u{1F610} neutral|\u{1F644} eye roll|\u{1F62C} grimace|\u{1F634} sleeping|\u{1F622} cry|\u{1F62D} sobbing|\u{1F624} huff|\u{1F621} angry|\u{1F92F} mind blown|\u{1F631} scream|\u{1F973} party|\u{1F917} hug|\u{1FAE1} salute|\u{1F62E} surprised|\u{1F633} flushed|\u{1F97A} pleading|\u{1F637} mask|\u{1F912} sick") },
+  { id: "people", label: "Gestures", items: e("\u{1F44D} thumbs up|\u{1F44E} thumbs down|\u{1F44F} clap|\u{1F64C} raised hands|\u{1F64F} pray thanks|\u{1F91D} handshake|\u{1F4AA} strong flex|\u{1F44C} ok|\u270C victory peace|\u{1F91E} fingers crossed|\u{1F44B} wave|\u270B raised hand|\u{1F446} point up|\u{1F449} point right|\u{1F448} point left|\u{1F447} point down|\u270D writing|\u{1F937} shrug|\u{1F64B} raise hand|\u{1F440} eyes|\u{1F9E0} brain|\u2764 heart|\u{1F494} broken heart|\u{1F4AF} hundred") },
+  { id: "objects", label: "Objects", items: e("\u{1F4A1} idea light bulb|\u{1F4CC} pin|\u{1F4CE} paperclip|\u{1F4DD} memo note|\u{1F4C5} calendar|\u{1F4C8} chart up|\u{1F4C9} chart down|\u{1F4CA} bar chart|\u{1F4C1} folder|\u{1F4C4} page|\u{1F4E7} email|\u{1F4DE} phone|\u{1F4BB} laptop|\u{1F4F1} mobile|\u{1F512} lock|\u{1F511} key|\u{1F50D} search|\u{1F514} bell|\u23F0 alarm clock|\u231B hourglass|\u{1F3AF} target|\u{1F3C6} trophy|\u{1F381} gift|\u{1F4E6} package|\u{1F6E0} tools|\u2699 gear|\u{1F4B0} money bag|\u{1F4B5} dollar|\u{1F9FE} receipt|\u{1F4DA} books") },
+  { id: "symbols", label: "Marks", items: e("\u2705 check mark|\u274C cross|\u2B50 star|\u{1F31F} glowing star|\u2728 sparkles|\u{1F525} fire|\u26A1 lightning|\u{1F680} rocket|\u{1F389} party popper|\u{1F38A} confetti|\u26A0 warning|\u2753 question|\u2757 exclamation|\u2795 plus|\u2796 minus|\u{1F534} red circle|\u{1F7E0} orange circle|\u{1F7E1} yellow circle|\u{1F7E2} green circle|\u{1F535} blue circle|\u{1F7E3} purple circle|\u2B06 up|\u2B07 down|\u27A1 right|\u2B05 left|\u{1F501} repeat|\u2714 heavy check") },
+  { id: "nature", label: "Nature and food", items: e("\u{1F31E} sun|\u{1F319} moon|\u2601 cloud|\u{1F327} rain|\u2744 snowflake|\u{1F308} rainbow|\u{1F331} seedling|\u{1F333} tree|\u{1F338} blossom|\u{1F30D} earth|\u{1F436} dog|\u{1F431} cat|\u{1F98A} fox|\u{1F41D} bee|\u{1F98B} butterfly|\u{1F34E} apple|\u{1F355} pizza|\u{1F354} burger|\u2615 coffee|\u{1F37A} beer|\u{1F377} wine|\u{1F382} cake|\u{1F36A} cookie|\u{1F951} avocado") }
+];
+var s = (chars, names) => Array.from(chars).map((char, i) => ({ char, name: _nullishCoalesce(names[i], () => ( char)) }));
+var SPECIAL_GROUPS = [
+  { id: "punctuation", label: "Punctuation", items: s("\xA9\xAE\u2122\xB0\xA7\xB6\u2020\u2021\u2022\u2026\u2030\u2116\u2018\u2019\u201C\u201D\xAB\xBB\u2013\u2014\xA1\xBF\xB7", ["copyright", "registered", "trademark", "degree", "section", "pilcrow", "dagger", "double dagger", "bullet", "ellipsis", "per mille", "numero", "left single quote", "right single quote", "left double quote", "right double quote", "left guillemet", "right guillemet", "en dash", "em dash", "inverted exclamation", "inverted question", "middle dot"]) },
+  { id: "arrows", label: "Arrows", items: s("\u2190\u2191\u2192\u2193\u2194\u2195\u21D0\u21D1\u21D2\u21D3\u21D4\u21A9\u21AA\u279C\u27A4\u2196\u2197\u2198\u2199\u21BA\u21BB", ["left arrow", "up arrow", "right arrow", "down arrow", "left right arrow", "up down arrow", "left double arrow", "up double arrow", "right double arrow", "down double arrow", "left right double arrow", "return arrow", "hook arrow", "heavy arrow", "arrowhead", "north west arrow", "north east arrow", "south east arrow", "south west arrow", "anticlockwise arrow", "clockwise arrow"]) },
+  { id: "math", label: "Math", items: s("\xB1\xD7\xF7\u2248\u2260\u2264\u2265\u221E\u221A\u2211\u220F\u222B\u2202\u2206\u2207\u2208\u2209\u222A\u2229\u2282\u2283\u2227\u2228\xAC\u2200\u2203\u2205\u221D\u2220\xBC\xBD\xBE\u2153\u2154\xB2\xB3", ["plus minus", "times", "divide", "approximately", "not equal", "less or equal", "greater or equal", "infinity", "square root", "sum", "product", "integral", "partial", "increment", "nabla", "element of", "not element", "union", "intersection", "subset", "superset", "and", "or", "not", "for all", "exists", "empty set", "proportional", "angle", "one quarter", "one half", "three quarters", "one third", "two thirds", "squared", "cubed"]) },
+  { id: "currency", label: "Currency", items: s("$\u20AC\xA3\xA5\xA2\u20B9\u20A9\u20BD\u20BA\u20BF\u0E3F\u20AB\u20AA\u20B4\u20A6\u20B1", ["dollar", "euro", "pound", "yen", "cent", "rupee", "won", "ruble", "lira", "bitcoin", "baht", "dong", "shekel", "hryvnia", "naira", "peso"]) },
+  { id: "greek", label: "Greek", items: s("\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03A9\u03A3\u0394\u03A0\u03A6\u03A8\u039B\u0398", ["alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", "iota", "kappa", "lambda", "mu", "nu", "xi", "omicron", "pi", "rho", "sigma", "tau", "upsilon", "phi", "chi", "psi", "omega", "capital omega", "capital sigma", "capital delta", "capital pi", "capital phi", "capital psi", "capital lambda", "capital theta"]) },
+  { id: "latin", label: "Accented letters", items: s("\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF1\xF2\xF3\xF4\xF5\xF6\xF8\u0153\xF9\xFA\xFB\xFC\xFD\xFF\xDF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD1\xD2\xD3\xD4\xD5\xD6\xD8\u0152\xD9\xDA\xDB\xDC\xDD\u0178", []) },
+  { id: "shapes", label: "Shapes", items: s("\u25A0\u25A1\u25B2\u25B3\u25BC\u25BD\u25C6\u25C7\u25CF\u25CB\u2605\u2606\u2660\u2663\u2665\u2666\u266A\u266B\u2611\u2612", ["black square", "white square", "black up triangle", "white up triangle", "black down triangle", "white down triangle", "black diamond", "white diamond", "black circle", "white circle", "black star", "white star", "spade", "club", "heart suit", "diamond suit", "eighth note", "beamed notes", "checked box", "crossed box"]) }
+];
+function searchSymbols(groups, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const g of groups) for (const it of g.items) if ((it.char === q || it.name.toLowerCase().includes(q)) && !seen.has(it.char)) seen.add(it.char), out.push(it);
+  return out;
+}
+
+// src/docs/document-body-text.ts
+var DOCUMENT_BODY_MAX_LENGTH = 2e5;
+var PARAGRAPH = "\r";
+var SECTION = "\n";
+function bodyTextOf(dataStream) {
+  let text = "";
+  const offsets = [];
+  for (let i = 0; i < dataStream.length; i++) {
+    const ch = dataStream[i];
+    if (ch === PARAGRAPH) {
+      text += "\n";
+      offsets.push(i);
+      continue;
+    }
+    if (ch === SECTION) continue;
+    if (ch !== "	" && ch.charCodeAt(0) < 32) continue;
+    text += ch;
+    offsets.push(i);
+  }
+  if (text.endsWith("\n")) {
+    const end = offsets[offsets.length - 1];
+    text = text.slice(0, -1);
+    offsets.pop();
+    offsets.push(end);
+  } else {
+    offsets.push(dataStream.length);
+  }
+  return { text, offsets };
+}
+function planBodyEdit(current, next) {
+  const a = current.text;
+  const b = next;
+  if (a === b) return null;
+  let prefix = 0;
+  const max = Math.min(a.length, b.length);
+  while (prefix < max && a[prefix] === b[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < max - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix])
+    suffix++;
+  const removeTo = a.length - suffix;
+  return {
+    start: current.offsets[prefix],
+    end: current.offsets[removeTo],
+    insert: b.slice(prefix, b.length - suffix)
+  };
+}
+function writeBodyText(port, next) {
+  const current = bodyTextOf(port.getDataStream());
+  const edit = planBodyEdit(current, next);
+  if (!edit) return { changed: false, removed: 0, inserted: 0 };
+  if (edit.end > edit.start && !port.deleteRange(edit.start, edit.end)) {
+    throw new Error(
+      "The editor refused to remove the old text (the document may be read-only right now). Nothing was changed."
+    );
+  }
+  if (edit.insert.length > 0 && !port.insertText(edit.start, edit.insert)) {
+    throw new Error(
+      edit.end > edit.start ? "The editor removed the old text but refused the new text. Press Undo in the document to bring the old text back, then try again." : "The editor refused the new text (the document may be read-only right now). Nothing was changed."
+    );
+  }
+  return {
+    changed: true,
+    removed: edit.end - edit.start,
+    inserted: edit.insert.length
+  };
+}
+function describeValue2(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "object") return "an object";
+  return `a ${typeof value}`;
+}
+function validateDocumentBody(value) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `document_body must be the document's whole text as a plain string (or an anchored edit {command, old_str, new_str}) \u2014 received ${describeValue2(
+        value
+      )}. Read document_body_text, change it, and send the full new text.`
+    );
+  }
+  if (value.length > DOCUMENT_BODY_MAX_LENGTH) {
+    throw new Error(
+      `document_body must be ${DOCUMENT_BODY_MAX_LENGTH} characters or fewer (received ${value.length}). Nothing was changed.`
+    );
+  }
+  return value.replace(/\r\n?/g, "\n");
+}
+function documentBodyWriteHandler(deps) {
+  return {
+    validate: (value) => {
+      validateDocumentBody(value);
+    },
+    apply: (value) => {
+      const next = validateDocumentBody(value);
+      deps.assertWritable("its text cannot be changed");
+      const port = deps.getPort();
+      if (!port) {
+        throw new Error(
+          "The document editor has not finished opening yet. Nothing was changed; try again in a moment."
+        );
+      }
+      const result = writeBodyText(port, next);
+      if (!result.changed) {
+        return { summary: "The document already has exactly this text; nothing changed." };
+      }
+      return {
+        summary: `Changed the document's text in the editor (removed ${result.removed} characters, inserted ${result.inserted}); the editor saves it within a few seconds, and Undo in the document reverses it.`,
+        data: { removed: result.removed, inserted: result.inserted }
+      };
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DOCUMENT_BODY_MAX_LENGTH = DOCUMENT_BODY_MAX_LENGTH; exports.DOCUMENT_DESCRIPTION_MAX_LENGTH = DOCUMENT_DESCRIPTION_MAX_LENGTH; exports.DOCUMENT_NAME_MAX_LENGTH = DOCUMENT_NAME_MAX_LENGTH; exports.DOCUMENT_SAVE_DELAY_MS = DOCUMENT_SAVE_DELAY_MS; exports.DocumentModel = DocumentModel; exports.EMOJI_GROUPS = EMOJI_GROUPS; exports.MIN_FIT_ZOOM = MIN_FIT_ZOOM; exports.SPECIAL_GROUPS = SPECIAL_GROUPS; exports.bodyTextOf = bodyTextOf; exports.configureDocsHost = _chunkBWMAYLW4cjs.configureDocsHost; exports.copyDocument = _chunkBWMAYLW4cjs.copyDocument; exports.createDocument = _chunkBWMAYLW4cjs.createDocument; exports.deleteDocument = _chunkBWMAYLW4cjs.deleteDocument; exports.discardFailedDocument = _chunkBWMAYLW4cjs.discardFailedDocument; exports.documentBodyWriteHandler = documentBodyWriteHandler; exports.documentSourceLabel = documentSourceLabel; exports.fitZoomRatio = fitZoomRatio; exports.getDocsHost = _chunkBWMAYLW4cjs.getDocsHost; exports.getDocument = _chunkBWMAYLW4cjs.getDocument; exports.getLatestDocumentSnapshot = _chunkBWMAYLW4cjs.getLatestDocumentSnapshot; exports.listAccessibleDocuments = _chunkBWMAYLW4cjs.listAccessibleDocuments; exports.listDocumentSnapshots = _chunkBWMAYLW4cjs.listDocumentSnapshots; exports.listTrashedDocuments = _chunkBWMAYLW4cjs.listTrashedDocuments; exports.moveDocument = _chunkBWMAYLW4cjs.moveDocument; exports.planBodyEdit = planBodyEdit; exports.renameDocument = _chunkBWMAYLW4cjs.renameDocument; exports.restoreDocument = _chunkBWMAYLW4cjs.restoreDocument; exports.sanitizeUniverDocSnapshot = _chunkBWMAYLW4cjs.sanitizeUniverDocSnapshot; exports.saveDocumentSnapshot = _chunkBWMAYLW4cjs.saveDocumentSnapshot; exports.searchSymbols = searchSymbols; exports.updateDocumentDescription = _chunkBWMAYLW4cjs.updateDocumentDescription; exports.validateDocumentBody = validateDocumentBody; exports.validateDocumentDescription = validateDocumentDescription; exports.validateDocumentName = validateDocumentName; exports.writeBodyText = writeBodyText;
+//# sourceMappingURL=docs.cjs.map