@primeui/texteditor-core 0.0.1-alpha.1

package/dist/chunk-TBQVZVKA.mjs

@@ -0,0 +1,1891 @@
+import { createMentionPlugin, insertMention } from './chunk-PT2O4RV7.mjs';
+import { createEditorKeymap, keymap, baseKeymap } from './chunk-YHMP6AN3.mjs';
+import { createMarkdownInputRules } from './chunk-OGEMGWLR.mjs';
+import { createContextToolbarPlugin } from './chunk-IUQKSDKG.mjs';
+import { createColumnWidthPinPlugin } from './chunk-MWT5PK3Z.mjs';
+import { createTrailingNodePlugin } from './chunk-EA2YI7LA.mjs';
+import { createTableOverlayPlugin } from './chunk-3RKMABZR.mjs';
+import { createSlashPlugin, executeSlashCommand } from './chunk-KNZAMA6H.mjs';
+import { addProseMirrorPlugin, removeProseMirrorPlugin } from './chunk-6GY64GPU.mjs';
+import { createPlaceholderPlugin } from './chunk-NWRVBNBW.mjs';
+import { createMentionController } from './chunk-GGPBV4BM.mjs';
+import { defaultTextEditorProps } from './chunk-AJOKUIQD.mjs';
+import { defaultTextEditorRefs } from './chunk-E2KXUP3F.mjs';
+import { defaultTextEditorState } from './chunk-PT5V6UYE.mjs';
+import { htmlExceedsMaxDepth, htmlToSlice, htmlToDoc, htmlToInertFragment } from './chunk-PRFYR67X.mjs';
+import { createEditorSchema } from './chunk-AUTGNC2Q.mjs';
+import { selectRow, selectColumn, createCommands, createTableCellCommands, createTableRowCommands, createTableColumnCommands } from './chunk-6YDCG63C.mjs';
+import { getSelectionPosition, getMarkAttrs, isNodeActive, isMarkActive } from './chunk-72T5I4O4.mjs';
+import { createSelectionHighlightPlugin, preserveSelection } from './chunk-RQ2HHNI6.mjs';
+import { docToHtml, withoutPlaceholders, nodeToHtml } from './chunk-6ZN5XRH2.mjs';
+import { sanitizeImageUrl, sanitizeUrl } from './chunk-MNKMKFLQ.mjs';
+import { textEditorClasses } from './chunk-GG56GLXC.mjs';
+import { defineComponent } from '@primeui/core';
+import { dropCursor } from 'prosemirror-dropcursor';
+import { gapCursor } from 'prosemirror-gapcursor';
+import { history, redo, undo } from 'prosemirror-history';
+import { TextSelection, EditorState } from 'prosemirror-state';
+import { columnResizing, tableEditing, addRowAfter, addColumnAfter, CellSelection } from 'prosemirror-tables';
+import { EditorView } from 'prosemirror-view';
+import { DOMSerializer, Fragment, DOMParser } from 'prosemirror-model';
+
+function getBlockIndex(view, pos) {
+  let index = 0;
+  view.state.doc.forEach((_child, childOffset) => {
+    if (childOffset < pos) {
+      index++;
+    }
+  });
+  return index;
+}
+function renderFromSchema(node) {
+  const spec = node.type.spec.toDOM?.(node);
+  if (!spec) return { dom: document.createElement("div"), contentDOM: null };
+  const { dom, contentDOM } = DOMSerializer.renderSpec(document, spec);
+  return { dom, contentDOM: contentDOM ?? null };
+}
+function createBlockNodeView(node, view, getPos, onHoverChange) {
+  const pos = getPos();
+  const isTopLevel = pos != null && view.state.doc.resolve(pos).depth === 0;
+  const attrsRenderEqual = (a, b) => JSON.stringify(a.attrs) === JSON.stringify(b.attrs);
+  if (!isTopLevel) {
+    const { dom: dom2, contentDOM: contentDOM2 } = renderFromSchema(node);
+    return {
+      dom: dom2,
+      contentDOM: contentDOM2,
+      update(updatedNode) {
+        if (updatedNode.type !== node.type || !attrsRenderEqual(node, updatedNode)) return false;
+        node = updatedNode;
+        return true;
+      }
+    };
+  }
+  const dom = document.createElement("div");
+  dom.className = textEditorClasses.block;
+  const contentWrapper = document.createElement("div");
+  contentWrapper.className = textEditorClasses.blockContent;
+  dom.appendChild(contentWrapper);
+  const { dom: contentEl, contentDOM } = renderFromSchema(node);
+  contentWrapper.appendChild(contentEl);
+  const onMouseEnter = () => {
+    const hoverPos = getPos();
+    if (hoverPos != null) {
+      onHoverChange(getBlockIndex(view, hoverPos), dom);
+    }
+  };
+  const onMouseLeave = (event) => {
+    const related = event.relatedTarget;
+    if (related?.closest(`.${textEditorClasses.blockControls}`)) return;
+    if (related?.closest(`.${textEditorClasses.block}`)) return;
+    if (related?.closest(`.${textEditorClasses.popoverMenu}`)) return;
+    onHoverChange(-1, null);
+  };
+  dom.addEventListener("mouseenter", onMouseEnter);
+  dom.addEventListener("mouseleave", onMouseLeave);
+  const removeHoverListeners = () => {
+    dom.removeEventListener("mouseenter", onMouseEnter);
+    dom.removeEventListener("mouseleave", onMouseLeave);
+  };
+  if (node.type.spec.atom || !contentDOM) {
+    return {
+      dom,
+      update(updatedNode) {
+        if (updatedNode.type !== node.type || !attrsRenderEqual(node, updatedNode)) return false;
+        node = updatedNode;
+        return true;
+      },
+      destroy() {
+        removeHoverListeners();
+      }
+    };
+  }
+  return {
+    dom,
+    contentDOM,
+    update(updatedNode) {
+      if (updatedNode.type !== node.type || !attrsRenderEqual(node, updatedNode)) return false;
+      node = updatedNode;
+      return true;
+    },
+    destroy() {
+      removeHoverListeners();
+    }
+  };
+}
+
+// src/utils/blockPosition.ts
+function blockStartPos(doc, index) {
+  if (index < 0 || index >= doc.childCount) return -1;
+  let pos = 0;
+  for (let i = 0; i < index; i++) pos += doc.child(i).nodeSize;
+  return pos;
+}
+function blockEndPos(doc, index) {
+  const start = blockStartPos(doc, index);
+  return start < 0 ? -1 : start + doc.child(index).nodeSize;
+}
+function posAfterBlock(doc, index) {
+  if (index >= doc.childCount - 1) return doc.content.size;
+  return blockEndPos(doc, index);
+}
+function posToBlockIndex(doc, pos) {
+  let offset = 0;
+  for (let i = 0; i < doc.childCount; i++) {
+    const size = doc.child(i).nodeSize;
+    if (pos < offset + size) return i;
+    offset += size;
+  }
+  return doc.childCount - 1;
+}
+
+// src/nodeviews/tableNodeView.ts
+function updateColumns(node, colgroup, table, defaultCellMinWidth) {
+  let totalWidth = 0;
+  let fixedWidth = true;
+  let nextDOM = colgroup.firstChild;
+  const row = node.firstChild;
+  if (!row) return;
+  for (let i = 0, col = 0; i < row.childCount; i++) {
+    const { colspan, colwidth } = row.child(i).attrs;
+    for (let j = 0; j < colspan; j++, col++) {
+      const hasWidth = colwidth && colwidth[j];
+      const cssWidth = hasWidth ? `${hasWidth}px` : "";
+      totalWidth += hasWidth || defaultCellMinWidth;
+      if (!hasWidth) fixedWidth = false;
+      if (!nextDOM) {
+        colgroup.appendChild(document.createElement("col")).style.width = cssWidth;
+      } else {
+        if (nextDOM.style.width !== cssWidth) nextDOM.style.width = cssWidth;
+        nextDOM = nextDOM.nextSibling;
+      }
+    }
+  }
+  while (nextDOM) {
+    const after = nextDOM.nextSibling;
+    nextDOM.remove();
+    nextDOM = after;
+  }
+  if (fixedWidth) {
+    table.style.width = `${totalWidth}px`;
+    table.style.minWidth = "";
+  } else {
+    table.style.width = "";
+    table.style.minWidth = `${totalWidth}px`;
+  }
+}
+function createTableNodeView(node, _view, _getPos, options) {
+  const dom = document.createElement("div");
+  dom.className = "tableWrapper";
+  const table = dom.appendChild(document.createElement("table"));
+  table.style.setProperty("--default-cell-min-width", `${options.defaultCellWidth}px`);
+  const colgroup = table.appendChild(document.createElement("colgroup"));
+  updateColumns(node, colgroup, table, options.defaultCellWidth);
+  const contentDOM = table.appendChild(document.createElement("tbody"));
+  return {
+    dom,
+    contentDOM,
+    update(updatedNode) {
+      if (updatedNode.type !== node.type) return false;
+      node = updatedNode;
+      updateColumns(node, colgroup, table, options.defaultCellWidth);
+      return true;
+    },
+    ignoreMutation(mutation) {
+      const target = mutation.target;
+      if (mutation.type === "attributes" && (target === table || colgroup.contains(target))) return true;
+      if (target === dom && mutation.type === "childList") {
+        const isOurElement = (el) => el.classList?.contains(textEditorClasses.tableSelectionOutline) || el.classList?.contains(textEditorClasses.tableTrigger) || el.classList?.contains(textEditorClasses.tableAdd);
+        for (let i = 0; i < mutation.addedNodes.length; i++) {
+          if (isOurElement(mutation.addedNodes[i])) return true;
+        }
+        for (let i = 0; i < mutation.removedNodes.length; i++) {
+          if (isOurElement(mutation.removedNodes[i])) return true;
+        }
+      }
+      if (target.closest?.(`.${textEditorClasses.tableSelectionOutline}, .${textEditorClasses.tableTrigger}, .${textEditorClasses.tableAdd}`)) return true;
+      return false;
+    }
+  };
+}
+
+// src/nodeviews/blockTableNodeView.ts
+function createBlockTableNodeView(node, view, getPos, options) {
+  const tableNV = createTableNodeView(node, view, getPos, { defaultCellWidth: options.defaultCellWidth });
+  const dom = document.createElement("div");
+  dom.className = textEditorClasses.block;
+  const contentWrapper = document.createElement("div");
+  contentWrapper.className = textEditorClasses.blockContent;
+  contentWrapper.appendChild(tableNV.dom);
+  dom.appendChild(contentWrapper);
+  dom.addEventListener("mouseenter", () => {
+    const pos = getPos();
+    if (pos != null) options.onBlockHoverChange(posToBlockIndex(view.state.doc, pos), dom);
+  });
+  dom.addEventListener("mouseleave", (event) => {
+    const related = event.relatedTarget;
+    if (related?.closest(`.${textEditorClasses.blockControls}`)) return;
+    if (related?.closest(`.${textEditorClasses.block}`)) return;
+    if (related?.closest(`.${textEditorClasses.popoverMenu}`)) return;
+    options.onBlockHoverChange(-1, null);
+  });
+  return {
+    dom,
+    contentDOM: tableNV.contentDOM,
+    update: tableNV.update?.bind(tableNV),
+    ignoreMutation: tableNV.ignoreMutation?.bind(tableNV)
+  };
+}
+
+// src/nodeviews/checkList.ts
+function checkListItemNodeView(node, view, getPos) {
+  const li = document.createElement("li");
+  li.setAttribute("data-p-checked", node.attrs.checked ? "true" : "false");
+  const label = document.createElement("label");
+  label.contentEditable = "false";
+  const checkbox = document.createElement("input");
+  checkbox.type = "checkbox";
+  checkbox.checked = node.attrs.checked;
+  checkbox.setAttribute("aria-label", node.textContent || "To-do item");
+  checkbox.addEventListener("change", () => {
+    const pos = getPos();
+    if (pos == null) return;
+    const tr = view.state.tr.setNodeMarkup(pos, null, {
+      ...node.attrs,
+      checked: checkbox.checked
+    });
+    view.dispatch(tr);
+  });
+  const span = document.createElement("span");
+  label.appendChild(checkbox);
+  label.appendChild(span);
+  li.appendChild(label);
+  const contentDOM = document.createElement("div");
+  li.appendChild(contentDOM);
+  return {
+    dom: li,
+    contentDOM,
+    update(updatedNode) {
+      if (updatedNode.type.name !== "check_list_item") return false;
+      li.setAttribute("data-p-checked", updatedNode.attrs.checked ? "true" : "false");
+      checkbox.checked = updatedNode.attrs.checked;
+      checkbox.setAttribute("aria-label", updatedNode.textContent || "To-do item");
+      return true;
+    }
+  };
+}
+
+// src/upload/uploadManager.ts
+function formatFileSize(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+  return (bytes / (1024 * 1024)).toFixed(1) + " MB";
+}
+var UploadManager = class {
+  constructor(callbacks) {
+    this.entries = [];
+    this.results = /* @__PURE__ */ new Map();
+    this.nextIndex = 0;
+    this.onStateChange = callbacks.onStateChange;
+    this.onAllComplete = callbacks.onAllComplete;
+    this.onAllDismissed = callbacks.onAllDismissed;
+    this.onError = callbacks.onError;
+  }
+  start(files, uploadHandler, mapResult) {
+    for (const file of files) {
+      const id = Math.random().toString(36).slice(2, 10);
+      const index = this.nextIndex++;
+      const controller = new AbortController();
+      const entry = {
+        id,
+        file,
+        progress: 0,
+        status: "uploading",
+        cancelled: false,
+        controller,
+        cancel: () => {
+          entry.cancelled = true;
+          entry.status = "cancelled";
+          controller.abort();
+          this.emitState();
+          this.checkAllComplete();
+        }
+      };
+      this.entries.push(entry);
+      this.emitState();
+      uploadHandler(file, {
+        signal: controller.signal,
+        onProgress: (percent) => {
+          if (!entry.cancelled) {
+            entry.progress = percent;
+            this.emitState();
+          }
+        }
+      }).then((url) => {
+        if (!entry.cancelled) {
+          entry.status = "complete";
+          entry.progress = 100;
+          this.results.set(index, mapResult(url, file));
+          this.emitState();
+        }
+      }).catch((error) => {
+        if (!entry.cancelled) {
+          entry.status = "error";
+          this.emitState();
+          this.onError?.(file, error);
+        }
+      }).finally(() => this.checkAllComplete());
+    }
+  }
+  dismiss() {
+    this.entries.forEach((e) => {
+      if (e.status === "uploading") {
+        e.cancelled = true;
+        e.status = "cancelled";
+        e.controller.abort();
+      }
+    });
+    this.reset();
+    this.onAllDismissed();
+  }
+  getEntries() {
+    return this.entries.map((e) => ({
+      id: e.id,
+      fileName: e.file.name,
+      fileSize: e.file.size,
+      fileSizeFormatted: formatFileSize(e.file.size),
+      progress: e.progress,
+      status: e.status,
+      cancel: e.cancel
+    }));
+  }
+  checkAllComplete() {
+    if (this.entries.length === 0) return;
+    if (this.entries.every((e) => e.status !== "uploading")) {
+      const ordered = [...this.results.keys()].sort((a, b) => a - b).map((k) => this.results.get(k));
+      if (ordered.length > 0) {
+        this.onAllComplete(ordered);
+      } else {
+        this.onAllDismissed();
+      }
+      this.reset();
+    }
+  }
+  reset() {
+    this.entries = [];
+    this.results = /* @__PURE__ */ new Map();
+    this.nextIndex = 0;
+    this.emitState();
+  }
+  emitState() {
+    this.onStateChange(this.getEntries());
+  }
+};
+
+// src/upload/accept.ts
+function matchesAccept(file, accept) {
+  if (!accept) return true;
+  const tokens = accept.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+  if (tokens.length === 0) return true;
+  const fileType = (file.type || "").toLowerCase();
+  const fileName = (file.name || "").toLowerCase();
+  return tokens.some((token) => {
+    if (token.startsWith(".")) return fileName.endsWith(token);
+    if (token.endsWith("/*")) return fileType.startsWith(token.slice(0, token.indexOf("/") + 1));
+    return fileType === token;
+  });
+}
+
+// src/upload/validate.ts
+function validateUploadFiles(files, constraints, onReject) {
+  const { maxCount, maxSize, accept } = constraints;
+  if (files.length > maxCount) {
+    onReject(files, "max-file-count");
+    return [];
+  }
+  const valid = [];
+  for (const file of files) {
+    if (!matchesAccept(file, accept)) {
+      onReject([file], "file-type");
+    } else if (file.size > maxSize) {
+      onReject([file], "max-file-size");
+    } else {
+      valid.push(file);
+    }
+  }
+  return valid;
+}
+
+// src/logic/uploads.ts
+function createUploadModule(ctx) {
+  const { props, emit, schema, findPlaceholderPos, removePlaceholder } = ctx;
+  const imageConstraints = () => ({
+    maxCount: props.imageMaxFileCount ?? 3,
+    maxSize: props.imageMaxFileSize ?? 1024 * 1024,
+    accept: props.allowedImageTypes ?? "image/*"
+  });
+  const documentConstraints = () => ({
+    maxCount: props.documentMaxFileCount ?? 3,
+    maxSize: props.documentMaxFileSize ?? 10 * 1024 * 1024,
+    accept: props.allowedDocumentTypes
+  });
+  const rejectImage = (files, reason) => emit("image-reject", { files, reason });
+  const rejectDocument = (files, reason) => emit("document-reject", { files, reason });
+  const imageManager = new UploadManager({
+    onStateChange: (entries) => emit("image-upload-state-change", entries),
+    onError: (file, error) => emit("image-upload-error", { file, error }),
+    onAllComplete: (results) => {
+      const view = ctx.getView();
+      if (!view || results.length === 0) return;
+      const pos = findPlaceholderPos(schema.nodes.image_upload_placeholder);
+      if (pos >= 0) {
+        const imageNodes = results.map(({ src, alt }) => ({ src: sanitizeImageUrl(src), alt })).filter((r) => r.src != null).map(({ src, alt }) => schema.nodes.image.create({ src, alt: alt || null }));
+        view.dispatch(view.state.tr.replaceWith(pos, pos + 1, schema.nodes.paragraph.create(null, imageNodes)));
+      }
+      emit("image-upload-complete");
+    },
+    onAllDismissed: () => {
+      removePlaceholder(schema.nodes.image_upload_placeholder);
+      emit("image-upload-complete");
+    }
+  });
+  const documentManager = new UploadManager({
+    onStateChange: (entries) => emit("document-upload-state-change", entries),
+    onError: (file, error) => emit("document-upload-error", { file, error }),
+    onAllComplete: (results) => {
+      const view = ctx.getView();
+      if (!view || results.length === 0) return;
+      const pos = findPlaceholderPos(schema.nodes.document_upload_placeholder);
+      if (pos >= 0) {
+        const nodes = results.map(({ url, fileName }) => {
+          const href = sanitizeUrl(url);
+          const marks = href ? [schema.marks.link.create({ href })] : [];
+          return schema.nodes.paragraph.create(null, schema.text(fileName, marks));
+        });
+        view.dispatch(view.state.tr.replaceWith(pos, pos + 1, nodes));
+      }
+      emit("document-upload-complete");
+    },
+    onAllDismissed: () => {
+      removePlaceholder(schema.nodes.document_upload_placeholder);
+      emit("document-upload-complete");
+    }
+  });
+  const imageHandler = () => props.imageUploadHandler ?? props.uploadHandler;
+  const documentHandler = () => props.documentUploadHandler ?? props.uploadHandler;
+  return {
+    startImageUploads: (files) => {
+      const handler = imageHandler();
+      if (!handler) return;
+      const valid = validateUploadFiles(files, imageConstraints(), rejectImage);
+      if (valid.length > 0) imageManager.start(valid, handler, (url, file) => ({ src: url, alt: file.name }));
+      else removePlaceholder(schema.nodes.image_upload_placeholder);
+    },
+    dismissImageUpload: () => imageManager.dismiss(),
+    validateImageFiles: (files) => validateUploadFiles(files, imageConstraints(), rejectImage),
+    startDocumentUploads: (files) => {
+      const handler = documentHandler();
+      if (!handler) return;
+      const valid = validateUploadFiles(files, documentConstraints(), rejectDocument);
+      if (valid.length > 0) documentManager.start(valid, handler, (url, file) => ({ url, fileName: file.name }));
+      else removePlaceholder(schema.nodes.document_upload_placeholder);
+    },
+    dismissDocumentUpload: () => documentManager.dismiss(),
+    validateDocumentFiles: (files) => validateUploadFiles(files, documentConstraints(), rejectDocument)
+  };
+}
+
+// src/utils/debounce.ts
+function createDebouncer(wait) {
+  let timer = null;
+  let pending = null;
+  const cancel = () => {
+    if (timer != null) clearTimeout(timer);
+    timer = null;
+    pending = null;
+  };
+  const flush = () => {
+    if (timer != null) clearTimeout(timer);
+    timer = null;
+    const fn = pending;
+    pending = null;
+    fn?.();
+  };
+  const schedule = (fn) => {
+    if (wait <= 0) {
+      fn();
+      return;
+    }
+    pending = fn;
+    if (timer != null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      const run = pending;
+      pending = null;
+      run?.();
+    }, wait);
+  };
+  return { schedule, flush, cancel };
+}
+
+// src/logic/navigator.ts
+function createNavigatorModule(ctx) {
+  const { getView, getElement, emit, schema, props } = ctx;
+  const getDocumentHeadings = () => {
+    const view = getView();
+    if (!view) return [];
+    const headings = [];
+    view.state.doc.descendants((node, pos) => {
+      if (node.type === schema.nodes.heading) {
+        headings.push({ pos, level: node.attrs.level, text: node.textContent });
+        return false;
+      }
+      return void 0;
+    });
+    return headings;
+  };
+  const debouncer = createDebouncer(props.valueChangeDebounce ?? 0);
+  const scheduleHeadings = () => debouncer.schedule(() => emit("navigator-headings-change", getDocumentHeadings()));
+  const activeIndexFromSelection = (headings) => {
+    const view = getView();
+    if (!view || headings.length === 0) return null;
+    const caret = view.state.selection.from;
+    let idx = -1;
+    for (let i = 0; i < headings.length; i++) {
+      if (headings[i].pos <= caret) idx = i;
+      else break;
+    }
+    return idx >= 0 ? idx : null;
+  };
+  const computeActiveIndex = (headings) => {
+    const el = getElement();
+    if (!el || headings.length === 0) return null;
+    const canScroll = el.scrollHeight - el.clientHeight > 1;
+    if (!canScroll) return activeIndexFromSelection(headings);
+    const editorTop = el.getBoundingClientRect().top;
+    const headingEls = el.querySelectorAll("h1, h2, h3, h4, h5, h6");
+    let activeIdx = 0;
+    headingEls.forEach((node, i) => {
+      if (i >= headings.length) return;
+      if (node.getBoundingClientRect().top - editorTop <= 50) activeIdx = i;
+    });
+    return activeIdx;
+  };
+  let rafId = 0;
+  return {
+    getDocumentHeadings,
+    scheduleHeadings,
+    cancel: () => {
+      debouncer.cancel();
+      cancelAnimationFrame(rafId);
+    },
+    focusHeading: (pos) => {
+      const view = getView();
+      if (!view) return;
+      view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, pos + 1)));
+      view.focus();
+    },
+    scrollToHeading: (pos, headings) => {
+      const view = getView();
+      if (!view) return;
+      view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, pos + 1)));
+      const el = getElement();
+      const headingEls = el?.querySelectorAll("h1, h2, h3, h4, h5, h6");
+      const idx = headings.findIndex((h) => h.pos === pos);
+      const target = headingEls && idx >= 0 ? headingEls[idx] : void 0;
+      if (el && target) {
+        const raw = el.scrollTop + (target.getBoundingClientRect().top - el.getBoundingClientRect().top);
+        const top = Math.max(0, Math.min(raw, el.scrollHeight - el.clientHeight));
+        el.scrollTo({ top, behavior: "smooth" });
+      }
+    },
+    updateActiveHeading: (headings) => {
+      const idx = computeActiveIndex(headings);
+      if (idx !== null) emit("navigator-active-index-change", idx);
+    },
+    // Re-resolve the active heading from the caret when the selection moves
+    // (no doc change). Keeps the minimap in sync as the user clicks/arrows
+    // around, including in short documents that can't scroll.
+    syncActiveFromSelection: () => {
+      const idx = activeIndexFromSelection(getDocumentHeadings());
+      if (idx !== null) emit("navigator-active-index-change", idx);
+    },
+    onNavigatorScroll: (headings) => {
+      cancelAnimationFrame(rafId);
+      rafId = requestAnimationFrame(() => {
+        const idx = computeActiveIndex(headings);
+        if (idx !== null) emit("navigator-active-index-change", idx);
+      });
+    }
+  };
+}
+function collectInlineContent(block, schema) {
+  if (block.isTextblock) return block.content;
+  const lines = [];
+  block.descendants((node) => {
+    if (node.isTextblock) {
+      lines.push(node.content);
+      return false;
+    }
+    return true;
+  });
+  if (lines.length === 0) return Fragment.empty;
+  const hardBreak = schema.nodes.hard_break;
+  let result = Fragment.empty;
+  lines.forEach((line, i) => {
+    if (i > 0 && hardBreak) result = result.addToEnd(hardBreak.create());
+    result = result.append(line);
+  });
+  return result;
+}
+function collectTextLines(block) {
+  if (block.isTextblock) return block.textContent;
+  const lines = [];
+  block.descendants((node) => {
+    if (node.isTextblock) {
+      lines.push(node.textContent);
+      return false;
+    }
+    return true;
+  });
+  return lines.join("\n");
+}
+
+// src/logic/menuCommands.ts
+function createMenuCommands(ctx) {
+  const { getView, schema, emit, props } = ctx;
+  const buildCommands = (view) => createCommands(
+    view,
+    schema,
+    {
+      onUploadImages: () => emit("image-upload-request"),
+      onUploadDocuments: () => emit("document-upload-request")
+    },
+    { defaultCellWidth: props.defaultTableColumnWidth ?? 120 }
+  );
+  const blockPos = (view, blockIndex) => {
+    let pos = 0;
+    view.state.doc.forEach((_child, offset, i) => {
+      if (i === blockIndex) pos = offset;
+    });
+    return pos;
+  };
+  const getBlockMenuCommands = (blockIndex, onDismiss) => {
+    const view = getView();
+    if (!view) return {};
+    const commands = buildCommands(view);
+    const selectBlock = () => {
+      if (!view) return;
+      const doc = view.state.doc;
+      if (blockIndex >= doc.childCount) return;
+      const startPos = blockPos(view, blockIndex);
+      const endPos = startPos + doc.child(blockIndex).nodeSize;
+      view.dispatch(view.state.tr.setSelection(TextSelection.create(doc, startPos + 1, endPos - 1)));
+    };
+    const deleteBlock = () => {
+      if (!view) return;
+      const doc = view.state.doc;
+      if (blockIndex >= doc.childCount) return;
+      const pos = blockPos(view, blockIndex);
+      const tr = view.state.tr.delete(pos, pos + doc.child(blockIndex).nodeSize);
+      if (tr.doc.childCount === 0) tr.insert(0, schema.nodes.paragraph.create());
+      view.dispatch(tr);
+      view.focus();
+      onDismiss();
+    };
+    const duplicateBlock = () => {
+      if (!view) return;
+      const doc = view.state.doc;
+      if (blockIndex >= doc.childCount) return;
+      const pos = blockPos(view, blockIndex);
+      const block = doc.child(blockIndex);
+      view.dispatch(view.state.tr.insert(pos + block.nodeSize, block.copy(block.content)));
+      view.focus();
+      onDismiss();
+    };
+    const copyToClipboard = () => {
+      if (!view) return;
+      selectBlock();
+      const { from, to } = view.state.selection;
+      const plain = view.state.doc.textBetween(from, to, "\n");
+      const slice = view.state.selection.content();
+      const fragment = DOMSerializer.fromSchema(schema).serializeFragment(slice.content);
+      const div = document.createElement("div");
+      div.appendChild(fragment);
+      const html = div.innerHTML;
+      if (typeof ClipboardItem !== "undefined" && navigator.clipboard?.write) {
+        navigator.clipboard.write([new ClipboardItem({ "text/html": new Blob([html], { type: "text/html" }), "text/plain": new Blob([plain], { type: "text/plain" }) })]).catch(() => navigator.clipboard.writeText(plain));
+      } else {
+        navigator.clipboard.writeText(plain);
+      }
+      onDismiss();
+    };
+    const turnBlockInto = (targetType, attrs) => {
+      if (!view) return;
+      const doc = view.state.doc;
+      if (blockIndex >= doc.childCount) return;
+      const pos = blockPos(view, blockIndex);
+      const block = doc.child(blockIndex);
+      const blockEnd = pos + block.nodeSize;
+      const getInlineContent = () => collectInlineContent(block, schema);
+      const tr = view.state.tr;
+      let newBlock;
+      if (targetType === "paragraph") {
+        newBlock = schema.nodes.paragraph.create(attrs || null, getInlineContent());
+      } else if (targetType === "heading") {
+        newBlock = schema.nodes.heading.create(attrs || { level: 1 }, getInlineContent());
+      } else if (targetType === "code_block") {
+        const text = collectTextLines(block);
+        newBlock = schema.nodes.code_block.create(null, text ? schema.text(text) : void 0);
+      } else if (targetType === "blockquote") {
+        newBlock = schema.nodes.blockquote.create(null, schema.nodes.paragraph.create(null, getInlineContent()));
+      } else if (targetType === "bullet_list" || targetType === "ordered_list" || targetType === "check_list") {
+        const listType = schema.nodes[targetType];
+        if (block.type === schema.nodes.bullet_list || block.type === schema.nodes.ordered_list || block.type === schema.nodes.check_list) {
+          const targetItemType = targetType === "check_list" ? schema.nodes.check_list_item : schema.nodes.list_item;
+          const items = [];
+          block.forEach((item) => {
+            const itemAttrs = targetItemType === schema.nodes.check_list_item ? { checked: false } : null;
+            items.push(targetItemType.create(itemAttrs, item.content));
+          });
+          newBlock = listType.create(null, items);
+        } else {
+          const itemType = targetType === "check_list" ? schema.nodes.check_list_item : schema.nodes.list_item;
+          const itemAttrs = targetType === "check_list" ? { checked: false } : null;
+          const item = itemType.create(itemAttrs, schema.nodes.paragraph.create(null, getInlineContent()));
+          newBlock = listType.create(null, item);
+        }
+      } else {
+        return;
+      }
+      tr.replaceWith(pos, blockEnd, newBlock);
+      const selection = TextSelection.findFrom(tr.doc.resolve(pos + 1), 1, true);
+      if (selection) tr.setSelection(selection);
+      view.dispatch(tr);
+      view.focus();
+      onDismiss();
+    };
+    const applyColor = (color, property) => {
+      selectBlock();
+      if (property === "color") commands.foregroundColor(color);
+      else commands.backgroundColor(color);
+      if (view) {
+        const { to } = view.state.selection;
+        view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, to)));
+      }
+      onDismiss();
+    };
+    return {
+      duplicate: duplicateBlock,
+      copyToClipboard,
+      deleteBlock,
+      turnInto: {
+        text: () => turnBlockInto("paragraph"),
+        heading1: () => turnBlockInto("heading", { level: 1 }),
+        heading2: () => turnBlockInto("heading", { level: 2 }),
+        heading3: () => turnBlockInto("heading", { level: 3 }),
+        bulletList: () => turnBlockInto("bullet_list"),
+        orderedList: () => turnBlockInto("ordered_list"),
+        checkList: () => turnBlockInto("check_list"),
+        blockquote: () => turnBlockInto("blockquote"),
+        codeBlock: () => turnBlockInto("code_block")
+      },
+      foregroundColor: (color) => applyColor(color, "color"),
+      backgroundColor: (color) => applyColor(color, "backgroundColor")
+    };
+  };
+  const getSlashMenuCommands = (_blockIndex, onDismiss) => {
+    const view = getView();
+    if (!view) return {};
+    const commands = buildCommands(view);
+    const exec = (fn, options) => {
+      if (!view) return;
+      executeSlashCommand(view, fn);
+      onDismiss();
+    };
+    return {
+      text: () => exec(() => commands.paragraph()),
+      heading: (level) => exec(() => commands.heading(level)),
+      bulletList: () => exec(() => commands.bulletList()),
+      orderedList: () => exec(() => commands.orderedList()),
+      checkList: () => exec(() => commands.checkList()),
+      blockquote: () => exec(() => commands.blockquote()),
+      code: () => exec(() => commands.codeBlock()),
+      divider: () => exec(() => commands.insertHorizontalRule()),
+      uploadImages: () => exec(() => commands.uploadImages()),
+      uploadDocuments: () => exec(() => commands.uploadDocuments()),
+      table: () => exec(() => commands.table(3, 3))
+    };
+  };
+  return { getBlockMenuCommands, getSlashMenuCommands };
+}
+var EMPTY_BLOCK = "<p><br></p>";
+function docToBlocks(doc, schema) {
+  const serializer = DOMSerializer.fromSchema(schema);
+  const blocks = [];
+  withoutPlaceholders(doc.content, schema).forEach((child) => {
+    const fragment = serializer.serializeFragment(Fragment.from(child));
+    const container = document.createElement("div");
+    container.appendChild(fragment);
+    const html = container.innerHTML;
+    blocks.push(html || EMPTY_BLOCK);
+  });
+  return blocks.length > 0 ? blocks : [EMPTY_BLOCK];
+}
+function blocksToDoc(blocks, schema) {
+  const parser = DOMParser.fromSchema(schema);
+  const nodes = [];
+  for (const html of blocks) {
+    const parsed = parser.parse(htmlToInertFragment(html || EMPTY_BLOCK));
+    parsed.content.forEach((child) => {
+      nodes.push(child);
+    });
+  }
+  if (nodes.length === 0) {
+    nodes.push(schema.nodes.paragraph.create());
+  }
+  return schema.node("doc", null, nodes);
+}
+
+// src/texteditor.internal.ts
+var TABLE_MIN_COLUMN_WIDTH = 40;
+var TABLE_DEFAULT_COLUMN_WIDTH = 120;
+var VALUE_CHANGE_AUTO_DEFER_THRESHOLD = 8e3;
+var MENTION_MENU_ID = "p-te-mention-menu";
+var SLASH_MENU_ID = "p-te-slash-menu";
+
+// src/logic/valueEmitter.ts
+function createValueEmitter({ getView, schema, emit, isBlockMode, debounceMs }) {
+  const debouncer = createDebouncer(debounceMs);
+  const hasExplicitDebounce = debounceMs > 0;
+  let valueRaf = 0;
+  const emitValueChange = () => {
+    const view = getView();
+    if (!view) return;
+    emit(isBlockMode() ? docToBlocks(view.state.doc, schema) : docToHtml(view.state.doc, schema));
+  };
+  const scheduleValueChange = () => {
+    if (hasExplicitDebounce) {
+      debouncer.schedule(emitValueChange);
+      return;
+    }
+    const view = getView();
+    if (view && view.state.doc.content.size > VALUE_CHANGE_AUTO_DEFER_THRESHOLD) {
+      if (valueRaf) return;
+      valueRaf = requestAnimationFrame(() => {
+        valueRaf = 0;
+        emitValueChange();
+      });
+      return;
+    }
+    emitValueChange();
+  };
+  const flushValueChange = () => {
+    if (valueRaf) {
+      cancelAnimationFrame(valueRaf);
+      valueRaf = 0;
+      emitValueChange();
+    }
+    debouncer.flush();
+  };
+  return { emitValueChange, scheduleValueChange, flushValueChange };
+}
+
+// src/serialization/markdownParser.ts
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function inlineToHtml(text) {
+  let out = escapeHtml(text);
+  out = out.replace(/!\[([^\]]*)\]\(([^)\s]+)\)/g, (_m, alt, src) => `<img src="${src}" alt="${alt}">`);
+  out = out.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, t, href) => `<a href="${href}">${t}</a>`);
+  out = out.replace(/&lt;((?:https?|mailto):[^\s&]+)&gt;/g, (_m, url) => `<a href="${url}">${url}</a>`);
+  out = out.replace(/`([^`]+)`/g, (_m, c) => `<code>${c}</code>`);
+  out = out.replace(/\*\*\*([^*]+)\*\*\*/g, "<strong><em>$1</em></strong>");
+  out = out.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  out = out.replace(/(^|[^*])\*([^*]+)\*/g, "$1<em>$2</em>");
+  out = out.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+  out = out.replace(/==([^=]+)==/g, '<span style="background-color: rgba(242, 201, 76, 0.4)">$1</span>');
+  return out;
+}
+function isTableSeparator(line) {
+  return /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)+\|?\s*$/.test(line);
+}
+function splitRow(line) {
+  return line.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim());
+}
+function markdownToHtml(md) {
+  const lines = md.replace(/\r\n?/g, "\n").split("\n");
+  const html = [];
+  let i = 0;
+  const flushParagraph = (buf) => {
+    if (buf.length) html.push(`<p>${inlineToHtml(buf.join(" "))}</p>`);
+  };
+  let para = [];
+  while (i < lines.length) {
+    const line = lines[i];
+    const fence = line.match(/^(```|~~~)([\w-]*)/);
+    if (fence) {
+      flushParagraph(para);
+      para = [];
+      const code = [];
+      const lang = fence[2];
+      i++;
+      while (i < lines.length && !lines[i].startsWith(fence[1])) code.push(lines[i++]);
+      i++;
+      const openTag = lang ? `<pre data-language="${lang}"><code class="language-${lang}">` : "<pre><code>";
+      html.push(`${openTag}${escapeHtml(code.join("\n"))}</code></pre>`);
+      continue;
+    }
+    if (line.includes("|") && i + 1 < lines.length && isTableSeparator(lines[i + 1])) {
+      flushParagraph(para);
+      para = [];
+      const headers = splitRow(line);
+      const rows = [];
+      i += 2;
+      while (i < lines.length && lines[i].includes("|") && lines[i].trim()) rows.push(splitRow(lines[i++]));
+      const head = `<tr>${headers.map((h) => `<th>${inlineToHtml(h)}</th>`).join("")}</tr>`;
+      const body = rows.map((r) => `<tr>${r.map((c) => `<td>${inlineToHtml(c)}</td>`).join("")}</tr>`).join("");
+      html.push(`<table>${head}${body}</table>`);
+      continue;
+    }
+    const heading = line.match(/^(#{1,6})\s+(.*)$/);
+    if (heading) {
+      flushParagraph(para);
+      para = [];
+      html.push(`<h${heading[1].length}>${inlineToHtml(heading[2])}</h${heading[1].length}>`);
+      i++;
+      continue;
+    }
+    if (/^\s*([-*_])\s*\1\s*\1[\s\S]*$/.test(line) || /^---+$/.test(line.trim())) {
+      flushParagraph(para);
+      para = [];
+      html.push("<hr>");
+      i++;
+      continue;
+    }
+    if (/^\s*>\s?/.test(line)) {
+      flushParagraph(para);
+      para = [];
+      const quote = [];
+      while (i < lines.length && /^\s*>\s?/.test(lines[i])) quote.push(lines[i++].replace(/^\s*>\s?/, ""));
+      html.push(`<blockquote><p>${inlineToHtml(quote.join(" "))}</p></blockquote>`);
+      continue;
+    }
+    if (/^\s*[-*]\s+\[[ xX]\]\s+/.test(line)) {
+      flushParagraph(para);
+      para = [];
+      const items = [];
+      while (i < lines.length && /^\s*[-*]\s+\[[ xX]\]\s+/.test(lines[i])) {
+        const m = lines[i].match(/^\s*[-*]\s+\[([ xX])\]\s+(.*)$/);
+        const checked = m[1].toLowerCase() === "x";
+        items.push(`<li data-p-checked="${checked}"><p>${inlineToHtml(m[2])}</p></li>`);
+        i++;
+      }
+      html.push(`<ul data-p-checked-list>${items.join("")}</ul>`);
+      continue;
+    }
+    const bullet = line.match(/^\s*([-*+])\s+(.*)$/);
+    const ordered = line.match(/^\s*(\d+)\.\s+(.*)$/);
+    if (bullet || ordered) {
+      flushParagraph(para);
+      para = [];
+      const tag = ordered ? "ol" : "ul";
+      const items = [];
+      while (i < lines.length) {
+        const b = lines[i].match(/^\s*[-*+]\s+(.*)$/);
+        const o = lines[i].match(/^\s*\d+\.\s+(.*)$/);
+        if (ordered && o) items.push(`<li><p>${inlineToHtml(o[1])}</p></li>`);
+        else if (!ordered && b && !/^\s*[-*]\s+\[[ xX]\]/.test(lines[i])) items.push(`<li><p>${inlineToHtml(b[1])}</p></li>`);
+        else break;
+        i++;
+      }
+      html.push(`<${tag}>${items.join("")}</${tag}>`);
+      continue;
+    }
+    if (!line.trim()) {
+      flushParagraph(para);
+      para = [];
+      i++;
+      continue;
+    }
+    para.push(line.trim());
+    i++;
+  }
+  flushParagraph(para);
+  return html.join("");
+}
+function looksLikeMarkdown(text) {
+  return /(^|\n)\s*(#{1,6}\s|[-*+]\s|\d+\.\s|>\s|```|\|.*\|)/.test(text) || /\*\*[^*]+\*\*|\[[^\]]+\]\([^)]+\)|`[^`]+`/.test(text);
+}
+var STRUCTURAL_TAGS = /<(h[1-6]|ul|ol|li|table|tr|td|th|thead|tbody|blockquote|pre|code|img|a|hr|strong|em|b|i|s|del|mark|input)\b/i;
+function isTrivialHtmlWrapper(html, plain) {
+  if (!plain) return false;
+  const body = html.replace(/^\s*<meta[^>]*>/i, "");
+  if (STRUCTURAL_TAGS.test(body)) return false;
+  const stripped = body.replace(/<\/(p|div|li|tr)>/gi, "\n").replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&nbsp;/g, " ");
+  const norm = (s) => s.replace(/\s+/g, " ").trim();
+  return norm(stripped) === norm(plain);
+}
+
+// src/serialization/markdownSerializer.ts
+function isKnownInline(node, schema) {
+  return node.isText || node.type === schema.nodes.hard_break || node.type === schema.nodes.image;
+}
+var MARKDOWN_BLOCKS = ["paragraph", "heading", "blockquote", "code_block", "horizontal_rule", "bullet_list", "ordered_list", "check_list", "table"];
+function isKnownBlock(node, schema) {
+  return MARKDOWN_BLOCKS.some((name) => node.type === schema.nodes[name]);
+}
+function escapeText(text) {
+  return text.replace(/([\\`*_~[\]])/g, "\\$1");
+}
+function serializeInline(node, schema) {
+  if (node.type === schema.nodes.hard_break) return "\n";
+  if (node.type === schema.nodes.image) {
+    const alt = node.attrs.alt || "";
+    return `![${alt}](${node.attrs.src})`;
+  }
+  if (!node.isText && !isKnownInline(node, schema)) return nodeToHtml(node, schema);
+  if (!node.isText) return node.textContent;
+  let text = escapeText(node.text ?? "");
+  const marks = node.marks;
+  if (marks.some((m) => m.type === schema.marks.code)) text = `\`${node.text ?? ""}\``;
+  if (marks.some((m) => m.type === schema.marks.bold) && marks.some((m) => m.type === schema.marks.italic)) text = `***${text}***`;
+  else if (marks.some((m) => m.type === schema.marks.bold)) text = `**${text}**`;
+  else if (marks.some((m) => m.type === schema.marks.italic)) text = `*${text}*`;
+  if (marks.some((m) => m.type === schema.marks.strikethrough)) text = `~~${text}~~`;
+  const link = marks.find((m) => m.type === schema.marks.link);
+  if (link) text = `[${text}](${link.attrs.href})`;
+  return text;
+}
+function serializeInlineContent(node, schema) {
+  let out = "";
+  node.forEach((child) => {
+    out += serializeInline(child, schema);
+  });
+  return out;
+}
+function serializeTableRow(row, schema) {
+  const cells = [];
+  row.forEach((cell) => {
+    cells.push(
+      serializeInlineContent(cell.firstChild ?? cell, schema).replace(/\n/g, " ").trim()
+    );
+  });
+  return `| ${cells.join(" | ")} |`;
+}
+function serializeBlock(node, schema, indent = "") {
+  const n = node.type;
+  if (n === schema.nodes.paragraph) return indent + serializeInlineContent(node, schema);
+  if (n === schema.nodes.heading) return `${"#".repeat(node.attrs.level)} ${serializeInlineContent(node, schema)}`;
+  if (n === schema.nodes.blockquote) {
+    return node.content.content.map((child) => `> ${serializeBlock(child, schema)}`).join("\n");
+  }
+  if (n === schema.nodes.code_block) return "```" + (node.attrs.language || "") + "\n" + node.textContent + "\n```";
+  if (n === schema.nodes.horizontal_rule) return "---";
+  if (n === schema.nodes.bullet_list || n === schema.nodes.ordered_list) {
+    const ordered = n === schema.nodes.ordered_list;
+    const start = ordered ? node.attrs.start || 1 : 0;
+    const lines = [];
+    node.content.forEach((item, _o, i) => {
+      const bullet = ordered ? `${start + i}.` : "-";
+      const inner = item.content.content.map((c) => serializeBlock(c, schema, indent + "  ")).join("\n");
+      lines.push(`${indent}${bullet} ${inner.replace(new RegExp(`^${indent}  `), "").trimStart()}`);
+    });
+    return lines.join("\n");
+  }
+  if (n === schema.nodes.check_list) {
+    const lines = [];
+    node.content.forEach((item) => {
+      const checked = item.attrs.checked ? "x" : " ";
+      const inner = item.content.content.map((c) => serializeBlock(c, schema)).join("\n");
+      lines.push(`${indent}- [${checked}] ${inner.trimStart()}`);
+    });
+    return lines.join("\n");
+  }
+  if (n === schema.nodes.table) {
+    const rows = [];
+    let isFirst = true;
+    node.content.forEach((row) => {
+      rows.push(serializeTableRow(row, schema));
+      if (isFirst) {
+        const cols = row.childCount;
+        rows.push(`| ${Array(cols).fill("---").join(" | ")} |`);
+        isFirst = false;
+      }
+    });
+    return rows.join("\n");
+  }
+  if (!isKnownBlock(node, schema)) return nodeToHtml(node, schema);
+  return serializeInlineContent(node, schema);
+}
+function docToMarkdown(doc, schema) {
+  const blocks = [];
+  doc.forEach((node) => {
+    blocks.push(serializeBlock(node, schema));
+  });
+  return blocks.join("\n\n");
+}
+function sliceToMarkdown(slice, schema) {
+  const blocks = [];
+  slice.content.forEach((node) => {
+    blocks.push(node.isTextblock || node.isBlock ? serializeBlock(node, schema) : serializeInline(node, schema));
+  });
+  return blocks.join("\n\n");
+}
+function deriveFormatState(state, schema, view, cachedPlaceholders) {
+  const { $from } = state.selection;
+  const textStyleAttrs = getMarkAttrs(state, schema.marks.textStyle);
+  let headingLevel = null;
+  for (let depth = $from.depth; depth > 0; depth--) {
+    if ($from.node(depth).type === schema.nodes.heading) {
+      headingLevel = $from.node(depth).attrs.level;
+      break;
+    }
+  }
+  let textAlign = "left";
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type === schema.nodes.paragraph || node.type === schema.nodes.heading) {
+      textAlign = node.attrs.textAlign || "left";
+      break;
+    }
+  }
+  let linkMark = schema.marks.link.isInSet(state.storedMarks || $from.marks());
+  if (!linkMark && !state.selection.empty) {
+    const { from, to } = state.selection;
+    state.doc.nodesBetween(from, to, (node) => {
+      if (linkMark) return false;
+      const mark = schema.marks.link.isInSet(node.marks);
+      if (mark) linkMark = mark;
+      return void 0;
+    });
+  }
+  const placeholders = cachedPlaceholders ?? findPlaceholders(state, schema);
+  const computedFont = textStyleAttrs?.fontFamily && textStyleAttrs?.fontSize ? null : getComputedFont(state, view);
+  const fontFamily = textStyleAttrs?.fontFamily || computedFont?.fontFamily || null;
+  const fontSize = textStyleAttrs?.fontSize || computedFont?.fontSize || null;
+  return {
+    bold: isMarkActive(state, schema.marks.bold),
+    italic: isMarkActive(state, schema.marks.italic),
+    underline: isMarkActive(state, schema.marks.underline),
+    strikethrough: isMarkActive(state, schema.marks.strikethrough),
+    subscript: isMarkActive(state, schema.marks.subscript),
+    superscript: isMarkActive(state, schema.marks.superscript),
+    code: isMarkActive(state, schema.marks.code),
+    codeBlock: isNodeActive(state, schema.nodes.code_block),
+    blockquote: isNodeActive(state, schema.nodes.blockquote),
+    heading: headingLevel,
+    bulletList: isNodeActive(state, schema.nodes.bullet_list),
+    orderedList: isNodeActive(state, schema.nodes.ordered_list),
+    checkList: isNodeActive(state, schema.nodes.check_list),
+    textAlign,
+    fontFamily,
+    fontSize,
+    foregroundColor: textStyleAttrs?.color || null,
+    backgroundColor: textStyleAttrs?.backgroundColor || null,
+    highlight: !!textStyleAttrs?.backgroundColor,
+    inTable: isNodeActive(state, schema.nodes.table),
+    hasSelection: !state.selection.empty,
+    hasFocus: view?.hasFocus() ?? false,
+    link: !!linkMark,
+    linkUrl: linkMark?.attrs.href || null,
+    canUndo: undo(state),
+    canRedo: redo(state),
+    hasImageUploadPlaceholder: placeholders.image,
+    hasDocumentUploadPlaceholder: placeholders.document,
+    isMultiCellSelected: state.selection instanceof CellSelection,
+    isCellMerged: isCellMergedCheck($from)
+  };
+}
+var fontCacheEl = null;
+var fontCacheVal = null;
+function getComputedFont(state, view) {
+  if (!view || typeof window === "undefined") return null;
+  try {
+    const { $from } = state.selection;
+    const at = view.domAtPos($from.pos);
+    let node = at.node;
+    if (node && node.nodeType === Node.TEXT_NODE) node = node.parentElement;
+    const el = node;
+    if (!el || !el.isConnected) return null;
+    if (fontCacheEl?.deref() === el) return fontCacheVal;
+    const cs = window.getComputedStyle(el);
+    const fontFamily = (cs.fontFamily.split(",")[0] || "").trim().replace(/^["']|["']$/g, "");
+    const fontSize = cs.fontSize;
+    const result = !fontFamily && !fontSize ? null : { fontFamily, fontSize };
+    fontCacheEl = new WeakRef(el);
+    fontCacheVal = result;
+    return result;
+  } catch {
+    return null;
+  }
+}
+function isCellMergedCheck($from) {
+  for (let depth = $from.depth; depth > 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type.name === "table_cell" || node.type.name === "table_header") {
+      return (node.attrs.colspan ?? 1) > 1 || (node.attrs.rowspan ?? 1) > 1;
+    }
+  }
+  return false;
+}
+function findPlaceholders(state, schema) {
+  const imageType = schema.nodes.image_upload_placeholder;
+  const documentType = schema.nodes.document_upload_placeholder;
+  let image = false;
+  let document2 = false;
+  state.doc.descendants((node) => {
+    if (node.type === imageType) image = true;
+    else if (node.type === documentType) document2 = true;
+    return !(image && document2);
+  });
+  return { image, document: document2 };
+}
+function replaceDocPreservingSelection(view, doc) {
+  const prev = view.state.selection;
+  const tr = view.state.tr.replaceWith(0, view.state.doc.content.size, doc.content);
+  const max = tr.doc.content.size;
+  const anchor = Math.min(prev.anchor, max);
+  const head = Math.min(prev.head, max);
+  tr.setSelection(TextSelection.between(tr.doc.resolve(anchor), tr.doc.resolve(head)));
+  view.dispatch(tr);
+}
+
+// src/texteditor.logic.ts
+var isRtl = (el) => {
+  const target = el ?? document.documentElement;
+  return target.closest?.('[dir="rtl"]') != null || getComputedStyle(target).direction === "rtl";
+};
+function useTextEditorLogic(instance) {
+  const { $refs, $props, $state, $emit, onMounted, onUnmounted } = instance;
+  const collectSchemaExtensions = () => {
+    const plugins = $props.plugins || [];
+    return plugins.map((entry) => Array.isArray(entry) ? entry[0] : entry).map((p) => p?.schema).filter((s) => !!s);
+  };
+  const schema = createEditorSchema(collectSchemaExtensions());
+  const collectProseMirrorPlugins = () => {
+    const plugins = $props.plugins || [];
+    const result = [];
+    for (const entry of plugins) {
+      const plugin = Array.isArray(entry) ? entry[0] : entry;
+      const options = Array.isArray(entry) ? entry[1] : void 0;
+      const factory = plugin?.prosemirrorPlugins;
+      if (typeof factory === "function") result.push(...factory(schema, options));
+    }
+    return result;
+  };
+  let view = null;
+  let tableActiveState = null;
+  let tableOverlayRect = null;
+  const pendingProseMirrorPlugins = [];
+  let pendingMouseUpRemover = null;
+  const emit = (event, ...args) => {
+    $emit(event, ...args);
+  };
+  const isBlockMode = () => $props.mode === "block";
+  const isMarkdownEnabled = () => !!$props.markdown;
+  const { scheduleValueChange, flushValueChange } = createValueEmitter({
+    getView: () => view,
+    schema,
+    emit: (value) => emit("value-change", value),
+    isBlockMode,
+    debounceMs: $props.valueChangeDebounce ?? 0
+  });
+  let placeholderCache = { image: false, document: false };
+  const emitFormatState = () => {
+    if (!view) return;
+    emit("format-state-change", deriveFormatState(view.state, schema, view, placeholderCache));
+  };
+  const findPlaceholderPos = (nodeType) => {
+    if (!view) return -1;
+    let pos = -1;
+    view.state.doc.descendants((node, p) => {
+      if (pos !== -1) return false;
+      if (node.type === nodeType) pos = p;
+      return void 0;
+    });
+    return pos;
+  };
+  const removePlaceholder = (nodeType) => {
+    const pos = findPlaceholderPos(nodeType);
+    if (view && pos >= 0) view.dispatch(view.state.tr.delete(pos, pos + 1));
+  };
+  const ctx = {
+    getView: () => view,
+    getElement: () => $refs.element,
+    props: $props,
+    emit,
+    schema,
+    findPlaceholderPos,
+    removePlaceholder
+  };
+  const uploadModule = createUploadModule(ctx);
+  const navigatorModule = createNavigatorModule(ctx);
+  const menuCommands = createMenuCommands(ctx);
+  let comboboxState = null;
+  const editorAttributes = () => {
+    const attrs = {
+      class: textEditorClasses.content,
+      role: "textbox",
+      "aria-multiline": "true"
+    };
+    if ($props.ariaLabelledby) {
+      attrs["aria-labelledby"] = $props.ariaLabelledby;
+    } else {
+      attrs["aria-label"] = $props.ariaLabel || $props.placeholder || "Rich text editor";
+    }
+    if ($props.disabled) attrs["aria-disabled"] = "true";
+    if ($props.disabled || $props.readonly) attrs["aria-readonly"] = "true";
+    if (comboboxState) {
+      attrs["aria-expanded"] = "true";
+      attrs["aria-controls"] = comboboxState.controls;
+      if (comboboxState.activedescendant) attrs["aria-activedescendant"] = comboboxState.activedescendant;
+    } else {
+      attrs["aria-expanded"] = "false";
+    }
+    return attrs;
+  };
+  const setComboboxState = (state) => {
+    let next = state;
+    if (state && state.activedescendant === void 0 && state.controls === comboboxState?.controls) {
+      next = { controls: state.controls, activedescendant: comboboxState.activedescendant };
+    }
+    if (next?.controls === comboboxState?.controls && next?.activedescendant === comboboxState?.activedescendant) return;
+    comboboxState = next;
+    view?.setProps({ attributes: editorAttributes });
+  };
+  const setComboboxActiveDescendant = (id) => {
+    if (!comboboxState) return;
+    setComboboxState({ controls: comboboxState.controls, activedescendant: id ?? void 0 });
+  };
+  const parseValueToDoc = (value) => {
+    const emptyDoc = () => schema.node("doc", null, [schema.node("paragraph")]);
+    try {
+      if (isBlockMode()) {
+        const blocks = Array.isArray(value) ? value : [];
+        return blocksToDoc(blocks.length > 0 ? blocks : ["<p></p>"], schema);
+      }
+      const html = value || "";
+      return html ? htmlToDoc(html, schema) : emptyDoc();
+    } catch (error) {
+      emit("parse-error", { error });
+      return emptyDoc();
+    }
+  };
+  const mentionController = createMentionController({
+    getHandler: () => $props.mentionHandler,
+    getFilterField: () => $props.mentionFilterField || "name",
+    emit: (update) => {
+      setComboboxState(update.active ? { controls: MENTION_MENU_ID } : null);
+      emit("mention-request", update);
+    }
+  });
+  const markdownPlugin = createMarkdownInputRules(schema);
+  const createEditorView = (mountEl) => {
+    const doc = parseValueToDoc($props.value);
+    const state = EditorState.create({
+      doc,
+      plugins: [
+        createEditorKeymap(schema, { blockMode: isBlockMode() }),
+        keymap(baseKeymap),
+        history(),
+        ...isBlockMode() ? [createTrailingNodePlugin(schema), gapCursor()] : [dropCursor(), createTrailingNodePlugin(schema), gapCursor()],
+        ...$props.markdown ? [markdownPlugin] : [],
+        // prosemirror-tables columnResizing drags from the wrong edge under RTL,
+        // so it is disabled there. RTL column resizing is a known limitation.
+        ...isRtl(mountEl) ? [] : [
+          columnResizing({ View: null, cellMinWidth: $props.minTableColumnWidth ?? TABLE_MIN_COLUMN_WIDTH, defaultCellMinWidth: $props.defaultTableColumnWidth ?? TABLE_DEFAULT_COLUMN_WIDTH }),
+          // eslint-disable-line @typescript-eslint/no-explicit-any
+          // Pin every unsized column to its rendered width when a
+          // resize starts, so a single drag (or even a plain click on
+          // the handle) doesn't snap the other columns to the default.
+          createColumnWidthPinPlugin()
+        ],
+        tableEditing(),
+        createTableOverlayPlugin({
+          onActiveStateChange: (state2) => {
+            tableActiveState = state2;
+            emit("table-active-state-change", state2);
+          },
+          onOverlayRectChange: (rect) => {
+            tableOverlayRect = rect;
+            emit("table-overlay-rect-change", rect);
+          },
+          onColumnTriggerClick: (colIndex, event) => {
+            if (view) selectColumn(view, colIndex);
+            emit("table-column-menu-request", colIndex, event);
+          },
+          onRowTriggerClick: (rowIndex, event) => {
+            if (view) selectRow(view, rowIndex);
+            emit("table-row-menu-request", rowIndex, event);
+          },
+          onCellTriggerClick: (event) => {
+            emit("table-cell-menu-request", event);
+          },
+          onAddColumn: () => {
+            if (view) addColumnAfter(view.state, view.dispatch);
+          },
+          onAddRow: () => {
+            if (view) addRowAfter(view.state, view.dispatch);
+          }
+        }),
+        createPlaceholderPlugin({
+          text: () => $props.placeholder,
+          blockMode: isBlockMode()
+        }),
+        createContextToolbarPlugin({
+          onRequest: (position) => {
+            emit("context-toolbar-request", position);
+          }
+        }),
+        ...$state.isMentionEnabled ? [
+          createMentionPlugin(schema, {
+            onUpdate: (update) => mentionController.onUpdate(update)
+          })
+        ] : [],
+        createSelectionHighlightPlugin(),
+        ...isBlockMode() && $state.isSlashCommandsEnabled ? [
+          createSlashPlugin({
+            onUpdate: (update) => {
+              setComboboxState(update.active ? { controls: SLASH_MENU_ID } : null);
+              emit("slash-menu-request", update);
+            },
+            placeholder: $props.slashPlaceholder ?? void 0
+          })
+        ] : [],
+        ...collectProseMirrorPlugins()
+      ]
+    });
+    view = new EditorView(mountEl, {
+      state,
+      editable: () => !($props.disabled || $props.readonly),
+      dispatchTransaction(tr) {
+        if (!view) return;
+        if (tr.docChanged && ($props.disabled || $props.readonly)) return;
+        const newState = view.state.apply(tr);
+        view.updateState(newState);
+        if (tr.docChanged) {
+          placeholderCache = findPlaceholders(newState, schema);
+          scheduleValueChange();
+          if ($props.navigator) {
+            navigatorModule.scheduleHeadings();
+          }
+        } else if (tr.selectionSet) {
+          if ($props.navigator) {
+            navigatorModule.syncActiveFromSelection();
+          }
+          emit("selection-update");
+        }
+        emitFormatState();
+      },
+      nodeViews: {
+        ...!isBlockMode() ? {
+          table: (node, tableView, getPos) => createTableNodeView(node, tableView, getPos, {
+            defaultCellWidth: $props.defaultTableColumnWidth ?? TABLE_DEFAULT_COLUMN_WIDTH
+          })
+        } : {},
+        check_list_item: (node, checkView, getPos) => checkListItemNodeView(node, checkView, getPos),
+        ...isBlockMode() ? {
+          ...Object.fromEntries(
+            ["paragraph", "heading", "blockquote", "code_block", "horizontal_rule", "bullet_list", "ordered_list", "check_list", "image_upload_placeholder", "document_upload_placeholder"].map((typeName) => [
+              typeName,
+              (node, blockView, getPos) => createBlockNodeView(node, blockView, getPos, (index, el) => emit("block-hover-change", { index, element: el }))
+            ])
+          ),
+          table: (node, tableView, getPos) => createBlockTableNodeView(node, tableView, getPos, {
+            defaultCellWidth: $props.defaultTableColumnWidth ?? TABLE_DEFAULT_COLUMN_WIDTH,
+            onBlockHoverChange: (index, el) => emit("block-hover-change", { index, element: el })
+          })
+        } : {}
+      },
+      attributes: editorAttributes,
+      // Surface focus/blur as granular events without intercepting them
+      // (return false so ProseMirror keeps its default handling).
+      handleDOMEvents: {
+        focus: () => {
+          emit("editor-focus");
+          return false;
+        },
+        blur: () => {
+          emit("editor-blur");
+          return false;
+        }
+      },
+      // Bound pasted/dropped HTML to the same depth guard as setValue, so a
+      // deeply-nested clipboard payload can't freeze the main thread.
+      transformPastedHTML: (html) => htmlExceedsMaxDepth(html) ? "" : html,
+      // Modifier-click (Cmd/Ctrl) opens a link without leaving the editor; a
+      // plain click still positions the caret for editing.
+      handleClickOn: (clickView, pos, _node, _nodePos, event) => {
+        if (!(event.metaKey || event.ctrlKey)) return false;
+        const mark = schema.marks.link.isInSet(clickView.state.doc.resolve(pos).marks());
+        const href = mark?.attrs.href ? sanitizeUrl(mark.attrs.href) : null;
+        if (!href) return false;
+        window.open(href, "_blank", "noopener,noreferrer");
+        return true;
+      },
+      // Copy: in markdown mode put markdown (not HTML) on text/plain.
+      clipboardTextSerializer: (slice) => isMarkdownEnabled() ? sliceToMarkdown(slice, schema) : slice.content.textBetween(0, slice.content.size, "\n\n"),
+      // Paste: in markdown mode, convert pasted markdown text into rich content.
+      handlePaste: (pasteView, event) => {
+        if (!isMarkdownEnabled()) return false;
+        const html = event.clipboardData?.getData("text/html");
+        const text = event.clipboardData?.getData("text/plain");
+        if (html && !isTrivialHtmlWrapper(html, text)) return false;
+        if (!text || !looksLikeMarkdown(text)) return false;
+        const generated = markdownToHtml(text);
+        if (htmlExceedsMaxDepth(generated)) return false;
+        const slice = htmlToSlice(generated, schema);
+        pasteView.dispatch(pasteView.state.tr.replaceSelection(slice).scrollIntoView());
+        return true;
+      },
+      handleDrop: (_view, event) => {
+        const html = event.dataTransfer?.getData("text/html");
+        if (html && htmlExceedsMaxDepth(html)) {
+          event.preventDefault();
+          return true;
+        }
+        return false;
+      }
+    });
+    placeholderCache = findPlaceholders(view.state, schema);
+    if (pendingProseMirrorPlugins.length) {
+      const queued = pendingProseMirrorPlugins.splice(0);
+      for (const plugin of queued) addProseMirrorPlugin(view, plugin);
+    }
+    emit("editor-create");
+  };
+  onMounted(() => {
+    const mountEl = $refs.element;
+    if (mountEl) {
+      createEditorView(mountEl);
+    }
+  });
+  onUnmounted(() => {
+    flushValueChange();
+    navigatorModule.cancel();
+    pendingMouseUpRemover?.();
+    pendingMouseUpRemover = null;
+    if (view) {
+      view.destroy();
+      view = null;
+    }
+  });
+  return {
+    /**
+     * Re-evaluates the EditorView's `editable` predicate. Call after
+     * mutating `$props.disabled` or `$props.readonly` so ProseMirror
+     * picks up the change without remounting.
+     */
+    refreshEditable: () => {
+      view?.setProps({ editable: () => !($props.disabled || $props.readonly), attributes: editorAttributes });
+    },
+    /**
+     * Add/remove the markdown input-rules plugin live so toggling the
+     * `markdown` prop at runtime takes effect without remounting.
+     */
+    refreshMarkdown: () => {
+      if (!view) return;
+      const active = view.state.plugins.includes(markdownPlugin);
+      if ($props.markdown && !active) addProseMirrorPlugin(view, markdownPlugin);
+      else if (!$props.markdown && active) removeProseMirrorPlugin(view, markdownPlugin);
+    },
+    onEditorKeyDown: () => {
+      if (isBlockMode()) {
+        emit("block-hover-change", { index: -1, element: null });
+      }
+    },
+    onEditorMouseDown: () => {
+      const before = view ? view.state.selection : null;
+      const beforeFrom = before?.from ?? -1;
+      const beforeTo = before?.to ?? -1;
+      const onMouseUp = () => {
+        document.removeEventListener("mouseup", onMouseUp);
+        pendingMouseUpRemover = null;
+        if (!view || view.state.selection.empty) return;
+        const { from, to } = view.state.selection;
+        if (from === beforeFrom && to === beforeTo) return;
+        const position = getSelectionPosition(view);
+        if (position) {
+          emit("context-toolbar-request", position);
+        }
+      };
+      pendingMouseUpRemover?.();
+      document.addEventListener("mouseup", onMouseUp);
+      pendingMouseUpRemover = () => document.removeEventListener("mouseup", onMouseUp);
+    },
+    // Upload (image + document) — delegated to the upload module
+    startImageUploads: uploadModule.startImageUploads,
+    dismissImageUpload: uploadModule.dismissImageUpload,
+    validateImageFiles: uploadModule.validateImageFiles,
+    startDocumentUploads: uploadModule.startDocumentUploads,
+    dismissDocumentUpload: uploadModule.dismissDocumentUpload,
+    validateDocumentFiles: uploadModule.validateDocumentFiles,
+    // Block mode (Phase 6)
+    addBlockAfter: (index) => {
+      if (!view) return;
+      const targetPos = posAfterBlock(view.state.doc, index);
+      const paragraph = schema.nodes.paragraph.create();
+      const tr = view.state.tr.insert(targetPos, paragraph);
+      tr.setSelection(TextSelection.create(tr.doc, targetPos + 1));
+      view.dispatch(tr);
+      view.focus();
+    },
+    getBlockType: (index) => {
+      if (!view || index >= view.state.doc.childCount) return "text";
+      const node = view.state.doc.child(index);
+      if (node.type.name === "paragraph") return "text";
+      if (node.type.name === "heading") return `heading:${node.attrs.level}`;
+      return node.type.name;
+    },
+    onBlockDragStart: (index, event) => {
+      if (!event.dataTransfer) return;
+      event.dataTransfer.effectAllowed = "move";
+      event.dataTransfer.setData("application/x-block-drag", String(index));
+      if (view && index < view.state.doc.childCount) {
+        const dom = view.nodeDOM(blockStartPos(view.state.doc, index));
+        const blockEl = dom instanceof HTMLElement ? dom : dom?.parentElement ?? null;
+        if (blockEl) {
+          const rect = blockEl.getBoundingClientRect();
+          event.dataTransfer.setDragImage(blockEl, event.clientX - rect.left, event.clientY - rect.top);
+        }
+      }
+      emit("block-drag-start", index);
+    },
+    moveBlock: (fromIndex, toIndex) => {
+      if (!view || fromIndex === toIndex || fromIndex < 0 || toIndex < 0) return;
+      const doc = view.state.doc;
+      if (fromIndex >= doc.childCount || toIndex > doc.childCount) return;
+      const fromPos = blockStartPos(doc, fromIndex);
+      const blockNode = doc.child(fromIndex);
+      const tr = view.state.tr;
+      tr.delete(fromPos, blockEndPos(doc, fromIndex));
+      const adjustedTarget = toIndex > fromIndex ? toIndex - 1 : toIndex;
+      const insertPos = adjustedTarget > 0 ? blockEndPos(tr.doc, adjustedTarget - 1) : 0;
+      tr.insert(insertPos, blockNode);
+      tr.setSelection(TextSelection.create(tr.doc, insertPos + 1));
+      view.dispatch(tr);
+      view.focus();
+      emit("block-drag-end");
+    },
+    onBlockDragEnd: () => {
+      emit("block-drag-end");
+    },
+    getCommands: () => {
+      if (!view) return {};
+      return createCommands(
+        view,
+        schema,
+        {
+          onUploadImages: () => emit("image-upload-request"),
+          onUploadDocuments: () => emit("document-upload-request")
+        },
+        { defaultCellWidth: $props.defaultTableColumnWidth ?? TABLE_DEFAULT_COLUMN_WIDTH, highlightColor: $props.defaultHighlightColor ?? null }
+      );
+    },
+    getBlockMenuCommands: menuCommands.getBlockMenuCommands,
+    getSlashMenuCommands: menuCommands.getSlashMenuCommands,
+    // Recent colors (deferred)
+    // Table — insert after the selected cell's row/column.
+    onTableAddRow: () => {
+      if (view) addRowAfter(view.state, view.dispatch);
+    },
+    onTableAddColumn: () => {
+      if (view) addColumnAfter(view.state, view.dispatch);
+    },
+    getTableColumnCommands: (colIndex, onDismiss) => {
+      if (!view) return {};
+      return createTableColumnCommands(view, schema, colIndex, onDismiss);
+    },
+    getTableRowCommands: (rowIndex, onDismiss) => {
+      if (!view) return {};
+      return createTableRowCommands(view, schema, rowIndex, onDismiss);
+    },
+    getTableCellCommands: (onDismiss) => {
+      if (!view) return {};
+      return createTableCellCommands(view, schema, onDismiss);
+    },
+    getTableOverlayRect: () => tableOverlayRect,
+    getTableActiveState: () => tableActiveState,
+    getIsMultiCellSelected: () => {
+      if (!view) return false;
+      return view.state.selection instanceof CellSelection;
+    },
+    getIsCellMerged: () => {
+      if (!view) return false;
+      const { $from } = view.state.selection;
+      for (let depth = $from.depth; depth > 0; depth--) {
+        const node = $from.node(depth);
+        if (node.type.name === "table_cell" || node.type.name === "table_header") {
+          return (node.attrs.colspan ?? 1) > 1 || (node.attrs.rowspan ?? 1) > 1;
+        }
+      }
+      return false;
+    },
+    updateTableOverlayRect: () => {
+      if (tableActiveState) {
+        const rect = tableActiveState.table.getBoundingClientRect();
+        if (rect.width > 0) {
+          emit("table-overlay-rect-change", tableOverlayRect);
+        }
+      }
+    },
+    // Mention
+    getMentionCommands: (onDismiss, options) => ({
+      select: (data) => {
+        if (!view) return;
+        insertMention(view, schema, data, options);
+        onDismiss();
+      }
+    }),
+    getFilteredMentionItems: (items, filterField, filterText) => {
+      if (!filterText) return items;
+      const query = filterText.toLowerCase();
+      return items.filter((item) => {
+        if (!item || typeof item !== "object") return false;
+        const value = String(item[filterField || "name"] || "");
+        return value.toLowerCase().includes(query);
+      });
+    },
+    // Plugin helpers
+    getSelectedText: () => {
+      if (!view) return "";
+      const { from, to } = view.state.selection;
+      return view.state.doc.textBetween(from, to, "\n");
+    },
+    replaceSelection: (content, asHtml) => {
+      if (!view) return;
+      const { from, to } = view.state.selection;
+      if (asHtml) {
+        const slice = htmlToSlice(content, schema);
+        view.dispatch(view.state.tr.replaceSelection(slice));
+      } else {
+        view.dispatch(view.state.tr.insertText(content, from, to));
+      }
+    },
+    getEditorElement: () => view?.dom || null,
+    // Direct ProseMirror access for extension authors (additive, opt-in)
+    getView: () => view,
+    getState: () => view?.state ?? null,
+    registerProseMirrorPlugin: (plugin) => {
+      if (!view) {
+        pendingProseMirrorPlugins.push(plugin);
+        return () => {
+          const idx = pendingProseMirrorPlugins.indexOf(plugin);
+          if (idx !== -1) pendingProseMirrorPlugins.splice(idx, 1);
+          if (view) removeProseMirrorPlugin(view, plugin);
+        };
+      }
+      return addProseMirrorPlugin(view, plugin);
+    },
+    runCommand: (command) => {
+      if (!view) return false;
+      return command(view.state, view.dispatch, view);
+    },
+    // Selection highlight
+    preserveSelection: () => {
+      if (view) preserveSelection(view);
+    },
+    /** Points aria-activedescendant at an open menu's active option; null clears. */
+    setComboboxActiveDescendant,
+    /**
+     * Serialize the current document to HTML. Works in both modes;
+     * in block mode the result is the concatenated HTML of every
+     * block (use `getBlocks` for the block-split array).
+     */
+    getHTML: () => {
+      if (!view) return "";
+      return docToHtml(view.state.doc, schema);
+    },
+    /**
+     * Serialize as the array-of-block-HTML representation used by
+     * block-mode `v-model`. In classic mode returns a single-item
+     * array for parity.
+     */
+    getBlocks: () => {
+      if (!view) return [];
+      const result = docToBlocks(view.state.doc, schema);
+      return Array.isArray(result) ? result : [result];
+    },
+    /** ProseMirror document as plain JSON (loss-less). */
+    getJSON: () => {
+      if (!view) return null;
+      return view.state.doc.toJSON();
+    },
+    /** Plain-text projection. Useful for previews and full-text search indexes. */
+    getText: () => {
+      if (!view) return "";
+      return view.state.doc.textContent;
+    },
+    /** Markdown projection of the document (same serializer as markdown copy). */
+    getMarkdown: () => {
+      if (!view) return "";
+      return docToMarkdown(view.state.doc, schema);
+    },
+    // Value
+    setValue: (value) => {
+      if (!view) return;
+      if (view.composing) return;
+      if (isBlockMode()) {
+        const blocks = Array.isArray(value) ? value : [];
+        if (JSON.stringify(docToBlocks(view.state.doc, schema)) === JSON.stringify(blocks.length > 0 ? blocks : ["<p></p>"])) return;
+      } else {
+        const html = (typeof value === "string" ? value : "") || "";
+        if (docToHtml(view.state.doc, schema) === html) return;
+      }
+      replaceDocPreservingSelection(view, parseValueToDoc(value));
+    },
+    // Navigator — delegated to the navigator module
+    getDocumentHeadings: navigatorModule.getDocumentHeadings,
+    focusHeading: navigatorModule.focusHeading,
+    scrollToHeading: navigatorModule.scrollToHeading,
+    updateActiveHeading: navigatorModule.updateActiveHeading,
+    onNavigatorScroll: navigatorModule.onNavigatorScroll
+  };
+}
+
+// src/createTextEditor.ts
+var createTextEditor = defineComponent("TextEditor", ({ getCurrentInstance, defineRefs, defineProps, defineState, defineEmits, defineExpose }) => {
+  defineRefs(defaultTextEditorRefs);
+  defineProps(defaultTextEditorProps);
+  defineState(defaultTextEditorState);
+  defineEmits([
+    "value-change",
+    "format-state-change",
+    "table-overlay-rect-change",
+    "table-active-state-change",
+    "context-toolbar-request",
+    "image-upload-request",
+    "document-upload-request",
+    "image-reject",
+    "document-reject",
+    "image-upload-error",
+    "document-upload-error",
+    "parse-error",
+    "mention-request",
+    "block-hover-change",
+    "block-drag-start",
+    "block-drag-end",
+    "slash-menu-request",
+    "table-column-menu-request",
+    "table-row-menu-request",
+    "table-cell-menu-request",
+    "navigator-headings-change",
+    "navigator-active-index-change",
+    "image-upload-state-change",
+    "document-upload-state-change",
+    "image-upload-complete",
+    "document-upload-complete",
+    "selection-update",
+    "editor-focus",
+    "editor-blur",
+    "editor-create"
+  ]);
+  const currentInstance = getCurrentInstance();
+  const expose = useTextEditorLogic(currentInstance);
+  defineExpose(expose);
+});
+
+export { createTextEditor };
+//# sourceMappingURL=chunk-TBQVZVKA.mjs.map
+//# sourceMappingURL=chunk-TBQVZVKA.mjs.map