@sofereditor/react 0.1.0

package/dist/index.js

@@ -0,0 +1,3778 @@
+// src/Editor.tsx
+import {
+  useCallback as useCallback5,
+  useEffect as useEffect7,
+  useLayoutEffect as useLayoutEffect4,
+  useMemo as useMemo4,
+  useRef as useRef10
+} from "react";
+import {
+  deleteBackward,
+  deleteForward,
+  insertParagraph,
+  insertText
+} from "@sofereditor/core";
+
+// src/dom-bridge.ts
+function findContainingBlockElement(node, root) {
+  let cur = node;
+  while (cur && cur !== root) {
+    if (cur.nodeType === Node.ELEMENT_NODE) {
+      const el = cur;
+      if (el.dataset.blockIndex != null) return el;
+    }
+    cur = cur.parentNode;
+  }
+  return null;
+}
+function findContainingCellElement(node, blockEl) {
+  let cur = node;
+  while (cur && cur !== blockEl) {
+    if (cur.nodeType === Node.ELEMENT_NODE) {
+      const el = cur;
+      if (el.dataset.cellIndex != null) return el;
+    }
+    cur = cur.parentNode;
+  }
+  return null;
+}
+function findBlockIndex(node, root) {
+  const el = findContainingBlockElement(node, root);
+  if (!el) return null;
+  return Number.parseInt(el.dataset.blockIndex, 10);
+}
+function getBlockElement(root, blockIndex) {
+  return root.querySelector(`[data-block-index="${blockIndex}"]`);
+}
+function readFragmentStart(el) {
+  const s = el.dataset.fragmentStart;
+  if (s == null) return 0;
+  const n = Number.parseInt(s, 10);
+  return Number.isFinite(n) ? n : 0;
+}
+function readFragmentEnd(el) {
+  const s = el.dataset.fragmentEnd;
+  if (s == null) return void 0;
+  const n = Number.parseInt(s, 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function getFragmentForOffset(root, blockIndex, offset) {
+  const candidates = root.querySelectorAll(`[data-block-index="${blockIndex}"]`);
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+  let last = null;
+  for (const el of candidates) {
+    last = el;
+    const start = readFragmentStart(el);
+    const end = readFragmentEnd(el);
+    if (end == null) return el;
+    if (offset >= start && offset < end) return el;
+  }
+  return last;
+}
+function getCellElement(root, blockIndex, cellIndex) {
+  const blockEl = getBlockElement(root, blockIndex);
+  if (!blockEl) return null;
+  return blockEl.querySelector(`[data-cell-index="${cellIndex}"]`);
+}
+function isImgEmbed(n) {
+  return n.nodeType === Node.ELEMENT_NODE && n.dataset.embed === "image";
+}
+function isWrapAnchorImg(n) {
+  return n.nodeType === Node.ELEMENT_NODE && n.dataset.wrapAnchor === "true";
+}
+function isPhantomEmbed(n) {
+  return n.nodeType === Node.ELEMENT_NODE && n.dataset.embedPhantom === "true";
+}
+function indexInParent(n) {
+  const parent = n.parentNode;
+  if (!parent) return 0;
+  let i = 0;
+  for (const c of Array.from(parent.childNodes)) {
+    if (c === n) return i;
+    i++;
+  }
+  return 0;
+}
+function isRejectedSubtree(el, container) {
+  if (el === container) return false;
+  if (el.dataset.blockIndex != null) return true;
+  if (container.dataset.cellIndex != null && el.dataset.cellIndex != null) return true;
+  return false;
+}
+function textOffsetWithin(container, node, offsetInNode) {
+  let target = node;
+  let targetOff = offsetInNode;
+  if (isImgEmbed(target) && target.parentNode) {
+    targetOff = indexInParent(target);
+    target = target.parentNode;
+  }
+  let offset = 0;
+  let done = false;
+  function visit(n) {
+    if (done) return;
+    if (n === target) {
+      if (n.nodeType === Node.TEXT_NODE) {
+        offset += targetOff;
+        done = true;
+        return;
+      }
+      const children = n.childNodes;
+      for (let i = 0; i < targetOff && i < children.length; i++) {
+        visit(children[i]);
+        if (done) return;
+      }
+      done = true;
+      return;
+    }
+    if (n.nodeType === Node.TEXT_NODE) {
+      offset += (n.textContent ?? "").length;
+      return;
+    }
+    if (n.nodeType !== Node.ELEMENT_NODE) return;
+    const el = n;
+    if (isRejectedSubtree(el, container)) return;
+    if (isImgEmbed(el) && isWrapAnchorImg(el)) return;
+    if (isImgEmbed(el) || isPhantomEmbed(el)) {
+      offset += 1;
+      return;
+    }
+    for (const child of Array.from(el.childNodes)) {
+      visit(child);
+      if (done) return;
+    }
+  }
+  visit(container);
+  return offset;
+}
+function resolveAnchorElement(node, root) {
+  const blockEl = findContainingBlockElement(node, root);
+  if (!blockEl) return null;
+  const blockIdx = Number.parseInt(blockEl.dataset.blockIndex, 10);
+  const blockType = blockEl.dataset.blockType;
+  if (blockType === "table") {
+    const cellEl = findContainingCellElement(node, blockEl);
+    if (!cellEl) {
+      const firstCell = blockEl.querySelector("[data-cell-index]");
+      if (!firstCell) return null;
+      return {
+        blockIdx,
+        cellIdx: 0,
+        container: firstCell,
+        containerStart: 0
+      };
+    }
+    const cellIdx = Number.parseInt(cellEl.dataset.cellIndex, 10);
+    return {
+      blockIdx,
+      cellIdx,
+      container: cellEl,
+      containerStart: 0
+    };
+  }
+  return {
+    blockIdx,
+    cellIdx: void 0,
+    container: blockEl,
+    containerStart: readFragmentStart(blockEl)
+  };
+}
+function readDomSelection(root) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return null;
+  if (!sel.anchorNode || !sel.focusNode) return null;
+  if (!root.contains(sel.anchorNode) || !root.contains(sel.focusNode)) return null;
+  const a = resolveAnchorElement(sel.anchorNode, root);
+  const f = resolveAnchorElement(sel.focusNode, root);
+  if (!a || !f) return null;
+  const anchor = {
+    blockIndex: a.blockIdx,
+    cellIndex: a.cellIdx,
+    offset: a.containerStart + textOffsetWithin(a.container, sel.anchorNode, sel.anchorOffset)
+  };
+  const focus = {
+    blockIndex: f.blockIdx,
+    cellIndex: f.cellIdx,
+    offset: f.containerStart + textOffsetWithin(f.container, sel.focusNode, sel.focusOffset)
+  };
+  return { anchor, focus };
+}
+function locatePoint(root, pos) {
+  let container;
+  let containerStart = 0;
+  if (pos.cellIndex != null) {
+    container = getCellElement(root, pos.blockIndex, pos.cellIndex);
+    if (!container) return null;
+  } else {
+    container = getFragmentForOffset(root, pos.blockIndex, pos.offset);
+    if (!container) return null;
+    containerStart = readFragmentStart(container);
+  }
+  let remaining = Math.max(0, pos.offset - containerStart);
+  let result = null;
+  let lastImg = null;
+  function visit(n) {
+    if (result) return;
+    if (n.nodeType === Node.TEXT_NODE) {
+      const len = (n.textContent ?? "").length;
+      if (remaining <= len) {
+        result = { node: n, offset: remaining };
+        return;
+      }
+      remaining -= len;
+      lastImg = null;
+      return;
+    }
+    if (n.nodeType !== Node.ELEMENT_NODE) return;
+    const el = n;
+    if (isRejectedSubtree(el, container)) return;
+    if (isImgEmbed(el) && isWrapAnchorImg(el)) return;
+    if (isImgEmbed(el) || isPhantomEmbed(el)) {
+      if (remaining === 0) {
+        const parent = el.parentNode;
+        if (parent) {
+          result = { node: parent, offset: indexInParent(el) };
+          return;
+        }
+      }
+      remaining -= 1;
+      lastImg = el;
+      return;
+    }
+    for (const child of Array.from(el.childNodes)) {
+      visit(child);
+      if (result) return;
+    }
+  }
+  visit(container);
+  if (result) return result;
+  if (lastImg && remaining === 0) {
+    const parent = lastImg.parentNode;
+    if (parent) return { node: parent, offset: indexInParent(lastImg) + 1 };
+  }
+  return { node: container, offset: 0 };
+}
+function selectionsEqual(a, b) {
+  return a.anchor.blockIndex === b.anchor.blockIndex && (a.anchor.cellIndex ?? -1) === (b.anchor.cellIndex ?? -1) && a.anchor.offset === b.anchor.offset && a.focus.blockIndex === b.focus.blockIndex && (a.focus.cellIndex ?? -1) === (b.focus.cellIndex ?? -1) && a.focus.offset === b.focus.offset;
+}
+function isTableRectSelection(sel) {
+  if (sel.anchor.blockIndex !== sel.focus.blockIndex) return false;
+  if (sel.anchor.cellIndex == null || sel.focus.cellIndex == null) return false;
+  return sel.anchor.cellIndex !== sel.focus.cellIndex;
+}
+function applyDomSelection(root, modelSel) {
+  const domSel = window.getSelection();
+  if (!domSel) return;
+  if (isTableRectSelection(modelSel)) {
+    domSel.removeAllRanges();
+    return;
+  }
+  const anchorPt = locatePoint(root, modelSel.anchor);
+  const focusPt = locatePoint(root, modelSel.focus);
+  if (!anchorPt || !focusPt) return;
+  try {
+    domSel.removeAllRanges();
+    domSel.setBaseAndExtent(anchorPt.node, anchorPt.offset, focusPt.node, focusPt.offset);
+  } catch {
+  }
+}
+
+// src/EditorContext.tsx
+import { createContext, useContext } from "react";
+
+// src/LinkDialog.tsx
+import {
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function LinkDialog() {
+  const { linkRequest, resolveLinkRequest } = useEditorContext();
+  const dialogRef = useRef(null);
+  const inputRef = useRef(null);
+  const [href, setHref] = useState("");
+  useEffect(() => {
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    if (linkRequest) {
+      setHref(linkRequest.initialHref);
+      if (!dialog.open) dialog.showModal();
+      queueMicrotask(() => {
+        const input = inputRef.current;
+        if (input) {
+          input.focus();
+          input.select();
+        }
+      });
+    } else if (dialog.open) {
+      dialog.close();
+    }
+  }, [linkRequest]);
+  if (!linkRequest) return null;
+  const onSubmit = (e) => {
+    e.preventDefault();
+    resolveLinkRequest(href.trim());
+  };
+  const onRemove = () => {
+    resolveLinkRequest("");
+  };
+  const onCancel = () => {
+    resolveLinkRequest(null);
+  };
+  return /* @__PURE__ */ jsx(
+    "dialog",
+    {
+      ref: dialogRef,
+      className: "ed-link-dialog",
+      onClose: onCancel,
+      onCancel: (e) => {
+        e.preventDefault();
+        onCancel();
+      },
+      children: /* @__PURE__ */ jsxs("form", { onSubmit, className: "ed-link-dialog-form", children: [
+        /* @__PURE__ */ jsxs("div", { className: "ed-link-dialog-row", children: [
+          /* @__PURE__ */ jsx("label", { htmlFor: "ed-link-href", children: "URL" }),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              id: "ed-link-href",
+              ref: inputRef,
+              type: "url",
+              inputMode: "url",
+              value: href,
+              onChange: (e) => setHref(e.target.value),
+              placeholder: "https://exemplo.com",
+              autoComplete: "off"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "ed-link-dialog-actions", children: [
+          linkRequest.initialHref ? /* @__PURE__ */ jsx("button", { type: "button", onClick: onRemove, className: "ed-link-dialog-remove", children: "Remover link" }) : /* @__PURE__ */ jsx("span", {}),
+          /* @__PURE__ */ jsxs("div", { className: "ed-link-dialog-confirm", children: [
+            /* @__PURE__ */ jsx("button", { type: "button", onClick: onCancel, children: "Cancelar" }),
+            /* @__PURE__ */ jsx("button", { type: "submit", className: "ed-link-dialog-apply", children: "Aplicar" })
+          ] })
+        ] })
+      ] })
+    }
+  );
+}
+
+// src/PageConfigDialog.tsx
+import { useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+import {
+  MARGIN_PRESETS,
+  PAGE_PRESETS,
+  detectPreset,
+  mmToPx,
+  pxToMm
+} from "@sofereditor/core";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function PageConfigDialog() {
+  const { pageConfigRequest, resolvePageConfigRequest, setPageSettings } = useEditorContext();
+  const dialogRef = useRef2(null);
+  const [sizePreset, setSizePreset] = useState2("a4");
+  const [widthMm, setWidthMm] = useState2(210);
+  const [heightMm, setHeightMm] = useState2(297);
+  const [marginPreset, setMarginPreset] = useState2("normal");
+  const [marginTopMm, setMarginTopMm] = useState2(25.4);
+  const [marginBottomMm, setMarginBottomMm] = useState2(25.4);
+  const [marginLeftMm, setMarginLeftMm] = useState2(25.4);
+  const [marginRightMm, setMarginRightMm] = useState2(25.4);
+  useEffect2(() => {
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    if (pageConfigRequest) {
+      hydrateFromSettings(pageConfigRequest.initial, {
+        setSizePreset,
+        setWidthMm,
+        setHeightMm,
+        setMarginPreset,
+        setMarginTopMm,
+        setMarginBottomMm,
+        setMarginLeftMm,
+        setMarginRightMm
+      });
+      if (!dialog.open) dialog.showModal();
+    } else if (dialog.open) {
+      dialog.close();
+    }
+  }, [pageConfigRequest]);
+  useEffect2(() => {
+    if (sizePreset === "custom") return;
+    const p = PAGE_PRESETS[sizePreset];
+    setWidthMm(roundMm(pxToMm(p.width)));
+    setHeightMm(roundMm(pxToMm(p.height)));
+  }, [sizePreset]);
+  useEffect2(() => {
+    if (marginPreset === "custom") return;
+    const px = MARGIN_PRESETS[marginPreset];
+    const mm = roundMm(pxToMm(px));
+    setMarginTopMm(mm);
+    setMarginBottomMm(mm);
+    setMarginLeftMm(mm);
+    setMarginRightMm(mm);
+  }, [marginPreset]);
+  const customWidth = sizePreset === "custom";
+  const previewPx = useMemo(
+    () => ({
+      width: Math.round(mmToPx(widthMm)),
+      height: Math.round(mmToPx(heightMm))
+    }),
+    [widthMm, heightMm]
+  );
+  if (!pageConfigRequest) return null;
+  const onApply = (e) => {
+    e.preventDefault();
+    const next = {
+      width: mmToPx(widthMm),
+      height: mmToPx(heightMm),
+      marginTop: mmToPx(marginTopMm),
+      marginBottom: mmToPx(marginBottomMm),
+      marginLeft: mmToPx(marginLeftMm),
+      marginRight: mmToPx(marginRightMm)
+    };
+    setPageSettings(next);
+    resolvePageConfigRequest(true);
+  };
+  const onCancel = () => resolvePageConfigRequest(false);
+  return /* @__PURE__ */ jsx2(
+    "dialog",
+    {
+      ref: dialogRef,
+      className: "ed-page-config-dialog",
+      onClose: onCancel,
+      onCancel: (e) => {
+        e.preventDefault();
+        onCancel();
+      },
+      children: /* @__PURE__ */ jsxs2("form", { onSubmit: onApply, className: "ed-page-config-form", children: [
+        /* @__PURE__ */ jsx2("h2", { children: "Configurar p\xE1gina" }),
+        /* @__PURE__ */ jsxs2("fieldset", { children: [
+          /* @__PURE__ */ jsx2("legend", { children: "Tamanho" }),
+          /* @__PURE__ */ jsxs2("div", { className: "ed-page-config-row", children: [
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "size",
+                  checked: sizePreset === "a4",
+                  onChange: () => setSizePreset("a4")
+                }
+              ),
+              " ",
+              "A4 (210 \xD7 297 mm)"
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "size",
+                  checked: sizePreset === "letter",
+                  onChange: () => setSizePreset("letter")
+                }
+              ),
+              " ",
+              "Carta (216 \xD7 279 mm)"
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "size",
+                  checked: sizePreset === "oficio",
+                  onChange: () => setSizePreset("oficio")
+                }
+              ),
+              " ",
+              "Of\xEDcio (216 \xD7 330 mm)"
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "size",
+                  checked: sizePreset === "custom",
+                  onChange: () => setSizePreset("custom")
+                }
+              ),
+              " ",
+              "Personalizado"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs2("div", { className: "ed-page-config-row", children: [
+            /* @__PURE__ */ jsxs2("label", { children: [
+              "Largura (mm)",
+              " ",
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "number",
+                  step: 0.1,
+                  min: 50,
+                  max: 1e3,
+                  value: widthMm,
+                  onChange: (e) => setWidthMm(Number(e.target.value)),
+                  disabled: !customWidth
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              "Altura (mm)",
+              " ",
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "number",
+                  step: 0.1,
+                  min: 50,
+                  max: 1e3,
+                  value: heightMm,
+                  onChange: (e) => setHeightMm(Number(e.target.value)),
+                  disabled: !customWidth
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs2("span", { className: "ed-page-config-preview", children: [
+              previewPx.width,
+              " \xD7 ",
+              previewPx.height,
+              " px"
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2("fieldset", { children: [
+          /* @__PURE__ */ jsx2("legend", { children: "Margens" }),
+          /* @__PURE__ */ jsxs2("div", { className: "ed-page-config-row", children: [
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "margin",
+                  checked: marginPreset === "normal",
+                  onChange: () => setMarginPreset("normal")
+                }
+              ),
+              " ",
+              "Normal (25,4 mm)"
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "margin",
+                  checked: marginPreset === "narrow",
+                  onChange: () => setMarginPreset("narrow")
+                }
+              ),
+              " ",
+              "Estreita (12,7 mm)"
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "margin",
+                  checked: marginPreset === "wide",
+                  onChange: () => setMarginPreset("wide")
+                }
+              ),
+              " ",
+              "Larga (50,8 mm)"
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "radio",
+                  name: "margin",
+                  checked: marginPreset === "custom",
+                  onChange: () => setMarginPreset("custom")
+                }
+              ),
+              " ",
+              "Personalizada"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs2("div", { className: "ed-page-config-row", children: [
+            /* @__PURE__ */ jsxs2("label", { children: [
+              "Topo",
+              " ",
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "number",
+                  step: 0.1,
+                  min: 0,
+                  max: 200,
+                  value: marginTopMm,
+                  onChange: (e) => {
+                    setMarginTopMm(Number(e.target.value));
+                    setMarginPreset("custom");
+                  }
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              "Inferior",
+              " ",
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "number",
+                  step: 0.1,
+                  min: 0,
+                  max: 200,
+                  value: marginBottomMm,
+                  onChange: (e) => {
+                    setMarginBottomMm(Number(e.target.value));
+                    setMarginPreset("custom");
+                  }
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              "Esquerda",
+              " ",
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "number",
+                  step: 0.1,
+                  min: 0,
+                  max: 200,
+                  value: marginLeftMm,
+                  onChange: (e) => {
+                    setMarginLeftMm(Number(e.target.value));
+                    setMarginPreset("custom");
+                  }
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs2("label", { children: [
+              "Direita",
+              " ",
+              /* @__PURE__ */ jsx2(
+                "input",
+                {
+                  type: "number",
+                  step: 0.1,
+                  min: 0,
+                  max: 200,
+                  value: marginRightMm,
+                  onChange: (e) => {
+                    setMarginRightMm(Number(e.target.value));
+                    setMarginPreset("custom");
+                  }
+                }
+              )
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "ed-page-config-actions", children: [
+          /* @__PURE__ */ jsx2("button", { type: "button", onClick: onCancel, children: "Cancelar" }),
+          /* @__PURE__ */ jsx2("button", { type: "submit", className: "ed-page-config-apply", children: "Aplicar" })
+        ] })
+      ] })
+    }
+  );
+}
+function roundMm(mm) {
+  return Math.round(mm * 10) / 10;
+}
+function hydrateFromSettings(s, setters) {
+  const preset = detectPreset(s.width, s.height);
+  setters.setSizePreset(preset);
+  setters.setWidthMm(roundMm(pxToMm(s.width)));
+  setters.setHeightMm(roundMm(pxToMm(s.height)));
+  const top = roundMm(pxToMm(s.marginTop));
+  const bottom = roundMm(pxToMm(s.marginBottom));
+  const left = roundMm(pxToMm(s.marginLeft));
+  const right = roundMm(pxToMm(s.marginRight));
+  setters.setMarginTopMm(top);
+  setters.setMarginBottomMm(bottom);
+  setters.setMarginLeftMm(left);
+  setters.setMarginRightMm(right);
+  setters.setMarginPreset(detectMarginPreset(s));
+}
+function detectMarginPreset(s) {
+  const TOL = 1;
+  const allEqual = Math.abs(s.marginTop - s.marginBottom) <= TOL && Math.abs(s.marginTop - s.marginLeft) <= TOL && Math.abs(s.marginTop - s.marginRight) <= TOL;
+  if (!allEqual) return "custom";
+  for (const [name, px] of Object.entries(MARGIN_PRESETS)) {
+    if (Math.abs(s.marginTop - px) <= TOL) return name;
+  }
+  return "custom";
+}
+
+// src/ImageCaptionDialog.tsx
+import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ImageCaptionDialog() {
+  const { imageCaptionRequest, resolveImageCaptionRequest } = useEditorContext();
+  const dialogRef = useRef3(null);
+  const inputRef = useRef3(null);
+  const [caption, setCaption] = useState3("");
+  const [align, setAlign] = useState3("center");
+  useEffect3(() => {
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    if (imageCaptionRequest) {
+      setCaption(imageCaptionRequest.initialCaption);
+      setAlign(imageCaptionRequest.initialAlign);
+      if (!dialog.open) dialog.showModal();
+      queueMicrotask(() => {
+        const input = inputRef.current;
+        if (input) {
+          input.focus();
+          input.select();
+        }
+      });
+    } else if (dialog.open) {
+      dialog.close();
+    }
+  }, [imageCaptionRequest]);
+  if (!imageCaptionRequest) return null;
+  const onSubmit = (e) => {
+    e.preventDefault();
+    resolveImageCaptionRequest({ caption, align });
+  };
+  const onRemove = () => resolveImageCaptionRequest({ caption: "", align });
+  const onCancel = () => resolveImageCaptionRequest(null);
+  return /* @__PURE__ */ jsx3(
+    "dialog",
+    {
+      ref: dialogRef,
+      className: "ed-caption-dialog ed-link-dialog",
+      onClose: onCancel,
+      onCancel: (e) => {
+        e.preventDefault();
+        onCancel();
+      },
+      children: /* @__PURE__ */ jsxs3("form", { onSubmit, className: "ed-link-dialog-form", children: [
+        /* @__PURE__ */ jsxs3("div", { className: "ed-link-dialog-row", children: [
+          /* @__PURE__ */ jsx3("label", { htmlFor: "ed-caption-input", children: "Legenda" }),
+          /* @__PURE__ */ jsx3(
+            "input",
+            {
+              id: "ed-caption-input",
+              ref: inputRef,
+              type: "text",
+              value: caption,
+              onChange: (e) => setCaption(e.target.value),
+              placeholder: "Ex.: Figura 1 \u2014 Mapa do Brasil",
+              autoComplete: "off"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "ed-link-dialog-row", children: [
+          /* @__PURE__ */ jsx3("span", { children: "Alinhamento" }),
+          /* @__PURE__ */ jsx3("div", { className: "ed-caption-align-group", role: "radiogroup", "aria-label": "Alinhamento da legenda", children: ["left", "center", "right"].map((value) => /* @__PURE__ */ jsxs3("label", { className: "ed-caption-align-option", children: [
+            /* @__PURE__ */ jsx3(
+              "input",
+              {
+                type: "radio",
+                name: "caption-align",
+                value,
+                checked: align === value,
+                onChange: () => setAlign(value)
+              }
+            ),
+            value === "left" ? "Esquerda" : value === "center" ? "Centro" : "Direita"
+          ] }, value)) })
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "ed-link-dialog-actions", children: [
+          imageCaptionRequest.initialCaption ? /* @__PURE__ */ jsx3("button", { type: "button", onClick: onRemove, className: "ed-link-dialog-remove", children: "Remover legenda" }) : /* @__PURE__ */ jsx3("span", {}),
+          /* @__PURE__ */ jsxs3("div", { className: "ed-link-dialog-confirm", children: [
+            /* @__PURE__ */ jsx3("button", { type: "button", onClick: onCancel, children: "Cancelar" }),
+            /* @__PURE__ */ jsx3("button", { type: "submit", className: "ed-link-dialog-apply", children: "Aplicar" })
+          ] })
+        ] })
+      ] })
+    }
+  );
+}
+
+// src/EditorContext.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var EditorContext = createContext(null);
+function EditorProvider({ editor, children }) {
+  return /* @__PURE__ */ jsxs4(EditorContext.Provider, { value: editor, children: [
+    children,
+    /* @__PURE__ */ jsx4(LinkDialog, {}),
+    /* @__PURE__ */ jsx4(PageConfigDialog, {}),
+    /* @__PURE__ */ jsx4(ImageCaptionDialog, {})
+  ] });
+}
+function useEditorContext() {
+  const ctx = useContext(EditorContext);
+  if (!ctx) {
+    throw new Error("useEditorContext must be used inside an <EditorProvider>");
+  }
+  return ctx;
+}
+
+// src/ImageResizeOverlay.tsx
+import {
+  useCallback,
+  useEffect as useEffect4,
+  useLayoutEffect,
+  useRef as useRef4,
+  useState as useState4
+} from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ImageResizeOverlay({
+  rootRef,
+  blockIndex,
+  offset,
+  cellIndex,
+  embed,
+  onCommit,
+  onCommitMove
+}) {
+  const [rect, setRect] = useState4(null);
+  const imgRef = useRef4(null);
+  const locateImage = useCallback(() => {
+    const root = rootRef.current;
+    if (!root) return null;
+    let container = null;
+    if (cellIndex != null) {
+      container = root.querySelector(
+        `[data-block-index="${blockIndex}"] [data-cell-index="${cellIndex}"]`
+      );
+    } else {
+      container = getFragmentForOffset(root, blockIndex, offset);
+    }
+    if (!container) return null;
+    const fragmentStart = container.dataset.fragmentStart ? Number.parseInt(container.dataset.fragmentStart, 10) || 0 : 0;
+    const localOffset = offset - fragmentStart;
+    return container.querySelector(
+      `img[data-embed="image"][data-embed-offset="${localOffset}"]`
+    );
+  }, [rootRef, blockIndex, offset, cellIndex]);
+  const measure = useCallback(() => {
+    const img = locateImage();
+    if (!img) {
+      setRect((prev) => prev === null ? prev : null);
+      return;
+    }
+    imgRef.current = img;
+    const root = rootRef.current;
+    if (!root) return;
+    const r = img.getBoundingClientRect();
+    const rr = root.getBoundingClientRect();
+    const next = {
+      top: r.top - rr.top + root.scrollTop,
+      left: r.left - rr.left + root.scrollLeft,
+      width: r.width,
+      height: r.height
+    };
+    setRect(
+      (prev) => prev && prev.top === next.top && prev.left === next.left && prev.width === next.width && prev.height === next.height ? prev : next
+    );
+  }, [locateImage, rootRef]);
+  useLayoutEffect(() => {
+    measure();
+    let cancelled = false;
+    const remeasure = () => {
+      if (cancelled) return;
+      measure();
+    };
+    const id = typeof requestAnimationFrame === "function" ? requestAnimationFrame(remeasure) : (queueMicrotask(remeasure), 0);
+    return () => {
+      cancelled = true;
+      if (typeof cancelAnimationFrame === "function" && typeof id === "number" && id > 0) {
+        cancelAnimationFrame(id);
+      }
+    };
+  }, [
+    measure,
+    embed.width,
+    embed.height,
+    embed.align,
+    embed.src,
+    embed.layout,
+    embed.offsetX,
+    embed.offsetY
+  ]);
+  useEffect4(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const onScroll = () => measure();
+    window.addEventListener("resize", onScroll);
+    root.addEventListener("scroll", onScroll);
+    return () => {
+      window.removeEventListener("resize", onScroll);
+      root.removeEventListener("scroll", onScroll);
+    };
+  }, [measure, rootRef]);
+  useEffect4(() => {
+    if (typeof ResizeObserver === "undefined") return;
+    const img = locateImage();
+    const root = rootRef.current;
+    if (!img || !root) return;
+    const ro = new ResizeObserver(() => measure());
+    ro.observe(img);
+    ro.observe(root);
+    return () => ro.disconnect();
+  }, [locateImage, measure, rootRef, embed.layout, embed.align, embed.src]);
+  if (!rect) return null;
+  const layout = embed.layout ?? "inline";
+  const movable = layout !== "inline" && onCommitMove !== void 0;
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: "ed-image-overlay",
+      style: { top: rect.top, left: rect.left, width: rect.width, height: rect.height },
+      contentEditable: false,
+      children: [
+        movable && /* @__PURE__ */ jsx5(
+          MoveHandle,
+          {
+            layout,
+            startOffsetX: embed.offsetX ?? 0,
+            startOffsetY: embed.offsetY ?? 0,
+            imgRef,
+            onCommit: onCommitMove,
+            onLiveChange: measure
+          }
+        ),
+        /* @__PURE__ */ jsx5(
+          Handle,
+          {
+            corner: "nw",
+            startW: embed.width,
+            startH: embed.height,
+            imgRef,
+            onCommit,
+            onLiveChange: measure
+          }
+        ),
+        /* @__PURE__ */ jsx5(
+          Handle,
+          {
+            corner: "ne",
+            startW: embed.width,
+            startH: embed.height,
+            imgRef,
+            onCommit,
+            onLiveChange: measure
+          }
+        ),
+        /* @__PURE__ */ jsx5(
+          Handle,
+          {
+            corner: "sw",
+            startW: embed.width,
+            startH: embed.height,
+            imgRef,
+            onCommit,
+            onLiveChange: measure
+          }
+        ),
+        /* @__PURE__ */ jsx5(
+          Handle,
+          {
+            corner: "se",
+            startW: embed.width,
+            startH: embed.height,
+            imgRef,
+            onCommit,
+            onLiveChange: measure
+          }
+        )
+      ]
+    }
+  );
+}
+function MoveHandle({
+  layout,
+  startOffsetX,
+  startOffsetY,
+  imgRef,
+  onCommit,
+  onLiveChange
+}) {
+  const dragRef = useRef4(null);
+  const onPointerDown = (e) => {
+    if (e.button !== 0) return;
+    if (!imgRef.current) return;
+    e.preventDefault();
+    e.stopPropagation();
+    e.target.setPointerCapture(e.pointerId);
+    dragRef.current = {
+      startX: e.clientX,
+      startY: e.clientY,
+      liveOX: startOffsetX,
+      liveOY: startOffsetY
+    };
+  };
+  const onPointerMove = (e) => {
+    const d = dragRef.current;
+    if (!d || !imgRef.current) return;
+    const dx = e.clientX - d.startX;
+    const dy = e.clientY - d.startY;
+    const img = imgRef.current;
+    let nox = startOffsetX;
+    let noy = startOffsetY;
+    if (layout === "wrap-left") {
+      nox = Math.max(8, startOffsetX + dx);
+      noy = Math.max(0, startOffsetY + dy);
+      img.style.marginRight = `${nox}px`;
+      img.style.marginTop = `${noy}px`;
+    } else if (layout === "wrap-right") {
+      nox = Math.max(8, startOffsetX - dx);
+      noy = Math.max(0, startOffsetY + dy);
+      img.style.marginLeft = `${nox}px`;
+      img.style.marginTop = `${noy}px`;
+    } else if (layout === "behind" || layout === "front") {
+      nox = startOffsetX + dx;
+      noy = startOffsetY + dy;
+      img.style.left = `${nox}px`;
+      img.style.top = `${noy}px`;
+    }
+    d.liveOX = nox;
+    d.liveOY = noy;
+    onLiveChange();
+  };
+  const finish = (e) => {
+    const d = dragRef.current;
+    if (!d) return;
+    dragRef.current = null;
+    try {
+      e.target.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+    onCommit(Math.round(d.liveOX), Math.round(d.liveOY));
+  };
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      className: "ed-image-move",
+      onPointerDown,
+      onPointerMove,
+      onPointerUp: finish,
+      onPointerCancel: finish
+    }
+  );
+}
+var MIN_W = 20;
+function Handle({
+  corner,
+  startW,
+  startH,
+  imgRef,
+  onCommit,
+  onLiveChange
+}) {
+  const dragRef = useRef4(null);
+  const onPointerDown = (e) => {
+    if (e.button !== 0) return;
+    if (!imgRef.current) return;
+    e.preventDefault();
+    e.stopPropagation();
+    e.target.setPointerCapture(e.pointerId);
+    const aspect = startW > 0 && startH > 0 ? startW / startH : 1;
+    dragRef.current = {
+      startX: e.clientX,
+      startY: e.clientY,
+      startW,
+      startH,
+      aspect,
+      liveW: startW,
+      liveH: startH
+    };
+  };
+  const onPointerMove = (e) => {
+    const d = dragRef.current;
+    if (!d || !imgRef.current) return;
+    const dxRaw = e.clientX - d.startX;
+    const dx = corner === "se" || corner === "ne" ? dxRaw : -dxRaw;
+    let w = Math.max(MIN_W, d.startW + dx);
+    let h = w / d.aspect;
+    imgRef.current.style.width = `${w}px`;
+    imgRef.current.style.height = `${h}px`;
+    imgRef.current.width = Math.round(w);
+    imgRef.current.height = Math.round(h);
+    d.liveW = w;
+    d.liveH = h;
+    onLiveChange();
+  };
+  const finish = (e) => {
+    const d = dragRef.current;
+    if (!d) return;
+    dragRef.current = null;
+    try {
+      e.target.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+    onCommit(Math.round(d.liveW), Math.round(d.liveH));
+  };
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      className: `ed-image-handle ${corner}`,
+      onPointerDown,
+      onPointerMove,
+      onPointerUp: finish,
+      onPointerCancel: finish
+    }
+  );
+}
+
+// src/NodeView.tsx
+import { useMemo as useMemo2, useRef as useRef6 } from "react";
+import { tableRectSelection } from "@sofereditor/core";
+
+// src/renderInline.tsx
+import { Fragment, memo } from "react";
+import { isImageEmbed } from "@sofereditor/core";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function renderInline(delta, keyPrefix) {
+  if (delta.length === 0 || delta.length === 1 && typeof delta[0].insert === "string" && delta[0].insert === "") {
+    return /* @__PURE__ */ jsx6("br", { "data-empty": "true" });
+  }
+  let offset = 0;
+  const wrapAnchors = [];
+  const body = [];
+  for (const op of delta) {
+    if (typeof op.insert === "string") {
+      const text = op.insert;
+      if (text.length === 0) continue;
+      const key = `${keyPrefix}-${offset}`;
+      body.push(/* @__PURE__ */ jsx6(Fragment, { children: wrap(text, op.attributes) }, key));
+      offset += text.length;
+    } else if (isImageEmbed(op.insert)) {
+      const key = `${keyPrefix}-${offset}`;
+      const layout = op.insert.layout ?? "inline";
+      if (layout === "wrap-left" || layout === "wrap-right") {
+        wrapAnchors.push(
+          /* @__PURE__ */ jsx6(ImageEmbedView, { embed: op.insert, offset, wrapAnchor: true }, `${key}-anchor`)
+        );
+        body.push(
+          /* @__PURE__ */ jsx6(
+            "span",
+            {
+              "data-embed-phantom": "true",
+              "data-embed-offset": offset,
+              contentEditable: false,
+              style: PHANTOM_STYLE
+            },
+            `${key}-phantom`
+          )
+        );
+      } else {
+        body.push(/* @__PURE__ */ jsx6(ImageEmbedView, { embed: op.insert, offset }, key));
+      }
+      offset += 1;
+    } else if (op.insert != null) {
+      offset += 1;
+    }
+  }
+  if (wrapAnchors.length === 0 && body.length === 0) return /* @__PURE__ */ jsx6("br", { "data-empty": "true" });
+  return [...wrapAnchors, ...body];
+}
+var PHANTOM_STYLE = {
+  display: "inline-block",
+  width: 0,
+  height: 0,
+  overflow: "hidden",
+  verticalAlign: "baseline"
+};
+function imageEmbedPropsEqual(a, b) {
+  if (a.offset !== b.offset || a.wrapAnchor !== b.wrapAnchor) return false;
+  const x = a.embed;
+  const y = b.embed;
+  if (x === y) return true;
+  return x.width === y.width && x.height === y.height && x.layout === y.layout && x.align === y.align && x.offsetX === y.offsetX && x.offsetY === y.offsetY && x.caption === y.caption && x.captionAlign === y.captionAlign && // src is the expensive compare — only fall back to ref equality. Fresh
+  // toDelta() objects share the same string reference for embed payloads
+  // because Y.js stores the embed in its content map and re-exposes it.
+  x.src === y.src;
+}
+var ImageEmbedView = memo(ImageEmbedViewImpl, imageEmbedPropsEqual);
+function ImageEmbedViewImpl({
+  embed,
+  offset,
+  wrapAnchor
+}) {
+  const layout = embed.layout ?? "inline";
+  const align = embed.align;
+  const ox = embed.offsetX ?? 0;
+  const oy = embed.offsetY ?? 0;
+  const hasCaption = !!embed.caption && embed.caption.length > 0;
+  let outerStyle;
+  switch (layout) {
+    case "wrap-left":
+      outerStyle = {
+        float: "left",
+        width: embed.width,
+        marginRight: Math.max(8, ox),
+        marginTop: Math.max(0, oy),
+        marginBottom: 4
+      };
+      break;
+    case "wrap-right":
+      outerStyle = {
+        float: "right",
+        width: embed.width,
+        marginLeft: Math.max(8, ox),
+        marginTop: Math.max(0, oy),
+        marginBottom: 4
+      };
+      break;
+    case "behind":
+    case "front":
+      outerStyle = {
+        position: "absolute",
+        left: ox,
+        top: oy,
+        width: embed.width,
+        zIndex: layout === "behind" ? -1 : 2
+      };
+      break;
+    case "inline":
+    default:
+      outerStyle = align ? {
+        display: "block",
+        width: embed.width,
+        marginLeft: align === "left" ? 0 : "auto",
+        marginRight: align === "right" ? 0 : "auto"
+      } : {
+        display: "inline-block",
+        verticalAlign: "text-bottom",
+        width: embed.width
+      };
+      break;
+  }
+  const imgStyle = hasCaption ? { width: embed.width, height: embed.height, display: "block" } : outerStyle;
+  const img = /* @__PURE__ */ jsx6(
+    "img",
+    {
+      src: embed.src,
+      width: embed.width,
+      height: embed.height,
+      contentEditable: false,
+      draggable: false,
+      "data-embed": "image",
+      "data-embed-offset": offset,
+      "data-embed-align": align ?? "",
+      "data-embed-layout": layout,
+      "data-wrap-anchor": wrapAnchor ? "true" : void 0,
+      style: imgStyle,
+      alt: ""
+    }
+  );
+  if (!hasCaption) return img;
+  const captionAlign = embed.captionAlign ?? "center";
+  return /* @__PURE__ */ jsxs6(
+    "figure",
+    {
+      className: "ed-figure",
+      contentEditable: false,
+      "data-embed-figure": "true",
+      "data-embed-layout": layout,
+      style: outerStyle,
+      children: [
+        img,
+        /* @__PURE__ */ jsx6(
+          "figcaption",
+          {
+            className: "ed-figcaption",
+            "data-caption-align": captionAlign,
+            style: { textAlign: captionAlign },
+            children: embed.caption
+          }
+        )
+      ]
+    }
+  );
+}
+function wrap(text, attrs) {
+  let node = text;
+  if (!attrs) return node;
+  if (attrs.bold) node = /* @__PURE__ */ jsx6("strong", { children: node });
+  if (attrs.italic) node = /* @__PURE__ */ jsx6("em", { children: node });
+  if (attrs.underline) node = /* @__PURE__ */ jsx6("u", { children: node });
+  if (attrs.strike) node = /* @__PURE__ */ jsx6("s", { children: node });
+  const styleParts = {};
+  if (attrs.color) styleParts.color = attrs.color;
+  if (attrs.fontFamily) styleParts.fontFamily = attrs.fontFamily;
+  if (attrs.fontSize) styleParts.fontSize = attrs.fontSize;
+  if (Object.keys(styleParts).length > 0) {
+    node = /* @__PURE__ */ jsx6("span", { style: styleParts, children: node });
+  }
+  if (attrs.link?.href) {
+    node = /* @__PURE__ */ jsx6(
+      "a",
+      {
+        href: attrs.link.href,
+        title: attrs.link.title,
+        rel: "noopener noreferrer",
+        target: "_blank",
+        onClick: (e) => {
+          if (!(e.metaKey || e.ctrlKey)) e.preventDefault();
+        },
+        children: node
+      }
+    );
+  }
+  if (attrs.comment?.markId) {
+    node = /* @__PURE__ */ jsx6("span", { "data-comment-id": attrs.comment.markId, className: "ed-comment", children: node });
+  }
+  return node;
+}
+
+// src/sliceDelta.ts
+function deltaLength(delta) {
+  let sum = 0;
+  for (const op of delta) {
+    if (typeof op.insert === "string") sum += op.insert.length;
+    else if (op.insert != null) sum += 1;
+  }
+  return sum;
+}
+function sliceDelta(delta, start, end) {
+  if (end <= start) return [];
+  const out = [];
+  let cursor = 0;
+  for (const op of delta) {
+    if (typeof op.insert === "string") {
+      const opStart = cursor;
+      const opEnd = cursor + op.insert.length;
+      cursor = opEnd;
+      if (opEnd <= start) continue;
+      if (opStart >= end) break;
+      const sliceFrom = Math.max(opStart, start) - opStart;
+      const sliceTo = Math.min(opEnd, end) - opStart;
+      out.push({
+        insert: op.insert.slice(sliceFrom, sliceTo),
+        attributes: op.attributes
+      });
+    } else if (op.insert != null) {
+      const opStart = cursor;
+      const opEnd = cursor + 1;
+      cursor = opEnd;
+      if (opEnd <= start) continue;
+      if (opStart >= end) break;
+      out.push({ insert: op.insert, attributes: op.attributes });
+    }
+  }
+  return out;
+}
+
+// src/TableResizeOverlay.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect5,
+  useLayoutEffect as useLayoutEffect2,
+  useRef as useRef5,
+  useState as useState5
+} from "react";
+import { Fragment as Fragment2, jsx as jsx7 } from "react/jsx-runtime";
+function TableResizeOverlay({ tableRef, blockIndex, cols }) {
+  const editor = useEditorContext();
+  const [positions, setPositions] = useState5(null);
+  const [layout, setLayout] = useState5(null);
+  const draggingRef = useRef5(null);
+  const measure = useCallback2(() => {
+    const table = tableRef.current;
+    if (!table) return;
+    const tableRect = table.getBoundingClientRect();
+    const cgCols = table.querySelectorAll("colgroup > col");
+    let rights = [];
+    if (cgCols.length === cols) {
+      let acc = 0;
+      cgCols.forEach((c) => {
+        acc += c.getBoundingClientRect().width;
+        rights.push(acc);
+      });
+    } else {
+      const firstRowCells = table.querySelectorAll("tbody > tr:first-child > td");
+      let acc = 0;
+      firstRowCells.forEach((td) => {
+        const cs = Math.max(1, td.colSpan || 1);
+        const w = td.getBoundingClientRect().width / cs;
+        for (let i = 0; i < cs; i++) {
+          acc += w;
+          rights.push(acc);
+        }
+      });
+    }
+    if (rights.length !== cols) {
+      setLayout(null);
+      return;
+    }
+    setLayout({ rights, height: tableRect.height });
+  }, [cols, tableRef]);
+  useLayoutEffect2(() => {
+    measure();
+  }, [measure]);
+  useEffect5(() => {
+    const table = tableRef.current;
+    if (!table) return;
+    const ro = new ResizeObserver(() => measure());
+    ro.observe(table);
+    return () => ro.disconnect();
+  }, [measure, tableRef]);
+  const onPointerDown = useCallback2(
+    (col) => (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      const table = tableRef.current;
+      if (!table) return;
+      const cgCols = table.querySelectorAll("colgroup > col");
+      const startWidth = cgCols[col]?.getBoundingClientRect().width ?? 100;
+      draggingRef.current = { col, startX: e.clientX, startWidth };
+      setPositions({ x: e.clientX, height: layout?.height ?? 0 });
+      e.currentTarget.setPointerCapture(e.pointerId);
+    },
+    [layout, tableRef]
+  );
+  const onPointerMove = useCallback2(
+    (e) => {
+      const d = draggingRef.current;
+      if (!d) return;
+      const dx = e.clientX - d.startX;
+      const next = Math.max(40, d.startWidth + dx);
+      editor.setColumnWidth(blockIndex, d.col, next);
+    },
+    [blockIndex, editor]
+  );
+  const onPointerUp = useCallback2((e) => {
+    draggingRef.current = null;
+    setPositions(null);
+    try {
+      e.currentTarget.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+  }, []);
+  if (!layout) return null;
+  const handleStyle = (x) => ({
+    position: "absolute",
+    top: 0,
+    left: `${x - 3}px`,
+    width: "6px",
+    height: `${layout.height}px`,
+    cursor: "col-resize",
+    zIndex: 5
+  });
+  void positions;
+  return /* @__PURE__ */ jsx7(Fragment2, { children: layout.rights.map((x, c) => /* @__PURE__ */ jsx7(
+    "div",
+    {
+      contentEditable: false,
+      className: "ed-col-resize-handle",
+      style: handleStyle(x),
+      onPointerDown: onPointerDown(c),
+      onPointerMove,
+      onPointerUp,
+      "aria-label": `Redimensionar coluna ${c + 1}`,
+      role: "separator"
+    },
+    c
+  )) });
+}
+
+// src/NodeView.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function NodeView({ block, index, children, fragment, tableFragment }) {
+  if (block.type === "table") {
+    return /* @__PURE__ */ jsx8(TableView, { block, index, tableFragment });
+  }
+  const inline = fragment ? renderInline(sliceDelta(block.delta, fragment.start, fragment.end), index) : renderInline(block.delta, index);
+  const common = commonBlockProps(block.attrs, index, block.type, fragment);
+  switch (block.type) {
+    case "heading": {
+      const level = clampLevel(block.attrs.level);
+      const Tag = `h${level}`;
+      return /* @__PURE__ */ jsx8(
+        Tag,
+        {
+          ...common,
+          className: `ed-block ed-heading ed-heading-${level}${alignClass(block.attrs.align)}${fragmentClass(fragment)}`,
+          children: inline
+        }
+      );
+    }
+    case "blockquote":
+      return /* @__PURE__ */ jsx8(
+        "blockquote",
+        {
+          ...common,
+          className: `ed-block ed-blockquote${alignClass(block.attrs.align)}${fragmentClass(fragment)}`,
+          children: inline
+        }
+      );
+    case "codeBlock":
+      return /* @__PURE__ */ jsx8(
+        "pre",
+        {
+          ...common,
+          "data-language": block.attrs.language ?? void 0,
+          className: `ed-block ed-codeblock${alignClass(block.attrs.align)}`,
+          children: /* @__PURE__ */ jsx8("code", { children: inline })
+        }
+      );
+    case "listItem": {
+      const level = clampListLevel(block.attrs.listLevel);
+      return /* @__PURE__ */ jsxs7(
+        "li",
+        {
+          ...common,
+          "data-list-kind": block.attrs.listKind ?? "bullet",
+          "data-list-level": level,
+          className: `ed-block ed-listitem${alignClass(block.attrs.align)}`,
+          children: [
+            inline,
+            children
+          ]
+        }
+      );
+    }
+    case "paragraph":
+    default:
+      return /* @__PURE__ */ jsx8(
+        "div",
+        {
+          ...common,
+          className: `ed-block ed-paragraph${alignClass(block.attrs.align)}${fragmentClass(fragment)}`,
+          children: inline
+        }
+      );
+  }
+}
+function commonBlockProps(attrs, index, type, fragment) {
+  const style = {};
+  if (attrs.align) style.textAlign = attrs.align;
+  const base = {
+    "data-block-index": index,
+    "data-block-type": type,
+    dir: attrs.dir,
+    style: Object.keys(style).length > 0 ? style : void 0
+  };
+  if (!fragment) return base;
+  base["data-fragment-index"] = fragment.index;
+  base["data-fragment-start"] = fragment.start;
+  base["data-fragment-end"] = fragment.end;
+  return base;
+}
+function fragmentClass(f) {
+  if (!f) return "";
+  return ` ed-fragment ed-fragment-${f.index}`;
+}
+function alignClass(a) {
+  return a ? ` ed-align-${a}` : "";
+}
+function clampLevel(l) {
+  if (l === 2 || l === 3 || l === 4 || l === 5 || l === 6) return l;
+  return 1;
+}
+function clampListLevel(l) {
+  if (typeof l !== "number" || !Number.isFinite(l)) return 0;
+  return Math.max(0, Math.min(5, Math.trunc(l)));
+}
+function TableView({ block, index, tableFragment }) {
+  const rows = clampPositive(block.attrs.rows);
+  const cols = clampPositive(block.attrs.cols);
+  const cells = block.cells ?? [];
+  const widths = readColWidths(block.attrs.colWidths, cols);
+  const tableRef = useRef6(null);
+  const rowStart = tableFragment?.rowStart ?? 0;
+  const rowEnd = tableFragment?.rowEnd ?? rows;
+  const isFirstFragment = !tableFragment || tableFragment.index === 0;
+  const editor = useEditorContext();
+  const rect = useMemo2(() => {
+    if (editor.selection.anchor.blockIndex !== index) return null;
+    if (editor.selection.focus.blockIndex !== index) return null;
+    return tableRectSelection(editor.doc, editor.selection);
+  }, [editor.doc, editor.selection, index]);
+  return /* @__PURE__ */ jsxs7("div", { className: "ed-table-wrap", children: [
+    /* @__PURE__ */ jsxs7(
+      "table",
+      {
+        ref: tableRef,
+        "data-block-index": index,
+        "data-block-type": "table",
+        className: "ed-block ed-table",
+        children: [
+          widths && /* @__PURE__ */ jsx8("colgroup", { children: widths.map((w, c) => /* @__PURE__ */ jsx8("col", { style: w != null ? { width: `${w}px` } : void 0 }, c)) }),
+          /* @__PURE__ */ jsx8("tbody", { children: Array.from({ length: rowEnd - rowStart }, (_, i) => {
+            const r = rowStart + i;
+            return /* @__PURE__ */ jsx8("tr", { "data-cell-row": r, children: Array.from({ length: cols }, (_2, c) => {
+              const flat = r * cols + c;
+              const cell = cells[flat];
+              if (cell?.attrs.covered === true) return null;
+              const rowspan = spanAttr(cell?.attrs.rowspan);
+              const colspan = spanAttr(cell?.attrs.colspan);
+              const delta = cell?.delta ?? [];
+              const inRect = rect !== null && r >= rect.top && r <= rect.bottom && c >= rect.left && c <= rect.right;
+              return /* @__PURE__ */ jsx8(
+                "td",
+                {
+                  "data-cell-index": flat,
+                  "data-cell-row": r,
+                  "data-cell-col": c,
+                  "data-cell-rowspan": rowspan,
+                  "data-cell-colspan": colspan,
+                  rowSpan: rowspan > 1 ? rowspan : void 0,
+                  colSpan: colspan > 1 ? colspan : void 0,
+                  className: inRect ? "ed-cell ed-cell--selected" : "ed-cell",
+                  children: renderInline(delta, `t${index}-c${flat}`)
+                },
+                c
+              );
+            }) }, r);
+          }) })
+        ]
+      }
+    ),
+    isFirstFragment && /* @__PURE__ */ jsx8(TableResizeOverlay, { tableRef, blockIndex: index, cols })
+  ] });
+}
+function readColWidths(raw, cols) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (let i = 0; i < cols; i++) {
+    const v = raw[i];
+    out.push(typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null);
+  }
+  return out;
+}
+function spanAttr(v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 1) return 1;
+  return Math.trunc(v);
+}
+function clampPositive(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) return 1;
+  return Math.trunc(n);
+}
+
+// src/usePagination.ts
+import { useLayoutEffect as useLayoutEffect3, useRef as useRef7, useState as useState6 } from "react";
+var A4_PAGE = {
+  width: 794,
+  height: 1123,
+  marginTop: 96,
+  marginBottom: 96,
+  marginLeft: 96,
+  marginRight: 96
+};
+function contentHeight(g) {
+  return g.height - g.marginTop - g.marginBottom;
+}
+function contentWidth(g) {
+  return g.width - g.marginLeft - g.marginRight;
+}
+function defaultPageLayout(topLevelCount) {
+  return {
+    pages: [
+      {
+        slots: Array.from({ length: topLevelCount }, (_, i) => ({ topLevelIndex: i }))
+      }
+    ]
+  };
+}
+function usePageLayout(rootRef, geometry, topLevelCount, deps) {
+  const [phase, setPhase] = useState6("measure");
+  const [layout, setLayout] = useState6(() => defaultPageLayout(topLevelCount));
+  const lastDepsRef = useRef7([]);
+  const currentDeps = [...deps, topLevelCount, geometry];
+  if (!shallowArrayEqual(lastDepsRef.current, currentDeps)) {
+    lastDepsRef.current = currentDeps;
+    if (phase !== "measure") setPhase("measure");
+    const next = defaultPageLayout(topLevelCount);
+    if (!layoutsDeepEqual(layout, next)) setLayout(next);
+  }
+  useLayoutEffect3(() => {
+    if (phase !== "measure") return;
+    const root = rootRef.current;
+    if (!root) return;
+    if (!isUnfragmented(layout)) return;
+    const next = computeLayout(root, geometry, topLevelCount);
+    if (!layoutsDeepEqual(layout, next)) setLayout(next);
+    setPhase("stable");
+  }, [phase, layout, geometry, topLevelCount, rootRef]);
+  return layout;
+}
+function isUnfragmented(layout) {
+  return layout.pages.length === 1 && layout.pages[0].slots.every(
+    (s) => s.fragment === void 0 && s.tableFragment === void 0
+  );
+}
+function computeLayout(root, geometry, topLevelCount) {
+  const tops = collectTopLevelElements(root);
+  if (tops.length === 0) return defaultPageLayout(topLevelCount);
+  const limit = contentHeight(geometry);
+  const pages = [{ slots: [] }];
+  let currentPage = pages[0];
+  let used = 0;
+  const cap = Math.min(tops.length, topLevelCount);
+  for (let i = 0; i < cap; i++) {
+    const el = tops[i];
+    const h = elTotalHeight(el);
+    if (used + h <= limit) {
+      currentPage.slots.push({ topLevelIndex: i });
+      used += h;
+      continue;
+    }
+    if (isFragmentable(el)) {
+      const result = placeFragmentedBlock(el, i, pages, used, limit);
+      currentPage = pages[pages.length - 1];
+      used = result.lastUsed;
+      continue;
+    }
+    if (isTableTopLevel(el)) {
+      const result = placeFragmentedTable(el, i, pages, used, limit);
+      currentPage = pages[pages.length - 1];
+      used = result.lastUsed;
+      continue;
+    }
+    if (currentPage.slots.length === 0) {
+      currentPage.slots.push({ topLevelIndex: i });
+      pages.push({ slots: [] });
+      currentPage = pages[pages.length - 1];
+      used = 0;
+    } else {
+      pages.push({ slots: [] });
+      currentPage = pages[pages.length - 1];
+      currentPage.slots.push({ topLevelIndex: i });
+      used = h;
+    }
+  }
+  if (pages.length > 1 && pages[pages.length - 1].slots.length === 0) pages.pop();
+  return { pages };
+}
+function placeFragmentedBlock(el, topLevelIndex, pages, startUsed, limit) {
+  const totalChars = getBlockTextLength(el);
+  if (totalChars === 0) {
+    const h = elTotalHeight(el);
+    let currentPage2 = pages[pages.length - 1];
+    if (startUsed + h > limit && currentPage2.slots.length > 0) {
+      pages.push({ slots: [] });
+      currentPage2 = pages[pages.length - 1];
+      startUsed = 0;
+    }
+    currentPage2.slots.push({ topLevelIndex });
+    return { lastUsed: startUsed + h };
+  }
+  const lines = measureLines(el);
+  if (lines.length === 0) {
+    const h = elTotalHeight(el);
+    let currentPage2 = pages[pages.length - 1];
+    if (startUsed + h > limit && currentPage2.slots.length > 0) {
+      pages.push({ slots: [] });
+      currentPage2 = pages[pages.length - 1];
+      startUsed = 0;
+    }
+    currentPage2.slots.push({ topLevelIndex });
+    return { lastUsed: startUsed + h };
+  }
+  let lineIdx = 0;
+  let currentPage = pages[pages.length - 1];
+  let used = startUsed;
+  let fragIndex = 0;
+  while (lineIdx < lines.length) {
+    const available = Math.max(0, limit - used);
+    if (available <= 0) {
+      pages.push({ slots: [] });
+      currentPage = pages[pages.length - 1];
+      used = 0;
+      continue;
+    }
+    const startTop = lines[lineIdx].top;
+    let bestK = -1;
+    for (let k = lineIdx; k < lines.length; k++) {
+      const h = lines[k].bottom - startTop;
+      if (h <= available) bestK = k;
+      else break;
+    }
+    if (bestK < 0) {
+      if (currentPage.slots.length === 0) {
+        bestK = lineIdx;
+      } else {
+        pages.push({ slots: [] });
+        currentPage = pages[pages.length - 1];
+        used = 0;
+        continue;
+      }
+    }
+    const fragStart = lines[lineIdx].start;
+    const fragEnd = bestK + 1 < lines.length ? lines[bestK + 1].start : totalChars;
+    const fragHeight = lines[bestK].bottom - startTop;
+    currentPage.slots.push({
+      topLevelIndex,
+      fragment: { index: fragIndex, start: fragStart, end: fragEnd }
+    });
+    used += fragHeight;
+    fragIndex++;
+    lineIdx = bestK + 1;
+    if (lineIdx < lines.length) {
+      pages.push({ slots: [] });
+      currentPage = pages[pages.length - 1];
+      used = 0;
+    }
+  }
+  return { lastUsed: used };
+}
+var lineMetricsCache = /* @__PURE__ */ new Map();
+var LINE_METRICS_CACHE_LIMIT = 200;
+function measureLines(el) {
+  const text = el.textContent ?? "";
+  const cacheKey = `${el.offsetWidth}|${text}`;
+  const cached = lineMetricsCache.get(cacheKey);
+  if (cached) {
+    lineMetricsCache.delete(cacheKey);
+    lineMetricsCache.set(cacheKey, cached);
+    return cached;
+  }
+  const fresh = measureLinesUncached(el);
+  lineMetricsCache.set(cacheKey, fresh);
+  if (lineMetricsCache.size > LINE_METRICS_CACHE_LIMIT) {
+    const oldest = lineMetricsCache.keys().next().value;
+    if (oldest !== void 0) lineMetricsCache.delete(oldest);
+  }
+  return fresh;
+}
+function measureLinesUncached(el) {
+  const range = document.createRange();
+  const lines = [];
+  const walker = document.createTreeWalker(
+    el,
+    NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT,
+    blockBoundaryFilter(el)
+  );
+  let n;
+  let charOffset = 0;
+  while (n = walker.nextNode()) {
+    if (n.nodeType === Node.TEXT_NODE) {
+      const text = n.textContent ?? "";
+      for (let i = 0; i < text.length; i++) {
+        try {
+          range.setStart(n, i);
+          range.setEnd(n, i + 1);
+        } catch {
+          continue;
+        }
+        const rect = range.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) continue;
+        const last = lines[lines.length - 1];
+        if (!last || rect.top >= last.bottom) {
+          lines.push({ start: charOffset + i, top: rect.top, bottom: rect.bottom });
+        } else {
+          last.top = Math.min(last.top, rect.top);
+          last.bottom = Math.max(last.bottom, rect.bottom);
+        }
+      }
+      charOffset += text.length;
+      continue;
+    }
+    if (n.nodeType === Node.ELEMENT_NODE && n.dataset.embed === "image") {
+      const rect = n.getBoundingClientRect();
+      if (rect.height > 0) {
+        const last = lines[lines.length - 1];
+        if (!last || rect.top >= last.bottom) {
+          lines.push({ start: charOffset, top: rect.top, bottom: rect.bottom });
+        } else {
+          last.top = Math.min(last.top, rect.top);
+          last.bottom = Math.max(last.bottom, rect.bottom);
+        }
+      }
+      charOffset += 1;
+    }
+  }
+  return lines;
+}
+function elTotalHeight(el) {
+  const cs = getComputedStyle(el);
+  const m = parseFloat(cs.marginTop || "0") + parseFloat(cs.marginBottom || "0");
+  return el.offsetHeight + m;
+}
+function isFragmentable(el) {
+  const type = el.getAttribute("data-block-type");
+  if (type === "paragraph") return true;
+  if (type === "heading") return true;
+  if (type === "blockquote") return true;
+  return false;
+}
+function isTableTopLevel(el) {
+  return el.querySelector(':scope > table[data-block-type="table"]') !== null;
+}
+function placeFragmentedTable(el, topLevelIndex, pages, startUsed, limit) {
+  const table = el.querySelector(':scope > table[data-block-type="table"]');
+  const tbody = table?.querySelector(":scope > tbody");
+  const trs = tbody ? Array.from(tbody.children) : [];
+  if (trs.length === 0) {
+    const h = elTotalHeight(el);
+    let currentPage2 = pages[pages.length - 1];
+    if (startUsed + h > limit && currentPage2.slots.length > 0) {
+      pages.push({ slots: [] });
+      currentPage2 = pages[pages.length - 1];
+      startUsed = 0;
+    }
+    currentPage2.slots.push({ topLevelIndex });
+    return { lastUsed: startUsed + h };
+  }
+  const rowHeights = trs.map((tr) => tr.getBoundingClientRect().height);
+  const invalid = /* @__PURE__ */ new Set();
+  for (let r = 0; r < trs.length; r++) {
+    const tds = Array.from(trs[r].children);
+    for (const td of tds) {
+      const rs = td.rowSpan || 1;
+      if (rs > 1) {
+        for (let k = r; k <= r + rs - 2 && k < trs.length - 1; k++) {
+          invalid.add(k);
+        }
+      }
+    }
+  }
+  const wrapHeight = elTotalHeight(el);
+  const tableHeight = table ? table.getBoundingClientRect().height : 0;
+  const chrome = Math.max(0, wrapHeight - tableHeight);
+  let rowIdx = 0;
+  let used = startUsed;
+  let fragIndex = 0;
+  let currentPage = pages[pages.length - 1];
+  while (rowIdx < trs.length) {
+    const overhead = fragIndex === 0 ? chrome : 0;
+    const available = Math.max(0, limit - used - overhead);
+    if (available <= 0) {
+      pages.push({ slots: [] });
+      currentPage = pages[pages.length - 1];
+      used = 0;
+      continue;
+    }
+    let bestEnd = -1;
+    let accH = 0;
+    for (let k = rowIdx; k < trs.length; k++) {
+      accH += rowHeights[k];
+      if (accH > available) break;
+      if (k === trs.length - 1 || !invalid.has(k)) bestEnd = k + 1;
+    }
+    if (bestEnd < 0) {
+      if (currentPage.slots.length === 0) {
+        let k = rowIdx;
+        while (k < trs.length - 1 && invalid.has(k)) k++;
+        bestEnd = k + 1;
+      } else {
+        pages.push({ slots: [] });
+        currentPage = pages[pages.length - 1];
+        used = 0;
+        continue;
+      }
+    }
+    let fragHeight = 0;
+    for (let k = rowIdx; k < bestEnd; k++) fragHeight += rowHeights[k];
+    if (fragIndex === 0) fragHeight += chrome;
+    currentPage.slots.push({
+      topLevelIndex,
+      tableFragment: { index: fragIndex, rowStart: rowIdx, rowEnd: bestEnd }
+    });
+    used += fragHeight;
+    fragIndex++;
+    rowIdx = bestEnd;
+    if (rowIdx < trs.length) {
+      pages.push({ slots: [] });
+      currentPage = pages[pages.length - 1];
+      used = 0;
+    }
+  }
+  return { lastUsed: used };
+}
+function collectTopLevelElements(root) {
+  const pageContents = root.querySelectorAll(":scope > .ed-page > .ed-page-content");
+  if (pageContents.length > 0) {
+    const out = [];
+    pageContents.forEach((pc) => {
+      Array.from(pc.children).forEach((c) => out.push(c));
+    });
+    return out;
+  }
+  return Array.from(root.children);
+}
+function getBlockTextLength(el) {
+  const walker = document.createTreeWalker(
+    el,
+    NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT,
+    blockBoundaryFilter(el)
+  );
+  let n;
+  let sum = 0;
+  while (n = walker.nextNode()) {
+    if (n.nodeType === Node.TEXT_NODE) {
+      sum += (n.textContent ?? "").length;
+    } else if (n.nodeType === Node.ELEMENT_NODE && n.dataset.embed === "image") {
+      sum += 1;
+    }
+  }
+  return sum;
+}
+function blockBoundaryFilter(blockEl) {
+  return {
+    acceptNode(n) {
+      let p = n.parentNode;
+      while (p && p !== blockEl) {
+        if (p.nodeType === Node.ELEMENT_NODE) {
+          const e = p;
+          if (e.dataset.blockIndex != null) return NodeFilter.FILTER_REJECT;
+        }
+        p = p.parentNode;
+      }
+      return NodeFilter.FILTER_ACCEPT;
+    }
+  };
+}
+function shallowArrayEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function layoutsDeepEqual(a, b) {
+  if (a.pages.length !== b.pages.length) return false;
+  for (let i = 0; i < a.pages.length; i++) {
+    const sA = a.pages[i].slots;
+    const sB = b.pages[i].slots;
+    if (sA.length !== sB.length) return false;
+    for (let j = 0; j < sA.length; j++) {
+      if (sA[j].topLevelIndex !== sB[j].topLevelIndex) return false;
+      const fA = sA[j].fragment;
+      const fB = sB[j].fragment;
+      if (fA || fB) {
+        if (!fA || !fB) return false;
+        if (fA.index !== fB.index || fA.start !== fB.start || fA.end !== fB.end) return false;
+      }
+      const tA = sA[j].tableFragment;
+      const tB = sB[j].tableFragment;
+      if (tA || tB) {
+        if (!tA || !tB) return false;
+        if (tA.index !== tB.index || tA.rowStart !== tB.rowStart || tA.rowEnd !== tB.rowEnd) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+// src/useEditor.ts
+import { useCallback as useCallback4, useEffect as useEffect6, useMemo as useMemo3, useRef as useRef9, useState as useState7 } from "react";
+
+// src/usePageSettings.ts
+import { useCallback as useCallback3, useRef as useRef8, useSyncExternalStore } from "react";
+function usePageSettings(doc) {
+  const cacheRef = useRef8(null);
+  const subscribe = useCallback3(
+    (notify) => doc.observePageSettings(notify),
+    [doc]
+  );
+  const getSnapshot = useCallback3(() => {
+    const next = doc.getPageSettings();
+    const prev = cacheRef.current;
+    if (prev && shallowEqual(prev, next)) return prev;
+    cacheRef.current = next;
+    return next;
+  }, [doc]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+function shallowEqual(a, b) {
+  return a.width === b.width && a.height === b.height && a.marginTop === b.marginTop && a.marginBottom === b.marginBottom && a.marginLeft === b.marginLeft && a.marginRight === b.marginRight && a.preset === b.preset;
+}
+
+// src/useEditor.ts
+import {
+  EditorDocument,
+  EditorHistory,
+  collapsedSelection,
+  dedentList as cmdDedentList,
+  deleteTable as cmdDeleteTable,
+  deleteTableColumn as cmdDeleteColumn,
+  deleteTableRow as cmdDeleteRow,
+  insertImage as cmdInsertImage,
+  mergeDown as cmdMergeDown,
+  mergeRight as cmdMergeRight,
+  mergeSelection as cmdMergeSelection,
+  setColumnWidth as cmdSetColumnWidth,
+  setImageAttrs as cmdSetImageAttrs,
+  splitCell as cmdSplitCell,
+  tableRectSelection as tableRectSelection2,
+  getMarksInRange,
+  indentList as cmdIndentList,
+  insertTable as cmdInsertTable,
+  insertTableColumn as cmdInsertColumn,
+  insertTableRow as cmdInsertRow,
+  isImageEmbed as isImageEmbed2,
+  isMarkUniformInRange,
+  moveToNextCell as cmdMoveNextCell,
+  moveToPrevCell as cmdMovePrevCell,
+  orderedRange,
+  removeMark as cmdRemoveMark,
+  setBlockAttr as cmdSetBlockAttr,
+  setBlockType as cmdSetBlockType,
+  setMark as cmdSetMark,
+  splitListItem as cmdSplitListItem,
+  tableLocationOf,
+  toggleList as cmdToggleList,
+  toggleMark as cmdToggleMark
+} from "@sofereditor/core";
+var MAX_INSERT_WIDTH = 600;
+function useEditor(opts = {}) {
+  const doc = useMemo3(() => opts.document ?? new EditorDocument(), [opts.document]);
+  const history = useMemo3(() => new EditorHistory(doc), [doc]);
+  const [snapshot, setSnapshot] = useState7(() => doc.toJSON());
+  const [selection, setSelectionState] = useState7(
+    () => collapsedSelection({ blockIndex: 0, offset: 0 })
+  );
+  const selectionRef = useRef9(selection);
+  selectionRef.current = selection;
+  const pendingMarksRef = useRef9({});
+  const [pendingMarks, setPendingMarksState] = useState7({});
+  const setPendingMarks = useCallback4((next) => {
+    pendingMarksRef.current = next;
+    setPendingMarksState(next);
+  }, []);
+  useEffect6(() => {
+    let scheduled = false;
+    let cancelled = false;
+    let frame = 0;
+    const flush = () => {
+      scheduled = false;
+      if (cancelled) return;
+      setSnapshot(doc.toJSON());
+    };
+    const schedule = () => {
+      if (scheduled) return;
+      scheduled = true;
+      if (typeof requestAnimationFrame === "function") {
+        frame = requestAnimationFrame(flush);
+      } else {
+        queueMicrotask(flush);
+      }
+    };
+    doc.ydoc.on("afterTransaction", schedule);
+    return () => {
+      cancelled = true;
+      if (scheduled && typeof requestAnimationFrame === "function" && typeof cancelAnimationFrame === "function") {
+        cancelAnimationFrame(frame);
+      }
+      doc.ydoc.off("afterTransaction", schedule);
+    };
+  }, [doc]);
+  const getSelection = useCallback4(() => selectionRef.current, []);
+  const setSelection = useCallback4(
+    (sel) => {
+      const prev = selectionRef.current;
+      selectionRef.current = sel;
+      setSelectionState(sel);
+      if (Object.keys(pendingMarksRef.current).length > 0 && (prev.focus.blockIndex !== sel.focus.blockIndex || prev.focus.offset !== sel.focus.offset)) {
+        const advancedByOne = prev.focus.blockIndex === sel.focus.blockIndex && sel.focus.offset === prev.focus.offset + 1;
+        if (!advancedByOne) {
+          pendingMarksRef.current = {};
+          setPendingMarksState({});
+        }
+      }
+    },
+    []
+  );
+  const ctxRef = useRef9({ doc, getSelection, setSelection });
+  ctxRef.current = { doc, getSelection, setSelection };
+  const consumePendingMarks = useCallback4(() => {
+    const current = pendingMarksRef.current;
+    if (Object.keys(current).length === 0) return void 0;
+    pendingMarksRef.current = {};
+    setPendingMarksState({});
+    return current;
+  }, []);
+  const isMarkActive = useCallback4(
+    (name, value) => {
+      const sel = selectionRef.current;
+      const { start, end } = orderedRange(sel);
+      if (start.blockIndex === end.blockIndex && start.offset === end.offset) {
+        const pending = pendingMarksRef.current[name];
+        if (pending !== void 0) {
+          if (pending === null) return false;
+          return value === void 0 ? true : sameValue(pending, value);
+        }
+        const yText2 = doc.getBlockText(start.blockIndex);
+        if (!yText2 || start.offset === 0) return false;
+        return isMarkUniformInRange(yText2, start.offset - 1, start.offset, name, value);
+      }
+      if (start.blockIndex !== end.blockIndex) {
+        for (let i = start.blockIndex; i <= end.blockIndex; i++) {
+          const yText2 = doc.getBlockText(i);
+          if (!yText2) return false;
+          const s = i === start.blockIndex ? start.offset : 0;
+          const e = i === end.blockIndex ? end.offset : yText2.length;
+          if (s >= e) continue;
+          if (!isMarkUniformInRange(yText2, s, e, name, value)) return false;
+        }
+        return true;
+      }
+      const yText = doc.getBlockText(start.blockIndex);
+      if (!yText) return false;
+      return isMarkUniformInRange(yText, start.offset, end.offset, name, value);
+    },
+    [doc]
+  );
+  const getActiveMarks = useCallback4(() => {
+    const sel = selectionRef.current;
+    const { start, end } = orderedRange(sel);
+    if (start.blockIndex !== end.blockIndex) {
+      return {};
+    }
+    const yText = doc.getBlockText(start.blockIndex);
+    if (!yText) return {};
+    if (start.offset === end.offset) {
+      if (start.offset === 0) return {};
+      return getMarksInRange(yText, start.offset - 1, start.offset);
+    }
+    return getMarksInRange(yText, start.offset, end.offset);
+  }, [doc]);
+  const toggleMark = useCallback4(
+    (name, value) => {
+      const sel = selectionRef.current;
+      const { start, end } = orderedRange(sel);
+      const isCollapsed = start.blockIndex === end.blockIndex && start.offset === end.offset;
+      if (isCollapsed) {
+        const next = { ...pendingMarksRef.current };
+        const currentlyActive = isMarkActive(name, value);
+        if (currentlyActive) {
+          next[name] = null;
+        } else {
+          next[name] = value ?? (booleanMarks.has(name) ? true : null);
+        }
+        setPendingMarks(next);
+        return;
+      }
+      cmdToggleMark(ctxRef.current, name, value);
+    },
+    [isMarkActive, setPendingMarks]
+  );
+  const setMark = useCallback4(
+    (name, value) => {
+      const sel = selectionRef.current;
+      const { start, end } = orderedRange(sel);
+      const isCollapsed = start.blockIndex === end.blockIndex && start.offset === end.offset;
+      if (isCollapsed) {
+        setPendingMarks({ ...pendingMarksRef.current, [name]: value });
+        return;
+      }
+      cmdSetMark(ctxRef.current, name, value);
+    },
+    [setPendingMarks]
+  );
+  const removeMark = useCallback4(
+    (name) => {
+      const sel = selectionRef.current;
+      const { start, end } = orderedRange(sel);
+      const isCollapsed = start.blockIndex === end.blockIndex && start.offset === end.offset;
+      if (isCollapsed) {
+        setPendingMarks({ ...pendingMarksRef.current, [name]: null });
+        return;
+      }
+      cmdRemoveMark(ctxRef.current, name);
+    },
+    [setPendingMarks]
+  );
+  const getBlockType = useCallback4(() => {
+    const sel = selectionRef.current;
+    const { start, end } = orderedRange(sel);
+    const first = doc.getBlockType(start.blockIndex);
+    if (first === void 0) return "paragraph";
+    for (let i = start.blockIndex + 1; i <= end.blockIndex; i++) {
+      if (doc.getBlockType(i) !== first) return "mixed";
+    }
+    return first;
+  }, [doc]);
+  const getBlockAttr = useCallback4(
+    (key) => {
+      const sel = selectionRef.current;
+      const { start, end } = orderedRange(sel);
+      const first = doc.getBlockAttrs(start.blockIndex)[key];
+      for (let i = start.blockIndex + 1; i <= end.blockIndex; i++) {
+        const next = doc.getBlockAttrs(i)[key];
+        if (next !== first) return "mixed";
+      }
+      return first;
+    },
+    [doc]
+  );
+  const setBlockType = useCallback4((type, attrs) => {
+    cmdSetBlockType(ctxRef.current, type, attrs);
+  }, []);
+  const setBlockAttr = useCallback4(
+    (key, value) => {
+      cmdSetBlockAttr(ctxRef.current, key, value);
+    },
+    []
+  );
+  const isListActive = useCallback4(
+    (kind) => {
+      const sel = selectionRef.current;
+      const { start, end } = orderedRange(sel);
+      for (let i = start.blockIndex; i <= end.blockIndex; i++) {
+        if (doc.getBlockType(i) !== "listItem") return false;
+        if (doc.getBlockAttrs(i).listKind !== kind) return false;
+      }
+      return true;
+    },
+    [doc]
+  );
+  const toggleList = useCallback4((kind) => {
+    cmdToggleList(ctxRef.current, kind);
+  }, []);
+  const indentList = useCallback4(() => {
+    cmdIndentList(ctxRef.current);
+  }, []);
+  const dedentList = useCallback4(() => {
+    cmdDedentList(ctxRef.current);
+  }, []);
+  const splitListItem = useCallback4(() => {
+    return cmdSplitListItem(ctxRef.current);
+  }, []);
+  const isInTable = useCallback4(() => {
+    return selectionRef.current.focus.cellIndex != null;
+  }, []);
+  const getTableLocation = useCallback4(() => {
+    return tableLocationOf(doc, selectionRef.current.focus);
+  }, [doc]);
+  const insertTable = useCallback4((rows, cols) => {
+    cmdInsertTable(ctxRef.current, rows, cols);
+  }, []);
+  const deleteTable = useCallback4((blockIndex) => {
+    const idx = blockIndex ?? selectionRef.current.focus.blockIndex;
+    cmdDeleteTable(ctxRef.current, idx);
+  }, []);
+  const insertRowAbove = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return;
+    cmdInsertRow(ctxRef.current, loc.blockIndex, loc.row, "before");
+  }, [doc]);
+  const insertRowBelow = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return;
+    cmdInsertRow(ctxRef.current, loc.blockIndex, loc.row, "after");
+  }, [doc]);
+  const deleteCurrentRow = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return;
+    cmdDeleteRow(ctxRef.current, loc.blockIndex, loc.row);
+  }, [doc]);
+  const insertColumnLeft = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return;
+    cmdInsertColumn(ctxRef.current, loc.blockIndex, loc.col, "before");
+  }, [doc]);
+  const insertColumnRight = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return;
+    cmdInsertColumn(ctxRef.current, loc.blockIndex, loc.col, "after");
+  }, [doc]);
+  const deleteCurrentColumn = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return;
+    cmdDeleteColumn(ctxRef.current, loc.blockIndex, loc.col);
+  }, [doc]);
+  const moveToNextCell = useCallback4(() => {
+    cmdMoveNextCell(ctxRef.current);
+  }, []);
+  const moveToPrevCell = useCallback4(() => {
+    cmdMovePrevCell(ctxRef.current);
+  }, []);
+  const mergeRight = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return false;
+    return cmdMergeRight(ctxRef.current, loc.blockIndex, loc.row, loc.col);
+  }, [doc]);
+  const mergeDown = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return false;
+    return cmdMergeDown(ctxRef.current, loc.blockIndex, loc.row, loc.col);
+  }, [doc]);
+  const splitCell = useCallback4(() => {
+    const loc = tableLocationOf(doc, selectionRef.current.focus);
+    if (!loc) return false;
+    return cmdSplitCell(ctxRef.current, loc.blockIndex, loc.row, loc.col);
+  }, [doc]);
+  const setColumnWidth = useCallback4(
+    (blockIndex, col, widthPx) => {
+      cmdSetColumnWidth(ctxRef.current, blockIndex, col, widthPx);
+    },
+    []
+  );
+  const getTableRect = useCallback4(
+    () => tableRectSelection2(doc, selectionRef.current),
+    [doc]
+  );
+  const hasTableRectSelection = useCallback4(() => {
+    return tableRectSelection2(doc, selectionRef.current) !== null;
+  }, [doc]);
+  const mergeSelection = useCallback4(() => {
+    return cmdMergeSelection(ctxRef.current);
+  }, []);
+  const insertImage = useCallback4((embed) => {
+    cmdInsertImage(ctxRef.current, embed);
+  }, []);
+  const setImageAttrs = useCallback4(
+    (blockIndex, offset, partial, cellIndex, newOffset) => {
+      cmdSetImageAttrs(ctxRef.current, blockIndex, offset, partial, cellIndex, newOffset);
+    },
+    []
+  );
+  const uploadImageRef = useRef9(opts.uploadImage);
+  uploadImageRef.current = opts.uploadImage;
+  const insertImageFromFile = useCallback4(async (file) => {
+    if (!file.type.startsWith("image/")) return;
+    const dataUrl = await readAsDataURL(file);
+    const dims = await readImageDimensions(dataUrl);
+    let w = dims.width;
+    let h = dims.height;
+    if (w > MAX_INSERT_WIDTH) {
+      h = Math.round(h * MAX_INSERT_WIDTH / w);
+      w = MAX_INSERT_WIDTH;
+    }
+    const upload = uploadImageRef.current;
+    const src = upload ? await upload(file) : dataUrl;
+    cmdInsertImage(ctxRef.current, { type: "image", src, width: w, height: h });
+  }, []);
+  const getSelectedEmbed = useCallback4(() => {
+    const sel = selectionRef.current;
+    if (sel.anchor.blockIndex !== sel.focus.blockIndex) return null;
+    if ((sel.anchor.cellIndex ?? -1) !== (sel.focus.cellIndex ?? -1)) return null;
+    const a = sel.anchor.offset;
+    const b = sel.focus.offset;
+    if (Math.abs(a - b) !== 1) return null;
+    const start = Math.min(a, b);
+    const yText = doc.textAt(sel.anchor.blockIndex, sel.anchor.cellIndex);
+    if (!yText) return null;
+    const delta = yText.toDelta();
+    let cursor = 0;
+    for (const op of delta) {
+      if (typeof op.insert === "string") {
+        cursor += op.insert.length;
+        continue;
+      }
+      if (cursor === start && isImageEmbed2(op.insert)) {
+        return {
+          blockIndex: sel.anchor.blockIndex,
+          cellIndex: sel.anchor.cellIndex,
+          offset: start,
+          embed: op.insert
+        };
+      }
+      cursor += 1;
+    }
+    return null;
+  }, [doc]);
+  const [linkRequest, setLinkRequest] = useState7(null);
+  const requestLink = useCallback4((initialHref = "") => {
+    return new Promise((resolve) => {
+      setLinkRequest({ initialHref, resolve });
+    });
+  }, []);
+  const resolveLinkRequest = useCallback4((href) => {
+    setLinkRequest((prev) => {
+      if (prev) prev.resolve(href);
+      return null;
+    });
+  }, []);
+  const pageSettings = usePageSettings(doc);
+  const setPageSettings = useCallback4(
+    (partial) => {
+      doc.setPageSettings(partial);
+    },
+    [doc]
+  );
+  const [pageConfigRequest, setPageConfigRequest] = useState7(null);
+  const requestPageConfig = useCallback4(() => {
+    return new Promise((resolve) => {
+      setPageConfigRequest({ initial: doc.getPageSettings(), resolve });
+    });
+  }, [doc]);
+  const resolvePageConfigRequest = useCallback4((applied) => {
+    setPageConfigRequest((prev) => {
+      if (prev) prev.resolve(applied);
+      return null;
+    });
+  }, []);
+  const [imageCaptionRequest, setImageCaptionRequest] = useState7(null);
+  const requestImageCaption = useCallback4(
+    (initialCaption = "", initialAlign = "center") => {
+      return new Promise((resolve) => {
+        setImageCaptionRequest({ initialCaption, initialAlign, resolve });
+      });
+    },
+    []
+  );
+  const resolveImageCaptionRequest = useCallback4((result) => {
+    setImageCaptionRequest((prev) => {
+      if (prev) prev.resolve(result);
+      return null;
+    });
+  }, []);
+  return {
+    doc,
+    history,
+    snapshot,
+    selection,
+    setSelection,
+    getSelection,
+    isMarkActive,
+    getActiveMarks,
+    toggleMark,
+    setMark,
+    removeMark,
+    pendingMarks,
+    consumePendingMarks,
+    getBlockType,
+    getBlockAttr,
+    setBlockType,
+    setBlockAttr,
+    isListActive,
+    toggleList,
+    indentList,
+    dedentList,
+    splitListItem,
+    linkRequest,
+    requestLink,
+    resolveLinkRequest,
+    isInTable,
+    getTableLocation,
+    insertTable,
+    deleteTable,
+    insertRowAbove,
+    insertRowBelow,
+    deleteCurrentRow,
+    insertColumnLeft,
+    insertColumnRight,
+    deleteCurrentColumn,
+    moveToNextCell,
+    moveToPrevCell,
+    mergeRight,
+    mergeDown,
+    splitCell,
+    setColumnWidth,
+    getTableRect,
+    hasTableRectSelection,
+    mergeSelection,
+    insertImage,
+    setImageAttrs,
+    insertImageFromFile,
+    getSelectedEmbed,
+    pageSettings,
+    setPageSettings,
+    pageConfigRequest,
+    requestPageConfig,
+    resolvePageConfigRequest,
+    imageCaptionRequest,
+    requestImageCaption,
+    resolveImageCaptionRequest
+  };
+}
+function readAsDataURL(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error("FileReader error"));
+    reader.onload = () => resolve(reader.result);
+    reader.readAsDataURL(file);
+  });
+}
+function readImageDimensions(src) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onerror = () => reject(new Error("image load failed"));
+    img.onload = () => resolve({ width: img.naturalWidth, height: img.naturalHeight });
+    img.src = src;
+  });
+}
+var booleanMarks = /* @__PURE__ */ new Set(["bold", "italic", "underline", "strike"]);
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (typeof a === "object" && a && b && typeof b === "object") {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every((k) => a[k] === b[k]);
+  }
+  return false;
+}
+
+// src/Editor.tsx
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+var defaultFooter = ({ pageNumber, pageCount }) => `${pageNumber} / ${pageCount}`;
+function Editor({
+  editor: providedEditor,
+  className,
+  pageGeometry,
+  renderPageHeader,
+  renderPageFooter = defaultFooter
+}) {
+  const internal = useEditor();
+  const editor = providedEditor ?? internal;
+  const { doc, history, snapshot, getSelection, setSelection } = editor;
+  const rootRef = useRef10(null);
+  const isComposingRef = useRef10(false);
+  const suppressSelectionSyncRef = useRef10(false);
+  const ctxRef = useRef10({ doc, getSelection, setSelection });
+  ctxRef.current = { doc, getSelection, setSelection };
+  const historyRef = useRef10(history);
+  historyRef.current = history;
+  const editorRef = useRef10(editor);
+  editorRef.current = editor;
+  useLayoutEffect4(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    if (isComposingRef.current) return;
+    if (document.activeElement !== root) return;
+    const current = readDomSelection(root);
+    if (current && selectionsEqual(current, editor.selection)) return;
+    suppressSelectionSyncRef.current = true;
+    applyDomSelection(root, editor.selection);
+    queueMicrotask(() => {
+      suppressSelectionSyncRef.current = false;
+    });
+  });
+  useEffect7(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const handler = () => {
+      if (suppressSelectionSyncRef.current) return;
+      if (isComposingRef.current) return;
+      if (document.activeElement !== root) return;
+      const modelSel = readDomSelection(root);
+      if (modelSel) setSelection(modelSel);
+    };
+    document.addEventListener("selectionchange", handler);
+    return () => document.removeEventListener("selectionchange", handler);
+  }, [setSelection]);
+  useEffect7(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    let drag = null;
+    function cellFromTarget(target) {
+      if (!(target instanceof Node)) return null;
+      let n = target;
+      let cellEl = null;
+      let tableEl = null;
+      while (n && n !== root) {
+        if (n.nodeType === Node.ELEMENT_NODE) {
+          const e = n;
+          if (!cellEl && e.dataset.cellIndex != null) cellEl = e;
+          if (e.tagName === "TABLE" && e.dataset.blockIndex != null) {
+            tableEl = e;
+            break;
+          }
+        }
+        n = n.parentNode;
+      }
+      if (!cellEl || !tableEl) return null;
+      const cellIndex = Number.parseInt(cellEl.dataset.cellIndex, 10);
+      const blockIndex = Number.parseInt(tableEl.dataset.blockIndex, 10);
+      return { blockIndex, cellIndex, tableEl };
+    }
+    const onPointerDown = (e) => {
+      if (e.button !== 0) return;
+      const hit = cellFromTarget(e.target);
+      if (!hit) {
+        drag = null;
+        return;
+      }
+      drag = {
+        blockIndex: hit.blockIndex,
+        anchorCellIndex: hit.cellIndex,
+        anchorTableEl: hit.tableEl,
+        rectActive: false
+      };
+    };
+    const onPointerMove = (e) => {
+      if (!drag) return;
+      if ((e.buttons & 1) === 0) {
+        drag = null;
+        return;
+      }
+      const hit = cellFromTarget(e.target);
+      if (!hit) return;
+      if (hit.blockIndex !== drag.blockIndex) return;
+      if (hit.cellIndex === drag.anchorCellIndex && !drag.rectActive) return;
+      if (!drag.rectActive) {
+        drag.rectActive = true;
+        window.getSelection()?.removeAllRanges();
+      }
+      e.preventDefault();
+      ctxRef.current.setSelection({
+        anchor: { blockIndex: drag.blockIndex, cellIndex: drag.anchorCellIndex, offset: 0 },
+        focus: { blockIndex: drag.blockIndex, cellIndex: hit.cellIndex, offset: 0 }
+      });
+    };
+    const onPointerUp = () => {
+      drag = null;
+    };
+    root.addEventListener("pointerdown", onPointerDown);
+    document.addEventListener("pointermove", onPointerMove);
+    document.addEventListener("pointerup", onPointerUp);
+    return () => {
+      root.removeEventListener("pointerdown", onPointerDown);
+      document.removeEventListener("pointermove", onPointerMove);
+      document.removeEventListener("pointerup", onPointerUp);
+    };
+  }, []);
+  useEffect7(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const onDragOver = (e) => {
+      if (!e.dataTransfer) return;
+      const hasFiles = Array.from(e.dataTransfer.items ?? []).some(
+        (i) => i.kind === "file"
+      );
+      if (!hasFiles) return;
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "copy";
+    };
+    const onDrop = (e) => {
+      if (!e.dataTransfer) return;
+      const images = Array.from(e.dataTransfer.files).filter(
+        (f) => f.type.startsWith("image/")
+      );
+      if (images.length === 0) return;
+      e.preventDefault();
+      const range = caretRangeFromPoint(e.clientX, e.clientY);
+      if (range) {
+        const dom = window.getSelection();
+        dom?.removeAllRanges();
+        dom?.addRange(range);
+        const sel = readDomSelection(root);
+        if (sel) ctxRef.current.setSelection(sel);
+      }
+      void (async () => {
+        for (const f of images) await editorRef.current.insertImageFromFile(f);
+      })();
+    };
+    root.addEventListener("dragover", onDragOver);
+    root.addEventListener("drop", onDrop);
+    return () => {
+      root.removeEventListener("dragover", onDragOver);
+      root.removeEventListener("drop", onDrop);
+    };
+  }, []);
+  useEffect7(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const onPointerDown = (e) => {
+      if (e.button !== 0) return;
+      const target = e.target;
+      if (!(target instanceof Element)) return;
+      const img = target.closest('img[data-embed="image"]');
+      if (!img) return;
+      const blockEl = img.closest("[data-block-index]");
+      if (!blockEl) return;
+      const blockIndex = Number.parseInt(blockEl.dataset.blockIndex, 10);
+      const offsetAttr = img.dataset.embedOffset;
+      if (offsetAttr == null) return;
+      const localOffset = Number.parseInt(offsetAttr, 10);
+      const fragmentStart = Number.parseInt(blockEl.dataset.fragmentStart ?? "0", 10) || 0;
+      const cellEl = img.closest("[data-cell-index]");
+      const cellIndex = cellEl ? Number.parseInt(cellEl.dataset.cellIndex, 10) : void 0;
+      const offset = fragmentStart + localOffset;
+      e.preventDefault();
+      ctxRef.current.setSelection({
+        anchor: { blockIndex, cellIndex, offset },
+        focus: { blockIndex, cellIndex, offset: offset + 1 }
+      });
+    };
+    root.addEventListener("pointerdown", onPointerDown);
+    return () => root.removeEventListener("pointerdown", onPointerDown);
+  }, []);
+  useEffect7(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const handler = (e) => {
+      const ctx = ctxRef.current;
+      const hist = historyRef.current;
+      const ed = editorRef.current;
+      const type = e.inputType;
+      if (isComposingRef.current && type === "insertCompositionText") return;
+      switch (type) {
+        case "insertText": {
+          const data = e.data ?? "";
+          if (data.length > 0) {
+            e.preventDefault();
+            insertText(ctx, data, ed.consumePendingMarks());
+          }
+          return;
+        }
+        case "insertParagraph":
+        case "insertLineBreak": {
+          e.preventDefault();
+          const selectedEmbed2 = ed.getSelectedEmbed();
+          if (selectedEmbed2) {
+            const off = selectedEmbed2.offset + 1;
+            ctx.setSelection({
+              anchor: {
+                blockIndex: selectedEmbed2.blockIndex,
+                cellIndex: selectedEmbed2.cellIndex,
+                offset: off
+              },
+              focus: {
+                blockIndex: selectedEmbed2.blockIndex,
+                cellIndex: selectedEmbed2.cellIndex,
+                offset: off
+              }
+            });
+          }
+          if (ed.splitListItem()) return;
+          insertParagraph(ctx);
+          return;
+        }
+        case "insertReplacementText": {
+          const text = e.data ?? e.dataTransfer?.getData("text/plain") ?? "";
+          if (text.length > 0) {
+            e.preventDefault();
+            insertText(ctx, text, ed.consumePendingMarks());
+          }
+          return;
+        }
+        case "insertFromPaste": {
+          e.preventDefault();
+          const images = Array.from(e.dataTransfer?.files ?? []).filter(
+            (f) => f.type.startsWith("image/")
+          );
+          if (images.length > 0) {
+            void (async () => {
+              for (const f of images) await editorRef.current.insertImageFromFile(f);
+            })();
+            return;
+          }
+          const text = e.dataTransfer?.getData("text/plain") ?? "";
+          if (text.length === 0) return;
+          const lines = text.split(/\r\n|\r|\n/);
+          lines.forEach((line, i) => {
+            if (i > 0) insertParagraph(ctx);
+            if (line.length > 0) insertText(ctx, line);
+          });
+          return;
+        }
+        case "deleteContentBackward":
+        case "deleteWordBackward":
+        case "deleteSoftLineBackward":
+        case "deleteHardLineBackward": {
+          e.preventDefault();
+          deleteBackward(ctx);
+          return;
+        }
+        case "deleteContentForward":
+        case "deleteWordForward":
+        case "deleteSoftLineForward":
+        case "deleteHardLineForward": {
+          e.preventDefault();
+          deleteForward(ctx);
+          return;
+        }
+        case "historyUndo": {
+          e.preventDefault();
+          hist.undo();
+          return;
+        }
+        case "historyRedo": {
+          e.preventDefault();
+          hist.redo();
+          return;
+        }
+        default: {
+          e.preventDefault();
+          return;
+        }
+      }
+    };
+    root.addEventListener("beforeinput", handler);
+    return () => root.removeEventListener("beforeinput", handler);
+  }, []);
+  const onKeyDown = useCallback5((e) => {
+    const ed = editorRef.current;
+    const mod = e.metaKey || e.ctrlKey;
+    if (e.key === "Tab") {
+      e.preventDefault();
+      if (ed.isInTable()) {
+        if (e.shiftKey) ed.moveToPrevCell();
+        else ed.moveToNextCell();
+        return;
+      }
+      if (e.shiftKey) ed.dedentList();
+      else ed.indentList();
+      return;
+    }
+    if (!mod) return;
+    const key = e.key.toLowerCase();
+    if (!e.shiftKey && !e.altKey && key === "z") {
+      e.preventDefault();
+      historyRef.current.undo();
+      return;
+    }
+    if (!e.altKey && (key === "y" || e.shiftKey && key === "z")) {
+      e.preventDefault();
+      historyRef.current.redo();
+      return;
+    }
+    if (e.altKey && !e.shiftKey && /^[0-6]$/.test(key)) {
+      e.preventDefault();
+      const n = Number(key);
+      if (n === 0) ed.setBlockType("paragraph");
+      else ed.setBlockType("heading", { level: n });
+      return;
+    }
+    if (e.shiftKey && !e.altKey && (key === "7" || key === "8")) {
+      e.preventDefault();
+      ed.toggleList(key === "7" ? "ordered" : "bullet");
+      return;
+    }
+    const markToggle = !e.shiftKey && !e.altKey ? BOOLEAN_SHORTCUTS[key] : void 0;
+    if (markToggle) {
+      e.preventDefault();
+      ed.toggleMark(markToggle);
+      return;
+    }
+    if (e.shiftKey && !e.altKey && key === "x") {
+      e.preventDefault();
+      ed.toggleMark("strike");
+      return;
+    }
+    if (!e.altKey && !e.shiftKey && key === "k") {
+      e.preventDefault();
+      const active = ed.getActiveMarks();
+      const currentHref = active.link && typeof active.link === "object" && "href" in active.link ? active.link.href : "";
+      void ed.requestLink(currentHref).then((href) => {
+        if (href === null) return;
+        if (href === "") ed.removeMark("link");
+        else ed.setMark("link", { href });
+      });
+    }
+  }, []);
+  const onCompositionStart = useCallback5(() => {
+    isComposingRef.current = true;
+  }, []);
+  const onCompositionEnd = useCallback5((e) => {
+    isComposingRef.current = false;
+    if (e.data && e.data.length > 0) {
+      insertText(ctxRef.current, e.data);
+    }
+  }, []);
+  const topLevels = useMemo4(() => groupTopLevels(snapshot.blocks), [snapshot]);
+  const docSettings = usePageSettings(editor.doc);
+  const propIsSet = pageGeometry !== void 0;
+  const geom = propIsSet ? pageGeometry ?? A4_PAGE : docSettings;
+  const paginated = pageGeometry !== null;
+  const selectedEmbed = editor.getSelectedEmbed();
+  const layout = usePageLayout(
+    rootRef,
+    geom,
+    topLevels.length,
+    [topLevels, pageGeometry]
+  );
+  const effectiveLayout = paginated ? layout : defaultPageLayout(topLevels.length);
+  const pageStyle = paginated ? {
+    "--ed-page-width": `${geom.width}px`,
+    "--ed-page-height": `${geom.height}px`,
+    "--ed-page-margin-top": `${geom.marginTop}px`,
+    "--ed-page-margin-bottom": `${geom.marginBottom}px`,
+    "--ed-page-margin-left": `${geom.marginLeft}px`,
+    "--ed-page-margin-right": `${geom.marginRight}px`
+  } : void 0;
+  const body = /* @__PURE__ */ jsxs8(
+    "div",
+    {
+      ref: rootRef,
+      contentEditable: true,
+      suppressContentEditableWarning: true,
+      spellCheck: true,
+      autoCorrect: "off",
+      autoCapitalize: "off",
+      role: "textbox",
+      "aria-multiline": "true",
+      className: (className ?? "ed-root") + (paginated ? " ed-root--paged" : " ed-root--flat"),
+      style: pageStyle,
+      onKeyDown,
+      onCompositionStart,
+      onCompositionEnd,
+      children: [
+        paginated ? effectiveLayout.pages.map((page, pi) => {
+          const ctx = {
+            pageNumber: pi + 1,
+            pageCount: effectiveLayout.pages.length
+          };
+          return /* @__PURE__ */ jsxs8(
+            "div",
+            {
+              className: "ed-page",
+              "data-page-number": ctx.pageNumber,
+              "data-page-total": ctx.pageCount,
+              children: [
+                renderPageHeader && /* @__PURE__ */ jsx9("div", { className: "ed-page-header", contentEditable: false, children: renderPageHeader(ctx) }),
+                /* @__PURE__ */ jsx9("div", { className: "ed-page-content", children: page.slots.map((slot) => renderSlot(slot, topLevels)) }),
+                renderPageFooter && /* @__PURE__ */ jsx9("div", { className: "ed-page-footer", contentEditable: false, children: renderPageFooter(ctx) })
+              ]
+            },
+            `page-${pi}`
+          );
+        }) : topLevels.map((t) => renderTopLevel(t)),
+        selectedEmbed && /* @__PURE__ */ jsx9(
+          ImageResizeOverlay,
+          {
+            rootRef,
+            blockIndex: selectedEmbed.blockIndex,
+            offset: selectedEmbed.offset,
+            cellIndex: selectedEmbed.cellIndex,
+            embed: selectedEmbed.embed,
+            onCommit: (w, h) => editor.setImageAttrs(
+              selectedEmbed.blockIndex,
+              selectedEmbed.offset,
+              { width: w, height: h },
+              selectedEmbed.cellIndex
+            ),
+            onCommitMove: (ox, oy) => editor.setImageAttrs(
+              selectedEmbed.blockIndex,
+              selectedEmbed.offset,
+              { offsetX: ox, offsetY: oy },
+              selectedEmbed.cellIndex
+            )
+          }
+        )
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsx9(EditorProvider, { editor, children: body });
+}
+function groupTopLevels(snapshot) {
+  const out = [];
+  let i = 0;
+  while (i < snapshot.length) {
+    const block = snapshot[i];
+    if (block.type === "listItem") {
+      const groupStart = i;
+      const items = [];
+      const kind = block.attrs.listKind === "ordered" ? "ordered" : "bullet";
+      while (i < snapshot.length && snapshot[i].type === "listItem" && (snapshot[i].attrs.listKind ?? "bullet") === kind) {
+        items.push({ block: snapshot[i], index: i });
+        i++;
+      }
+      out.push({ kind: "list", items, listKind: kind, key: groupStart });
+      continue;
+    }
+    out.push({ kind: "block", block, blockIndex: i, key: i });
+    i++;
+  }
+  return out;
+}
+function renderSlot(slot, topLevels) {
+  const top = topLevels[slot.topLevelIndex];
+  if (!top) return null;
+  if (slot.fragment && top.kind === "block") {
+    const f = {
+      index: slot.fragment.index,
+      start: slot.fragment.start,
+      end: slot.fragment.end
+    };
+    return /* @__PURE__ */ jsx9(
+      NodeView,
+      {
+        block: top.block,
+        index: top.blockIndex,
+        fragment: f
+      },
+      `${top.key}-f${f.index}`
+    );
+  }
+  if (slot.tableFragment && top.kind === "block" && top.block.type === "table") {
+    return /* @__PURE__ */ jsx9(
+      NodeView,
+      {
+        block: top.block,
+        index: top.blockIndex,
+        tableFragment: slot.tableFragment
+      },
+      `${top.key}-tf${slot.tableFragment.index}`
+    );
+  }
+  return renderTopLevel(top);
+}
+function renderTopLevel(top) {
+  if (top.kind === "list") {
+    const tree = buildListTree(top.items);
+    return renderListTree(tree, top.listKind, `list-${top.key}`);
+  }
+  return /* @__PURE__ */ jsx9(NodeView, { block: top.block, index: top.blockIndex }, top.key);
+}
+function buildListTree(items) {
+  const roots = [];
+  const stack = [{ children: roots, level: -1 }];
+  for (const it of items) {
+    const level = clampListLevel2(it.block.attrs.listLevel);
+    while (stack.length > 1 && stack[stack.length - 1].level >= level) stack.pop();
+    const node = { entry: it, children: [] };
+    stack[stack.length - 1].children.push(node);
+    stack.push({ children: node.children, level });
+  }
+  return roots;
+}
+function renderListTree(tree, kind, key) {
+  const Tag = kind === "ordered" ? "ol" : "ul";
+  return /* @__PURE__ */ jsx9(Tag, { className: `ed-list ed-list-${kind}`, "data-list-kind": kind, children: tree.map((node) => /* @__PURE__ */ jsx9(NodeView, { block: node.entry.block, index: node.entry.index, children: node.children.length > 0 ? renderListTree(node.children, kind, `nested-${node.entry.index}`) : null }, node.entry.index)) }, key);
+}
+function clampListLevel2(l) {
+  if (typeof l !== "number" || !Number.isFinite(l)) return 0;
+  return Math.max(0, Math.min(5, Math.trunc(l)));
+}
+var BOOLEAN_SHORTCUTS = {
+  b: "bold",
+  i: "italic",
+  u: "underline"
+};
+function caretRangeFromPoint(x, y) {
+  const doc = document;
+  if (typeof doc.caretRangeFromPoint === "function") {
+    return doc.caretRangeFromPoint(x, y);
+  }
+  if (typeof doc.caretPositionFromPoint === "function") {
+    const pos = doc.caretPositionFromPoint(x, y);
+    if (!pos) return null;
+    const range = document.createRange();
+    range.setStart(pos.offsetNode, pos.offset);
+    range.collapse(true);
+    return range;
+  }
+  return null;
+}
+
+// src/Toolbar.tsx
+import {
+  useCallback as useCallback6,
+  useEffect as useEffect8,
+  useRef as useRef11,
+  useState as useState8
+} from "react";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var FONT_FAMILIES = ["Arial"];
+var FONT_SIZES = ["8pt", "10pt", "11pt", "12pt", "14pt", "16pt", "18pt", "24pt", "32pt", "48pt"];
+var BLOCK_OPTIONS = [
+  { value: "paragraph", label: "Par\xE1grafo", type: "paragraph" },
+  { value: "h1", label: "T\xEDtulo 1", type: "heading", level: 1 },
+  { value: "h2", label: "T\xEDtulo 2", type: "heading", level: 2 },
+  { value: "h3", label: "T\xEDtulo 3", type: "heading", level: 3 },
+  { value: "h4", label: "T\xEDtulo 4", type: "heading", level: 4 },
+  { value: "h5", label: "T\xEDtulo 5", type: "heading", level: 5 },
+  { value: "h6", label: "T\xEDtulo 6", type: "heading", level: 6 },
+  { value: "blockquote", label: "Cita\xE7\xE3o", type: "blockquote" },
+  { value: "codeBlock", label: "C\xF3digo", type: "codeBlock" }
+];
+var ALIGN_OPTIONS = [
+  { value: "left", label: "\u21E4", title: "Alinhar \xE0 esquerda" },
+  { value: "center", label: "\u2261", title: "Centralizar" },
+  { value: "right", label: "\u21E5", title: "Alinhar \xE0 direita" },
+  { value: "justify", label: "\u2630", title: "Justificar" }
+];
+var IMAGE_ALIGN_VALUES = /* @__PURE__ */ new Set(["left", "center", "right"]);
+var IMAGE_LAYOUT_OPTIONS = [
+  { value: "inline", label: "\u2194", title: "Inline (no fluxo do texto)" },
+  { value: "wrap-left", label: "\u25E7", title: "Texto contorna \xE0 direita" },
+  { value: "wrap-right", label: "\u25E8", title: "Texto contorna \xE0 esquerda" },
+  { value: "behind", label: "\u25A2\u2193", title: "Atr\xE1s do texto" },
+  { value: "front", label: "\u25A2\u2191", title: "Na frente do texto" }
+];
+function Toolbar({ className }) {
+  const editor = useEditorContext();
+  const {
+    isMarkActive,
+    getActiveMarks,
+    toggleMark,
+    setMark,
+    removeMark,
+    getBlockType,
+    getBlockAttr,
+    setBlockType,
+    setBlockAttr,
+    isListActive,
+    toggleList,
+    indentList,
+    dedentList
+  } = editor;
+  const active = getActiveMarks();
+  const blockType = getBlockType();
+  const blockLevel = getBlockAttr("level");
+  const blockAlign = getBlockAttr("align");
+  const blockDir = getBlockAttr("dir");
+  const stop = (e) => {
+    const t = e.target;
+    if (t && (t.tagName === "SELECT" || t.tagName === "INPUT" || t.tagName === "OPTION")) {
+      return;
+    }
+    e.preventDefault();
+  };
+  const onToggle = (name) => (e) => {
+    e.preventDefault();
+    toggleMark(name);
+  };
+  const onColorChange = (e) => {
+    setMark("color", e.target.value);
+  };
+  const onFontFamilyChange = (e) => {
+    const v = e.target.value;
+    if (v === "") removeMark("fontFamily");
+    else setMark("fontFamily", v);
+  };
+  const onFontSizeChange = (e) => {
+    const v = e.target.value;
+    if (v === "") removeMark("fontSize");
+    else setMark("fontSize", v);
+  };
+  const onBlockChange = (e) => {
+    const opt = BLOCK_OPTIONS.find((o) => o.value === e.target.value);
+    if (!opt) return;
+    setBlockType(opt.type, opt.level !== void 0 ? { level: opt.level } : void 0);
+  };
+  const onAlign = (value) => (e) => {
+    e.preventDefault();
+    const selectedEmbed2 = editor.getSelectedEmbed();
+    if (selectedEmbed2 && IMAGE_ALIGN_VALUES.has(value)) {
+      editor.setImageAttrs(
+        selectedEmbed2.blockIndex,
+        selectedEmbed2.offset,
+        { align: value },
+        selectedEmbed2.cellIndex
+      );
+      return;
+    }
+    setBlockAttr("align", value);
+  };
+  const onInsertImageClick = useCallback6(
+    (e) => {
+      e.preventDefault();
+      imageInputRef.current?.click();
+    },
+    []
+  );
+  const onImageInputChange = useCallback6(
+    (e) => {
+      const file = e.target.files?.[0];
+      if (file) void editor.insertImageFromFile(file);
+      e.target.value = "";
+    },
+    [editor]
+  );
+  const imageInputRef = useRef11(null);
+  const onToggleDir = (e) => {
+    e.preventDefault();
+    const next = blockDir === "rtl" ? "ltr" : "rtl";
+    setBlockAttr("dir", next);
+  };
+  const linkActive = isMarkActive("link");
+  const onLinkClick = useCallback6(
+    (e) => {
+      e.preventDefault();
+      const currentHref = active.link && typeof active.link === "object" && "href" in active.link ? active.link.href : "";
+      void editor.requestLink(currentHref).then((href) => {
+        if (href === null) return;
+        if (href === "") removeMark("link");
+        else setMark("link", { href });
+      });
+    },
+    [active.link, editor, removeMark, setMark]
+  );
+  const colorValue = typeof active.color === "string" ? active.color : "#000000";
+  const fontFamilyValue = typeof active.fontFamily === "string" ? active.fontFamily : "";
+  const fontSizeValue = typeof active.fontSize === "string" ? active.fontSize : "";
+  const blockValue = blockSelectValue(blockType, blockLevel);
+  const selectedEmbed = editor.getSelectedEmbed();
+  const currentImageLayout = selectedEmbed ? selectedEmbed.embed.layout ?? "inline" : "inline";
+  const onImageLayoutClick = (layout) => (e) => {
+    e.preventDefault();
+    const sel = editor.getSelectedEmbed();
+    if (!sel) return;
+    const reset = layout !== (sel.embed.layout ?? "inline") ? { offsetX: 0, offsetY: 0 } : {};
+    editor.setImageAttrs(
+      sel.blockIndex,
+      sel.offset,
+      { layout, ...reset },
+      sel.cellIndex
+    );
+  };
+  return /* @__PURE__ */ jsxs9(
+    "div",
+    {
+      className: className ?? "ed-toolbar",
+      role: "toolbar",
+      "aria-label": "Editor toolbar",
+      onMouseDown: stop,
+      children: [
+        /* @__PURE__ */ jsx10(Group, { children: /* @__PURE__ */ jsxs9(
+          "select",
+          {
+            className: "ed-toolbar-select",
+            value: blockValue,
+            onChange: onBlockChange,
+            onMouseDown: stop,
+            "aria-label": "Tipo de bloco",
+            children: [
+              blockValue === "" && /* @__PURE__ */ jsx10("option", { value: "", children: "\u2014 (misto)" }),
+              BLOCK_OPTIONS.map((o) => /* @__PURE__ */ jsx10("option", { value: o.value, children: o.label }, o.value))
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ jsxs9(Group, { children: [
+          /* @__PURE__ */ jsx10(MarkButton, { title: "Negrito (\u2318B)", pressed: isMarkActive("bold"), onClick: onToggle("bold"), children: /* @__PURE__ */ jsx10("strong", { children: "B" }) }),
+          /* @__PURE__ */ jsx10(MarkButton, { title: "It\xE1lico (\u2318I)", pressed: isMarkActive("italic"), onClick: onToggle("italic"), children: /* @__PURE__ */ jsx10("em", { children: "I" }) }),
+          /* @__PURE__ */ jsx10(MarkButton, { title: "Sublinhado (\u2318U)", pressed: isMarkActive("underline"), onClick: onToggle("underline"), children: /* @__PURE__ */ jsx10("u", { children: "U" }) }),
+          /* @__PURE__ */ jsx10(MarkButton, { title: "Tachado (\u2318\u21E7X)", pressed: isMarkActive("strike"), onClick: onToggle("strike"), children: /* @__PURE__ */ jsx10("s", { children: "S" }) })
+        ] }),
+        /* @__PURE__ */ jsxs9(Group, { children: [
+          /* @__PURE__ */ jsxs9("label", { className: "ed-toolbar-label", children: [
+            /* @__PURE__ */ jsx10("span", { className: "ed-toolbar-swatch", "aria-hidden": true, style: { background: colorValue } }),
+            /* @__PURE__ */ jsx10("input", { type: "color", value: colorValue, onChange: onColorChange, onMouseDown: stop, "aria-label": "Cor do texto" })
+          ] }),
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              title: "Remover cor",
+              onMouseDown: stop,
+              onClick: (e) => {
+                e.preventDefault();
+                removeMark("color");
+              },
+              children: "\u232B"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs9(Group, { children: [
+          /* @__PURE__ */ jsxs9(
+            "select",
+            {
+              className: "ed-toolbar-select",
+              value: fontFamilyValue,
+              onChange: onFontFamilyChange,
+              onMouseDown: stop,
+              "aria-label": "Fam\xEDlia da fonte",
+              children: [
+                /* @__PURE__ */ jsx10("option", { value: "", children: "Fonte\u2026" }),
+                FONT_FAMILIES.map((f) => /* @__PURE__ */ jsx10("option", { value: f, children: f }, f))
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs9(
+            "select",
+            {
+              className: "ed-toolbar-select",
+              value: fontSizeValue,
+              onChange: onFontSizeChange,
+              onMouseDown: stop,
+              "aria-label": "Tamanho da fonte",
+              children: [
+                /* @__PURE__ */ jsx10("option", { value: "", children: "Tamanho\u2026" }),
+                FONT_SIZES.map((s) => /* @__PURE__ */ jsx10("option", { value: s, children: s }, s))
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx10(Group, { children: ALIGN_OPTIONS.map((a) => /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "ed-toolbar-btn",
+            title: a.title,
+            "aria-pressed": blockAlign === a.value,
+            onMouseDown: stop,
+            onClick: onAlign(a.value),
+            children: a.label
+          },
+          a.value
+        )) }),
+        /* @__PURE__ */ jsx10(Group, { children: /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "ed-toolbar-btn",
+            "aria-pressed": blockDir === "rtl",
+            title: blockDir === "rtl" ? "Mudar para LTR" : "Mudar para RTL (hebraico)",
+            onMouseDown: stop,
+            onClick: onToggleDir,
+            children: blockDir === "rtl" ? "RTL" : "LTR"
+          }
+        ) }),
+        /* @__PURE__ */ jsxs9(Group, { children: [
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              "aria-pressed": isListActive("bullet"),
+              title: "Lista com marcadores (\u2318\u21E78)",
+              onMouseDown: stop,
+              onClick: (e) => {
+                e.preventDefault();
+                toggleList("bullet");
+              },
+              children: "\u2022"
+            }
+          ),
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              "aria-pressed": isListActive("ordered"),
+              title: "Lista numerada (\u2318\u21E77)",
+              onMouseDown: stop,
+              onClick: (e) => {
+                e.preventDefault();
+                toggleList("ordered");
+              },
+              children: "1."
+            }
+          ),
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              title: "Diminuir recuo (\u21E7Tab)",
+              onMouseDown: stop,
+              onClick: (e) => {
+                e.preventDefault();
+                dedentList();
+              },
+              children: "\u21E4"
+            }
+          ),
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              title: "Aumentar recuo (Tab)",
+              onMouseDown: stop,
+              onClick: (e) => {
+                e.preventDefault();
+                indentList();
+              },
+              children: "\u21E5"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx10(Group, { children: /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "ed-toolbar-btn",
+            "aria-pressed": linkActive,
+            title: linkActive ? "Remover link (\u2318K)" : "Adicionar link (\u2318K)",
+            onMouseDown: stop,
+            onClick: onLinkClick,
+            children: "\u{1F517}"
+          }
+        ) }),
+        /* @__PURE__ */ jsx10(Group, { children: /* @__PURE__ */ jsx10(TableMenu, {}) }),
+        /* @__PURE__ */ jsxs9(Group, { children: [
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              title: "Inserir imagem",
+              onMouseDown: stop,
+              onClick: onInsertImageClick,
+              children: "\u{1F5BC}"
+            }
+          ),
+          /* @__PURE__ */ jsx10(
+            "input",
+            {
+              ref: imageInputRef,
+              type: "file",
+              accept: "image/*",
+              hidden: true,
+              onChange: onImageInputChange
+            }
+          )
+        ] }),
+        selectedEmbed && /* @__PURE__ */ jsxs9(Group, { children: [
+          IMAGE_LAYOUT_OPTIONS.map((opt) => /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              title: opt.title,
+              "aria-pressed": currentImageLayout === opt.value,
+              onMouseDown: stop,
+              onClick: onImageLayoutClick(opt.value),
+              children: opt.label
+            },
+            opt.value
+          )),
+          /* @__PURE__ */ jsx10(
+            "button",
+            {
+              type: "button",
+              className: "ed-toolbar-btn",
+              title: "Legenda da imagem",
+              "aria-pressed": !!selectedEmbed.embed.caption,
+              onMouseDown: stop,
+              onClick: (e) => {
+                e.preventDefault();
+                const initialCaption = selectedEmbed.embed.caption ?? "";
+                const initialAlign = selectedEmbed.embed.captionAlign ?? "center";
+                void editor.requestImageCaption(initialCaption, initialAlign).then((result) => {
+                  if (result === null) return;
+                  const empty = result.caption.length === 0;
+                  editor.setImageAttrs(
+                    selectedEmbed.blockIndex,
+                    selectedEmbed.offset,
+                    {
+                      caption: empty ? void 0 : result.caption,
+                      captionAlign: empty ? void 0 : result.align
+                    },
+                    selectedEmbed.cellIndex
+                  );
+                });
+              },
+              children: "Legenda"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx10(Group, { children: /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "ed-toolbar-btn",
+            title: "Configurar p\xE1gina (tamanho, margens)",
+            onMouseDown: stop,
+            onClick: (e) => {
+              e.preventDefault();
+              void editor.requestPageConfig();
+            },
+            children: "\u2699"
+          }
+        ) })
+      ]
+    }
+  );
+}
+function TableMenu() {
+  const editor = useEditorContext();
+  const inTable = editor.isInTable();
+  const [open, setOpen] = useState8(false);
+  const rootRef = useRef11(null);
+  useEffect8(() => {
+    if (!open) return;
+    const onDown = (e) => {
+      if (!rootRef.current) return;
+      if (rootRef.current.contains(e.target)) return;
+      setOpen(false);
+    };
+    document.addEventListener("mousedown", onDown);
+    return () => document.removeEventListener("mousedown", onDown);
+  }, [open]);
+  return /* @__PURE__ */ jsxs9("div", { ref: rootRef, className: "ed-toolbar-tablemenu", children: [
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        type: "button",
+        className: "ed-toolbar-btn",
+        title: "Tabela",
+        "aria-pressed": open,
+        onMouseDown: (e) => e.preventDefault(),
+        onClick: (e) => {
+          e.preventDefault();
+          setOpen((v) => !v);
+        },
+        children: "\u25A6"
+      }
+    ),
+    open && /* @__PURE__ */ jsxs9(
+      "div",
+      {
+        className: "ed-table-popover",
+        role: "menu",
+        onMouseDown: (e) => {
+          const t = e.target;
+          if (!t || t.tagName !== "INPUT" && t.tagName !== "BUTTON") {
+            e.preventDefault();
+          }
+        },
+        children: [
+          /* @__PURE__ */ jsx10(
+            TableSizePicker,
+            {
+              onPick: (rows, cols) => {
+                setOpen(false);
+                editor.insertTable(rows, cols);
+              }
+            }
+          ),
+          inTable && /* @__PURE__ */ jsxs9("div", { className: "ed-table-actions", children: [
+            /* @__PURE__ */ jsx10("hr", {}),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.insertRowAbove();
+            }, children: "Inserir linha acima" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.insertRowBelow();
+            }, children: "Inserir linha abaixo" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.insertColumnLeft();
+            }, children: "Inserir coluna \xE0 esquerda" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.insertColumnRight();
+            }, children: "Inserir coluna \xE0 direita" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.deleteCurrentRow();
+            }, children: "Excluir linha" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.deleteCurrentColumn();
+            }, children: "Excluir coluna" }),
+            /* @__PURE__ */ jsx10("hr", {}),
+            editor.hasTableRectSelection() && /* @__PURE__ */ jsx10(
+              "button",
+              {
+                type: "button",
+                onClick: () => {
+                  setOpen(false);
+                  editor.mergeSelection();
+                },
+                children: "Mesclar c\xE9lulas selecionadas"
+              }
+            ),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.mergeRight();
+            }, children: "Mesclar com c\xE9lula \xE0 direita" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.mergeDown();
+            }, children: "Mesclar com c\xE9lula abaixo" }),
+            /* @__PURE__ */ jsx10("button", { type: "button", onClick: () => {
+              setOpen(false);
+              editor.splitCell();
+            }, children: "Dividir c\xE9lulas mescladas" }),
+            /* @__PURE__ */ jsx10(
+              "button",
+              {
+                type: "button",
+                className: "ed-table-delete",
+                onClick: () => {
+                  setOpen(false);
+                  editor.deleteTable();
+                },
+                children: "Excluir tabela"
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+var PICKER_MAX_ROWS = 8;
+var PICKER_MAX_COLS = 10;
+function TableSizePicker({ onPick }) {
+  const [hover, setHover] = useState8(null);
+  const label = hover ? `${hover.r + 1} \xD7 ${hover.c + 1}` : "Inserir tabela";
+  return /* @__PURE__ */ jsxs9("div", { className: "ed-table-picker", children: [
+    /* @__PURE__ */ jsx10("div", { className: "ed-table-picker-label", children: label }),
+    /* @__PURE__ */ jsx10(
+      "div",
+      {
+        className: "ed-table-picker-grid",
+        style: {
+          gridTemplateColumns: `repeat(${PICKER_MAX_COLS}, 18px)`,
+          gridTemplateRows: `repeat(${PICKER_MAX_ROWS}, 18px)`
+        },
+        onMouseLeave: () => setHover(null),
+        children: Array.from(
+          { length: PICKER_MAX_ROWS },
+          (_, r) => Array.from({ length: PICKER_MAX_COLS }, (_2, c) => {
+            const filled = hover != null && r <= hover.r && c <= hover.c;
+            return /* @__PURE__ */ jsx10(
+              "button",
+              {
+                type: "button",
+                className: `ed-table-picker-cell${filled ? " filled" : ""}`,
+                onMouseEnter: () => setHover({ r, c }),
+                onMouseDown: (e) => e.preventDefault(),
+                onClick: (e) => {
+                  e.preventDefault();
+                  onPick(r + 1, c + 1);
+                },
+                "aria-label": `${r + 1} \xD7 ${c + 1}`
+              },
+              `${r}-${c}`
+            );
+          })
+        )
+      }
+    )
+  ] });
+}
+function blockSelectValue(type, level) {
+  if (type === "mixed") return "";
+  if (type === "heading") {
+    if (typeof level === "number" && level >= 1 && level <= 6) return `h${level}`;
+    return "h1";
+  }
+  return type;
+}
+function Group({ children }) {
+  return /* @__PURE__ */ jsx10("div", { className: "ed-toolbar-group", children });
+}
+function MarkButton({ title, pressed, onClick, children }) {
+  return /* @__PURE__ */ jsx10(
+    "button",
+    {
+      type: "button",
+      className: "ed-toolbar-btn",
+      "aria-pressed": pressed,
+      title,
+      onMouseDown: (e) => e.preventDefault(),
+      onClick,
+      children
+    }
+  );
+}
+export {
+  A4_PAGE,
+  Editor,
+  EditorProvider,
+  ImageCaptionDialog,
+  LinkDialog,
+  NodeView,
+  PageConfigDialog,
+  Toolbar,
+  applyDomSelection,
+  contentHeight,
+  contentWidth,
+  defaultPageLayout,
+  deltaLength,
+  findBlockIndex,
+  getBlockElement,
+  getCellElement,
+  getFragmentForOffset,
+  isTableRectSelection,
+  readDomSelection,
+  renderInline,
+  selectionsEqual,
+  sliceDelta,
+  textOffsetWithin,
+  useEditor,
+  useEditorContext,
+  usePageLayout,
+  usePageSettings
+};
+//# sourceMappingURL=index.js.map