annotation-kit 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,910 @@
+import { e as errorEn, a as errorZh, A as AnnotationError, b as annotationFailure, p as pageImageStore, s as selectedFiles, i as imageDrafts } from "./chunks/references-ukB-tSle.js";
+import { c, d, f, D, F, M, P, g, R, h, j, k, l, m, n, o, q, r, t, u, v, w, x, y, z, B, C, E, G, H, I, J, K, L, N, O, Q, S, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 } from "./chunks/references-ukB-tSle.js";
+const documentEn = {
+  "page.request": "Request edits",
+  "page.ask": "Ask for change",
+  "page.placeholder": "Describe a change or ask a question",
+  "page.pick": "Select content and ask for changes",
+  "page.comment": "Comment",
+  "page.edit": "Edit annotation",
+  "page.delete": "Delete annotation",
+  "page.one": "annotation",
+  "page.many": "annotations",
+  "page.cancel": "Cancel",
+  "page.save": "Save",
+  "page.send": "Send",
+  "page.sending": "Sending…",
+  "page.senderUnavailable": "Document annotations cannot be sent in this session.",
+  "page.changes": "Describe your changes…",
+  "page.submit": "Submit requested changes"
+};
+const zh = {
+  ...errorZh,
+  "response.title": "回复批注",
+  "response.add": "添加到会话",
+  "response.placeholder": "添加可选评论…",
+  "response.selected": "所选文字",
+  "response.source": "查看原回复",
+  "response.edit": "编辑批注",
+  "response.location": "助手回复",
+  "response.save": "保存评论",
+  "sheet.unavailable": "来源文件暂不可用。以下选区保留了保存时的内容，仍可查看或发送。",
+  "sheet.cell": "单元格",
+  "sheet.value": "保存时的值",
+  "sheet.formula": "公式",
+  "sheet.raw": "原始值",
+  "sheet.empty": "空值",
+  "page.request": "请求修改",
+  "page.ask": "提出修改",
+  "page.placeholder": "描述修改或提出问题",
+  "page.pick": "选择内容并提出修改",
+  "page.comment": "添加批注",
+  "page.edit": "编辑批注",
+  "page.delete": "删除批注",
+  "page.one": "条批注",
+  "page.many": "条批注",
+  "page.cancel": "取消",
+  "page.save": "保存",
+  "page.send": "发送",
+  "page.sending": "正在发送…",
+  "page.changes": "描述你希望的修改…",
+  "page.submit": "提交修改请求",
+  "page.senderUnavailable": "当前会话不支持发送文档批注。",
+  "page.region": "框选区域",
+  "page.regionHint": "在页面上拖动，选择要加入聊天的区域",
+  "page.restoring": "正在恢复区域图片…",
+  "page.imageMissing": "区域图片不可用",
+  "page.officePage": "页码对应当前文档预览",
+  "file.one": "个选区",
+  "file.many": "个选区",
+  "file.selections": "所选文本",
+  "file.remove": "移除选区",
+  "file.removeAll": "移除全部选区",
+  "file.openSource": "打开来源文件",
+  "file.openFailed": "无法打开来源文件，已保存的选区仍可查看。",
+  "file.sourceBlock": "所示行号为来源段落范围",
+  "file.snapshot": "保留添加时的内容",
+  "message.expand": "展开",
+  "message.collapse": "收起",
+  "message.evidence": "查看发送给模型的完整上下文",
+  adjust: "调整选区",
+  cancel: "取消",
+  placeholder: "添加评论…",
+  annotating: "批注中",
+  send: "发送",
+  "packet.one": "条批注",
+  "packet.many": "条批注",
+  "packet.edit": "编辑批注",
+  "packet.removeAll": "移除全部批注",
+  annotate: "批注",
+  element: "选择元素",
+  region: "选择区域",
+  close: "结束批注",
+  pick: "点击元素或拖出区域以添加评论。",
+  comment: "评论",
+  save: "保存",
+  saving: "正在截图…",
+  add: "加入聊天",
+  adding: "正在添加…",
+  delete: "删除",
+  noSession: "请先打开一个会话。",
+  empty: "尚未保存批注。",
+  saved: "已保存批注",
+  screenshot: "保存时自动截取页面。",
+  selection: "已选择目标",
+  "packet.title": "网页批注",
+  "packet.screenshot": "批注截图",
+  "packet.done": "完成",
+  "packet.remove": "移除批注",
+  "file.add": "加入聊天",
+  "file.adding": "正在添加…",
+  "file.addTitle": "把所选内容加入当前会话",
+  "file.openSession": "请先打开会话",
+  "file.addFailed": "添加选区失败"
+};
+const en = {
+  ...errorEn,
+  "response.title": "Response annotations",
+  "response.add": "Add to chat",
+  "response.placeholder": "Add an optional comment…",
+  "response.selected": "Selected text",
+  "response.source": "View original response",
+  "response.edit": "Edit annotation",
+  "response.location": "Assistant response",
+  "response.save": "Save comment",
+  "sheet.unavailable": "The source is unavailable. These saved selections can still be reviewed or sent.",
+  "sheet.cell": "Cell",
+  "sheet.value": "Saved value",
+  "sheet.formula": "Formula",
+  "sheet.raw": "Raw value",
+  "sheet.empty": "Empty",
+  ...documentEn,
+  "page.region": "Select region",
+  "page.regionHint": "Drag on a page to select a region for chat",
+  "page.restoring": "Restoring region image…",
+  "page.imageMissing": "Region image unavailable",
+  "page.officePage": "Page numbers refer to the document preview",
+  "file.one": "selection",
+  "file.many": "selections",
+  "file.selections": "Selected text",
+  "file.remove": "Remove selection",
+  "file.removeAll": "Remove all selections",
+  "file.openSource": "Open source file",
+  "file.openFailed": "Could not open the source. The saved selection is still available.",
+  "file.sourceBlock": "Lines refer to the source block",
+  "file.snapshot": "Content saved when added",
+  "message.expand": "Expand",
+  "message.collapse": "Collapse",
+  "message.evidence": "View full context sent to the model",
+  adjust: "Adjust",
+  cancel: "Cancel",
+  placeholder: "Add a comment…",
+  annotating: "Annotating",
+  send: "Send",
+  "packet.one": "annotation",
+  "packet.many": "annotations",
+  "packet.edit": "Edit annotation",
+  "packet.removeAll": "Remove all annotations",
+  annotate: "Annotate",
+  element: "Select element",
+  region: "Select region",
+  close: "End annotations",
+  pick: "Click an element or drag a region to add a comment.",
+  comment: "Comment",
+  save: "Save",
+  saving: "Capturing…",
+  add: "Add to chat",
+  adding: "Adding…",
+  delete: "Delete",
+  noSession: "Open a conversation first.",
+  empty: "No saved annotations.",
+  saved: "Saved annotations",
+  screenshot: "Saving captures the page automatically.",
+  selection: "Target selected",
+  "packet.title": "Browser comments",
+  "packet.screenshot": "Annotation screenshot",
+  "packet.done": "Done",
+  "packet.remove": "Remove comments",
+  "file.add": "Add to chat",
+  "file.adding": "Adding…",
+  "file.addTitle": "Add the selection to the current conversation",
+  "file.openSession": "Open a conversation first",
+  "file.addFailed": "Could not add the selection"
+};
+const emptyState = { drafts: {} };
+class AnnotationsModel {
+  constructor(desktop, composer, leaseOf = (surface) => {
+    const viewport = document.getElementById(surface.viewportId);
+    return viewport?.querySelector("webview")?.getAttribute("name") ?? void 0;
+  }) {
+    this.desktop = desktop;
+    this.composer = composer;
+    this.leaseOf = leaseOf;
+    this.unsubscribe = desktop?.subscribe((event) => this.receive(event)) ?? (() => {
+    });
+  }
+  state = emptyState;
+  listeners = /* @__PURE__ */ new Set();
+  surfaces = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new Map();
+  alive = true;
+  nextId = 1;
+  visibleMarkers = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Map();
+  unsubscribe;
+  getSnapshot = () => this.state;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  refresh = () => {
+    for (const [id, draft] of Object.entries(this.state.drafts)) {
+      if (draft.selection && draft.target !== this.composer.targetKey()) {
+        this.nextOperation(id);
+        this.update(id, { ...draft, selection: void 0, saving: false, comment: "", error: void 0 });
+      }
+    }
+    this.publish({ ...this.state });
+  };
+  available(surface) {
+    return this.alive && this.desktop?.protocolVersion === 1 && surface.enabled && !surface.signal?.aborted;
+  }
+  hasTarget() {
+    return this.composer.hasTarget();
+  }
+  controls() {
+    return this.composer.annotationControls?.();
+  }
+  markerVisible(id) {
+    return this.visibleMarkers.has(id);
+  }
+  edit = (entry, commit) => {
+    const surface = entry.surfaceId ? this.surfaces.get(entry.surfaceId) : void 0;
+    if (!surface || !this.available(surface) || surface.url !== entry.selection.url || !this.visibleMarkers.has(entry.id)) return false;
+    const draft = this.state.drafts[surface.id];
+    if (!draft?.active) return false;
+    this.update(surface.id, {
+      ...draft,
+      selection: entry.selection,
+      comment: entry.comment,
+      target: this.composer.targetKey(),
+      editing: { entry, commit },
+      error: void 0
+    });
+    return true;
+  };
+  async toggle(surface) {
+    const draft = this.state.drafts[surface.id];
+    if (draft?.active) {
+      this.nextOperation(surface.id);
+      this.update(surface.id, { ...draft, active: false, selection: void 0, saving: false, comment: "" });
+      await this.desktop?.setMode(draft.lease, "off").catch(() => {
+      });
+      return;
+    }
+    if (!this.available(surface)) return;
+    const lease = this.leaseOf(surface);
+    const operation = this.nextOperation(surface.id);
+    this.surfaces.set(surface.id, surface);
+    const starting = {
+      active: true,
+      mode: "element",
+      lease: lease ?? "",
+      epoch: "",
+      comment: draft?.comment ?? "",
+      saving: false
+    };
+    this.update(surface.id, starting);
+    if (!lease) {
+      this.update(surface.id, { ...starting, error: new AnnotationError("error.browserNotReady") });
+      return;
+    }
+    try {
+      const response = await this.desktop.setMode(lease, "element");
+      const latest = this.currentOperation(surface, operation, lease);
+      if (latest) this.update(surface.id, { ...latest, epoch: response.documentEpoch, error: void 0 });
+    } catch (error) {
+      const latest = this.currentOperation(surface, operation, lease);
+      if (latest) this.update(surface.id, { ...latest, error: annotationFailure(error) });
+    }
+  }
+  async setMode(surface, mode) {
+    const current = this.state.drafts[surface.id];
+    if (!current?.active || current.saving || !this.available(surface)) return;
+    const operation = this.nextOperation(surface.id);
+    try {
+      const response = await this.desktop.setMode(current.lease, mode);
+      const latest = this.currentOperation(surface, operation, current.lease);
+      if (latest) this.update(surface.id, { ...latest, mode, epoch: response.documentEpoch, selection: void 0, error: void 0 });
+    } catch (error) {
+      const latest = this.currentOperation(surface, operation, current.lease);
+      if (latest) this.update(surface.id, { ...latest, error: annotationFailure(error) });
+    }
+  }
+  setComment(surfaceId, comment) {
+    const draft = this.state.drafts[surfaceId];
+    if (draft) this.update(surfaceId, { ...draft, comment });
+  }
+  cancel(surfaceId) {
+    const draft = this.state.drafts[surfaceId];
+    if (!draft) return;
+    this.nextOperation(surfaceId);
+    this.update(surfaceId, { ...draft, selection: void 0, comment: "", saving: false, editing: void 0, error: void 0 });
+    void this.desktop?.setMode(draft.lease, draft.mode).catch(() => {
+    });
+  }
+  async save(surface) {
+    const draft = this.state.drafts[surface.id];
+    if (!draft?.selection || !draft.epoch || draft.saving || !draft.comment.trim() || !this.available(surface)) return;
+    const operation = this.operations.get(surface.id);
+    if (!draft.target || draft.target !== this.composer.targetKey()) {
+      this.update(surface.id, { ...draft, error: new AnnotationError("error.originalSession") });
+      return;
+    }
+    if (draft.editing) {
+      draft.editing.commit(draft.comment);
+      this.cancel(surface.id);
+      return;
+    }
+    const controller = new AbortController();
+    this.pending.set(surface.id, controller);
+    const id = this.nextId++;
+    const pending = { ...draft, saving: true, error: void 0 };
+    this.update(surface.id, pending);
+    try {
+      const captured = await this.desktop.capture(draft.lease, draft.epoch, draft.selection, id);
+      const latest = operation === void 0 ? void 0 : this.currentOperation(surface, operation, draft.lease);
+      if (!latest?.saving || latest.epoch !== draft.epoch) return;
+      const image = new File([new Uint8Array(captured.png)], `annotation-${crypto.randomUUID()}-${id}.png`, { type: "image/png" });
+      const entry = { id, source: surface.source, surfaceId: surface.id, selection: draft.selection, comment: draft.comment, image };
+      await this.composer.add({
+        text: "",
+        annotations: [entry],
+        images: [image],
+        expectedTarget: draft.target,
+        signal: controller.signal,
+        focus: false
+      });
+      if (controller.signal.aborted || !this.currentOperation(surface, operation, draft.lease)) return;
+      this.visibleMarkers.add(id);
+      this.update(surface.id, { ...latest, saving: false, selection: void 0, comment: "" });
+      void this.desktop?.setMode(draft.lease, draft.mode).catch(() => {
+      });
+    } catch (error) {
+      const latest = operation === void 0 ? void 0 : this.currentOperation(surface, operation, draft.lease);
+      if (latest?.saving && latest.epoch === draft.epoch) this.update(surface.id, { ...latest, saving: false, error: annotationFailure(error) });
+    } finally {
+      if (this.pending.get(surface.id) === controller) this.pending.delete(surface.id);
+    }
+  }
+  dispose() {
+    this.alive = false;
+    for (const controller of this.pending.values()) controller.abort();
+    this.pending.clear();
+    this.unsubscribe();
+    for (const draft of Object.values(this.state.drafts)) {
+      if (draft.active && draft.lease) void this.desktop?.setMode(draft.lease, "off").catch(() => {
+      });
+    }
+    this.listeners.clear();
+    this.surfaces.clear();
+    this.operations.clear();
+    this.state = emptyState;
+  }
+  receive(event) {
+    if (!this.alive) return;
+    if (event.kind === "identity-cleared") {
+      const drafts = { ...this.state.drafts };
+      for (const [id, surface] of this.surfaces) if (surface.source === event.source) {
+        this.nextOperation(id);
+        delete drafts[id];
+        this.surfaces.delete(id);
+      }
+      this.publish({ ...this.state, drafts });
+      return;
+    }
+    for (const [id, draft] of Object.entries(this.state.drafts)) {
+      if (draft.lease !== event.lease) continue;
+      if (event.kind !== "selection") {
+        for (const entry of this.controls()?.entries ?? []) if (entry.surfaceId === id) this.visibleMarkers.delete(entry.id);
+        this.nextOperation(id);
+        this.update(id, {
+          ...draft,
+          active: event.kind === "selection-cleared" && draft.active,
+          selection: void 0,
+          saving: false,
+          editing: void 0,
+          epoch: event.documentEpoch
+        });
+      } else if (draft.active && !draft.saving && draft.epoch === event.documentEpoch) {
+        this.update(id, { ...draft, selection: event.selection, target: this.composer.targetKey(), comment: "", editing: void 0, error: void 0 });
+      }
+    }
+  }
+  update(id, draft) {
+    this.publish({ ...this.state, drafts: { ...this.state.drafts, [id]: draft } });
+  }
+  nextOperation(id) {
+    this.pending.get(id)?.abort();
+    this.pending.delete(id);
+    const next = (this.operations.get(id) ?? 0) + 1;
+    this.operations.set(id, next);
+    return next;
+  }
+  currentOperation(surface, operation, lease) {
+    const draft = this.state.drafts[surface.id];
+    return this.alive && !surface.signal?.aborted && this.operations.get(surface.id) === operation && draft?.active && draft.lease === lease ? draft : void 0;
+  }
+  publish(state) {
+    if (!this.alive) return;
+    this.state = state;
+    for (const listener of this.listeners) listener();
+  }
+}
+function commitToComposer(actions, text, ids, current, release, insert) {
+  let attached = false;
+  try {
+    if (!current()) throw new AnnotationError("error.sessionChangedAdd");
+    if (ids.length > 0 && !actions.addAttachments(ids)) throw new AnnotationError("error.composerImages");
+    attached = ids.length > 0;
+    if (!current()) throw new AnnotationError("error.sessionChangedAdd");
+    const span = actions.captureInsertion();
+    if (!current()) throw new AnnotationError("error.sessionChangedAdd");
+    if (!(insert ? insert(span) : actions.insertText(text, span))) throw new AnnotationError("error.draftChanged");
+  } catch (error) {
+    if (attached) for (const id of ids) actions.removeAttachment(id);
+    for (const id of ids) release(id);
+    throw error;
+  }
+}
+function bindReferencePresentation(card, input, owns) {
+  const nodes = /* @__PURE__ */ new Set();
+  const editors = /* @__PURE__ */ new Set();
+  const sync = () => {
+    const indexes = /* @__PURE__ */ new Map();
+    for (const node of card.querySelectorAll("[data-composer-chip]")) {
+      const source = node.dataset.composerChip;
+      const index = indexes.get(source) ?? 0;
+      indexes.set(source, index + 1);
+      const ref = input.occurrences.filter((item) => item.source === source)[index];
+      const owned = !!ref && owns(source, ref.ref);
+      if (owned || nodes.has(node)) node.toggleAttribute("data-aione-annotation-owned", owned);
+      if (owned) nodes.add(node);
+    }
+    const refs = input.occurrences.filter((item) => owns(item.source, item.ref));
+    let visibleText = input.draft;
+    for (const ref of [...refs].reverse()) visibleText = visibleText.slice(0, ref.offset) + visibleText.slice(ref.offset + ref.length);
+    const editor = card.querySelector('[contenteditable="true"]');
+    if (editor) {
+      editors.add(editor);
+      editor.toggleAttribute("data-aione-annotation-only", refs.length > 0 && !visibleText.trim());
+    }
+  };
+  sync();
+  const observer = new MutationObserver(sync);
+  observer.observe(card, { childList: true, subtree: true });
+  return () => {
+    observer.disconnect();
+    nodes.forEach((node) => node.removeAttribute("data-aione-annotation-owned"));
+    editors.forEach((editor) => editor.removeAttribute("data-aione-annotation-only"));
+  };
+}
+class PageImages {
+  constructor(store = pageImageStore()) {
+    this.store = store;
+  }
+  entries = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  disposed = false;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => this.revision;
+  changed() {
+    this.revision++;
+    for (const listener of this.listeners) listener();
+  }
+  preview(snapshot) {
+    return this.entries.get(snapshot.id);
+  }
+  async save(snapshot, file, signal) {
+    if (!snapshot.image || file.name !== snapshot.image.name || file.type !== "image/png") throw new AnnotationError("error.pageImageMismatch");
+    signal?.throwIfAborted();
+    await this.store.put(snapshot.id, file);
+    if (signal?.aborted || this.disposed) {
+      await this.store.remove(snapshot.id);
+      throw new AnnotationError("error.cancelled");
+    }
+  }
+  stage(session, snapshot, file, factory, ids) {
+    this.entries.set(snapshot.id, { session, snapshot, file, factory, ids, staged: true, url: URL.createObjectURL(file) });
+  }
+  activate(id) {
+    const entry = this.entries.get(id);
+    if (entry) entry.staged = false;
+    this.changed();
+  }
+  validate(snapshot) {
+    if (snapshot.version !== 2 || !snapshot.image) return;
+    const entry = this.entries.get(snapshot.id);
+    if (!entry?.file || entry.ids.length !== 1 || entry.factory.resolveDraftAttachments(entry.ids)[0]?.file !== entry.file) {
+      throw entry?.error ?? new AnnotationError("error.imageRestoring");
+    }
+  }
+  imageIdsFor(input) {
+    return new Set(input ? selectedFiles(input).flatMap(({ snapshot }) => this.entries.get(snapshot.id)?.ids ?? []) : []);
+  }
+  reconcile(session, input, actions, factory) {
+    if (this.disposed || input.phase !== "plain") return;
+    const active = new Map(selectedFiles(input).flatMap(({ snapshot }) => snapshot.version === 2 && snapshot.image ? [[snapshot.id, snapshot]] : []));
+    for (const [id, snapshot] of active) {
+      if (this.entries.has(id)) continue;
+      const entry = { session, snapshot, factory, ids: [], staged: false };
+      this.entries.set(id, entry);
+      void this.store.get(id, snapshot.image.name).then((file) => {
+        if (this.disposed || this.entries.get(id) !== entry) return;
+        if (!file) throw new AnnotationError("error.imageDraftLost");
+        entry.file = file;
+        entry.url = URL.createObjectURL(file);
+        this.changed();
+      }).catch((error) => {
+        if (this.disposed || this.entries.get(id) !== entry) return;
+        entry.error = error instanceof Error ? error : new AnnotationError("error.restoreImage");
+        this.changed();
+      });
+    }
+    for (const [id, entry] of this.entries) {
+      if (entry.session !== session || entry.staged) continue;
+      if (active.has(id)) {
+        if (entry.file && !entry.ids.length && !entry.error) {
+          entry.staged = true;
+          try {
+            const ids = imageDrafts(factory, session, [entry.file]);
+            entry.ids = ids;
+            if (!actions.addAttachments(ids)) throw new AnnotationError("error.restoreAttachmentRetry");
+          } catch (error) {
+            for (const imageId of entry.ids) factory.releaseDraftAttachment(imageId);
+            entry.ids = [];
+            entry.error = error instanceof Error ? error : new AnnotationError("error.restoreAttachment");
+          } finally {
+            entry.staged = false;
+          }
+          this.changed();
+        }
+      } else if (entry.ids.some((imageId) => input.attachmentIds.includes(imageId))) {
+        const ids = entry.ids;
+        entry.ids = [];
+        for (const imageId of ids) {
+          actions.removeAttachment(imageId);
+          factory.releaseDraftAttachment(imageId);
+        }
+        this.changed();
+      } else if (entry.ids.length && !factory.resolveDraftAttachments(entry.ids).length) {
+        this.discard(id);
+        void this.store.remove(id).catch(() => void 0);
+      }
+    }
+  }
+  discard(id) {
+    const entry = this.entries.get(id);
+    if (entry?.url) URL.revokeObjectURL(entry.url);
+    this.entries.delete(id);
+    this.changed();
+  }
+  async cancel(id) {
+    this.discard(id);
+    await this.store.remove(id);
+  }
+  dispose() {
+    this.disposed = true;
+    for (const entry of this.entries.values()) if (entry.url) URL.revokeObjectURL(entry.url);
+    this.entries.clear();
+    this.listeners.clear();
+  }
+}
+const excluded = 'button,input,textarea,select,svg,script,style,[role="button"],[aria-hidden="true"],[hidden],[inert],[data-code-block-banner],[data-response-annotation-ui]';
+const blocks = /^(P|DIV|LI|UL|OL|BLOCKQUOTE|PRE|H[1-6]|TR|TABLE|SECTION)$/u;
+function projectResponseText(root) {
+  let text = "";
+  const segments = [];
+  const separator = (value) => {
+    if (text && !text.endsWith(value)) text += value;
+  };
+  const visit = (node) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const value = node.textContent ?? "";
+      if (value) {
+        segments.push({ node, start: text.length, end: text.length + value.length });
+        text += value;
+      }
+      return;
+    }
+    if (!(node instanceof HTMLElement) || node.matches(excluded)) return;
+    const style = getComputedStyle(node);
+    if (style.display === "none" || style.visibility === "hidden") return;
+    if (node.tagName === "BR") {
+      text += "\n";
+      return;
+    }
+    if (blocks.test(node.tagName)) separator("\n");
+    if (node.tagName === "TD" || node.tagName === "TH") separator("	");
+    node.childNodes.forEach(visit);
+    if (blocks.test(node.tagName)) separator("\n");
+  };
+  root.childNodes.forEach(visit);
+  return { text: text.slice(0, segments.at(-1)?.end ?? 0), segments };
+}
+function prefixHash(text) {
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index++) hash = Math.imul(hash ^ text.charCodeAt(index), 16777619);
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function sliceRange(range, segment) {
+  const nodeRange = document.createRange();
+  nodeRange.selectNodeContents(segment.node);
+  if (range.compareBoundaryPoints(Range.END_TO_START, nodeRange) >= 0 || range.compareBoundaryPoints(Range.START_TO_END, nodeRange) <= 0) return void 0;
+  const start = range.startContainer === segment.node ? range.startOffset : 0;
+  const end = range.endContainer === segment.node ? range.endOffset : segment.node.length;
+  return end > start ? { start: segment.start + start, end: segment.start + end } : void 0;
+}
+function readResponseSelection(range, surfaces, sessionId) {
+  if (range.collapsed) return void 0;
+  const first = surfaces.find((surface) => surface.root.contains(range.startContainer));
+  const last = surfaces.find((surface) => surface.root.contains(range.endContainer));
+  if (!first || !last || first.source.sessionId !== sessionId || last.source.sessionId !== sessionId || first.source.nodeKey !== last.source.nodeKey) return void 0;
+  const selected = surfaces.filter((surface) => surface.source.sessionId === sessionId && surface.source.nodeKey === first.source.nodeKey && range.intersectsNode(surface.root)).sort((a, b) => a.source.blockIndex - b.source.blockIndex);
+  const anchors = [];
+  const ranges = [];
+  for (const surface of selected) {
+    const projection = projectResponseText(surface.root);
+    const portions = projection.segments.flatMap((segment) => {
+      const portion = sliceRange(range, segment);
+      return portion ? [portion] : [];
+    });
+    if (!portions.length) continue;
+    const start = portions[0].start;
+    const end = portions.at(-1).end;
+    const anchor = {
+      blockIndex: surface.source.blockIndex,
+      start,
+      end,
+      text: projection.text.slice(start, end),
+      prefixHash: prefixHash(projection.text.slice(0, end))
+    };
+    anchors.push(anchor);
+    ranges.push(...rangesForAnchor(projection, anchor));
+  }
+  const text = anchors.map((anchor) => anchor.text).join("\n\n");
+  if (!text.trim()) return void 0;
+  const { blockIndex: _block, text: _source, ...source } = first.source;
+  return {
+    snapshot: { version: 1, id: crypto.randomUUID(), ...source, text, comment: "", anchors },
+    ranges,
+    sources: selected.map((surface) => ({ surface, text: surface.source.text }))
+  };
+}
+function rangesForAnchor(projection, anchor) {
+  if (projection.text.slice(anchor.start, anchor.end) !== anchor.text || prefixHash(projection.text.slice(0, anchor.end)) !== anchor.prefixHash) return [];
+  return projection.segments.flatMap((segment) => {
+    const start = Math.max(anchor.start, segment.start);
+    const end = Math.min(anchor.end, segment.end);
+    if (end <= start) return [];
+    const range = document.createRange();
+    range.setStart(segment.node, start - segment.start);
+    range.setEnd(segment.node, end - segment.start);
+    return [range];
+  });
+}
+function selectionCurrent(selection) {
+  return selection.sources.every(({ surface, text }) => surface.root.isConnected && surface.source.text === text) && selection.snapshot.anchors.every((anchor) => {
+    const surface = selection.sources.find((item) => item.surface.source.blockIndex === anchor.blockIndex)?.surface;
+    return !!surface && rangesForAnchor(projectResponseText(surface.root), anchor).length > 0;
+  });
+}
+class ResponseController {
+  constructor(composer, load) {
+    this.composer = composer;
+    this.load = load;
+  }
+  surfaces = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  operation = 0;
+  disposed = false;
+  candidate;
+  editor;
+  selectedId;
+  selected;
+  failure;
+  busy = false;
+  getSnapshot = () => this.revision;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  changed = () => {
+    this.revision++;
+    for (const listener of this.listeners) listener();
+  };
+  register(surface) {
+    this.surfaces.add(surface);
+    this.changed();
+    return () => {
+      this.surfaces.delete(surface);
+      this.changed();
+    };
+  }
+  select(sessionId) {
+    if (this.busy || this.editor || this.composer.targetKey() !== sessionId) return;
+    const selection = window.getSelection();
+    this.candidate = selection?.rangeCount === 1 ? readResponseSelection(selection.getRangeAt(0), [...this.surfaces], sessionId) : void 0;
+    this.changed();
+  }
+  dismiss(restoreFocus = false) {
+    const editor = this.editor;
+    this.operation++;
+    this.candidate = void 0;
+    this.editor = void 0;
+    this.selectedId = void 0;
+    this.selected = void 0;
+    this.failure = void 0;
+    this.changed();
+    if (restoreFocus && editor) {
+      if (editor.trigger?.isConnected) editor.trigger.focus();
+      else this.composer.responses?.focus(editor.snapshot.sessionId);
+    }
+  }
+  async add() {
+    const selection = this.candidate;
+    if (!selection || this.busy) return;
+    const operation = ++this.operation;
+    this.failure = void 0;
+    this.busy = true;
+    this.changed();
+    try {
+      if (!selectionCurrent(selection)) throw new AnnotationError("error.responseChanged");
+      await this.composer.add({ text: "", responseSelection: selection.snapshot, expectedTarget: selection.snapshot.sessionId, focus: false });
+      if (this.disposed || operation !== this.operation || this.composer.targetKey() !== selection.snapshot.sessionId) return;
+      this.candidate = void 0;
+      window.getSelection()?.removeAllRanges();
+      this.editor = { snapshot: selection.snapshot, initial: true };
+      this.selectedId = selection.snapshot.id;
+      this.selected = selection.snapshot;
+    } catch (error) {
+      if (operation === this.operation) {
+        this.candidate = void 0;
+        this.failure = annotationFailure(error);
+      }
+    } finally {
+      this.busy = false;
+      if (!this.disposed) this.changed();
+    }
+  }
+  ranges(snapshot) {
+    const ranges = snapshot.anchors.map((anchor) => {
+      const surface = [...this.surfaces].find((item) => item.source.sessionId === snapshot.sessionId && item.source.nodeKey === snapshot.nodeKey && item.source.blockIndex === anchor.blockIndex);
+      return surface ? rangesForAnchor(projectResponseText(surface.root), anchor) : [];
+    });
+    return ranges.every((part) => part.length > 0) ? ranges.flat() : [];
+  }
+  async open(snapshot, edit, trigger) {
+    if (this.composer.targetKey() !== snapshot.sessionId) throw new AnnotationError("error.sessionChangedAdd");
+    const operation = ++this.operation;
+    if (edit) {
+      snapshot = this.composer.responses?.read(snapshot.sessionId).find((item) => item.id === snapshot.id) ?? snapshot;
+    }
+    const unavailable = () => {
+      if (!edit) throw new AnnotationError("error.responseUnavailable");
+      this.candidate = void 0;
+      this.editor = { snapshot, initial: false, trigger };
+      this.selectedId = snapshot.id;
+      this.selected = snapshot;
+      this.failure = new AnnotationError("error.responseUnavailable");
+      this.changed();
+    };
+    try {
+      await this.load(snapshot.sessionId, snapshot.seq);
+    } catch {
+      if (operation === this.operation && this.composer.targetKey() === snapshot.sessionId) unavailable();
+      return;
+    }
+    for (let attempt = 0; attempt < 20; attempt++) {
+      if (this.disposed || operation !== this.operation || this.composer.targetKey() !== snapshot.sessionId) throw new AnnotationError("error.cancelled");
+      const surface = [...this.surfaces].find((item) => item.source.sessionId === snapshot.sessionId && item.source.nodeKey === snapshot.nodeKey);
+      if (surface) {
+        surface.reveal();
+        if (!this.ranges(snapshot).length) {
+          unavailable();
+          return;
+        }
+        surface.root.scrollIntoView({ block: "center", behavior: "instant" });
+        this.candidate = void 0;
+        this.failure = void 0;
+        this.selectedId = snapshot.id;
+        this.selected = snapshot;
+        this.editor = edit ? { snapshot, initial: false, trigger } : void 0;
+        this.changed();
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    unavailable();
+  }
+  save(comment) {
+    if (!this.editor) return;
+    try {
+      const snapshot = this.editor.snapshot;
+      this.composer.responses?.replace({ ...snapshot, comment });
+      this.dismiss();
+      this.composer.responses?.focus(snapshot.sessionId);
+    } catch (error) {
+      this.failure = annotationFailure(error);
+      this.changed();
+    }
+  }
+  remove() {
+    if (!this.editor) return;
+    try {
+      const snapshot = this.editor.snapshot;
+      this.composer.responses?.remove(snapshot.sessionId, snapshot.id);
+      this.dismiss();
+      this.composer.responses?.focus(snapshot.sessionId);
+    } catch (error) {
+      this.failure = annotationFailure(error);
+      this.changed();
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    this.operation++;
+    this.surfaces.clear();
+    this.listeners.clear();
+  }
+}
+export {
+  c as ANNOTATION_PRESENTATION,
+  d as ANNOTATION_SOURCE,
+  AnnotationError,
+  f as AnnotationPackets,
+  AnnotationsModel,
+  D as DocumentWorkflow,
+  F as FILE_SELECTION_SOURCE,
+  M as MAX_SELECTION_BYTES,
+  P as PageBatches,
+  PageImages,
+  g as PaintedCells,
+  R as RESPONSE_SELECTION_BYTES,
+  h as RESPONSE_SOURCE,
+  ResponseController,
+  j as absoluteFileAddress,
+  k as annotationErrorText,
+  annotationFailure,
+  l as annotationPresentation,
+  m as assertFileDraftCapacity,
+  n as assertResponseCapacity,
+  bindReferencePresentation,
+  o as capturePageRegion,
+  q as clip,
+  r as columnName,
+  commitToComposer,
+  t as decodeFileReference,
+  u as decodeResponseReference,
+  v as draftFactory,
+  en,
+  w as enclosing,
+  x as errorCopy,
+  errorEn,
+  errorZh,
+  y as fileLabel,
+  z as fileLocation,
+  B as filePath,
+  C as fileReference,
+  E as formatAnnotations,
+  imageDrafts,
+  G as isPageSnapshot,
+  H as normalizeRect,
+  I as packetSpan,
+  J as pageBounds,
+  pageImageStore,
+  K as pageInteraction,
+  L as pageRegion,
+  N as parseFileAddress,
+  prefixHash,
+  O as projectAnchors,
+  projectResponseText,
+  Q as quotedContext,
+  S as rangeAnchors,
+  T as rangeName,
+  rangesForAnchor,
+  U as readAnnotation,
+  V as readFileSelection,
+  W as readPageText,
+  X as readRange,
+  readResponseSelection,
+  Y as readResponseSnapshot,
+  Z as readSentFile,
+  _ as readSentResponse,
+  $ as readSpreadsheetSnapshot,
+  a0 as registerSpreadsheet,
+  a1 as responseReference,
+  a2 as responseSelections,
+  a3 as revealSpreadsheet,
+  selectedFiles,
+  selectionCurrent,
+  a4 as serializeFileReference,
+  a5 as serializeResponseReference,
+  a6 as sessionFileAddress,
+  a7 as spreadsheetSnapshot,
+  a8 as union,
+  a9 as validPageRect,
+  zh
+};
+//# sourceMappingURL=index.js.map