@sofereditor/react 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   getBlockElement: () => getBlockElement,
   getCellElement: () => getCellElement,
   getFragmentForOffset: () => getFragmentForOffset,
+  htmlToSlice: () => htmlToSlice,
   isTableRectSelection: () => isTableRectSelection,
   locatePoint: () => locatePoint,
   readDomSelection: () => readDomSelection,
@@ -54,7 +55,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/Editor.tsx
 var import_react14 = require("react");
-var import_core6 = require("@sofereditor/core");
+var import_core9 = require("@sofereditor/core");
 
 // src/dom-bridge.ts
 function findContainingBlockElement(node, root) {
@@ -329,6 +330,746 @@ function applyDomSelection(root, modelSel) {
   }
 }
 
+// src/pastePlan.ts
+var import_core2 = require("@sofereditor/core");
+
+// src/htmlToSlice.ts
+var import_core = require("@sofereditor/core");
+
+// src/imageConstraints.ts
+var MAX_INSERT_WIDTH = 600;
+
+// src/htmlToSlice.ts
+function htmlToSlice(html) {
+  if (!html || html.trim().length === 0) return null;
+  let doc;
+  try {
+    doc = new DOMParser().parseFromString(html, "text/html");
+  } catch {
+    return null;
+  }
+  const body = doc.body;
+  if (!body) return null;
+  const blocks = [];
+  try {
+    walkBlockLevel(body, {}, blocks);
+  } catch {
+    return null;
+  }
+  if (blocks.length === 0) return null;
+  normalizeListLevels(blocks);
+  const temConteudo = blocks.some(
+    (b) => b.text.trim().length > 0 || b.delta.some((op) => (0, import_core.isImageEmbed)(op.insert))
+  );
+  if (!temConteudo) return null;
+  const blockLevel = blocks.length > 1 || blocks[0].type !== "paragraph";
+  return { blocks, openStart: false, openEnd: false, ...blockLevel ? { blockLevel: true } : {} };
+}
+var IGNORED_TAGS = /* @__PURE__ */ new Set(["script", "style", "meta", "link", "head", "title", "xml"]);
+var BLOCK_LEVEL_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "div",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "main",
+  "figure",
+  "figcaption",
+  "pre",
+  "address"
+]);
+var BLOCK_TRIGGER_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "div",
+  "ul",
+  "ol",
+  "li",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "table",
+  "tr",
+  "td",
+  "th"
+]);
+function isNamespacedTag(tag) {
+  return tag.includes(":");
+}
+function hasBlockDescendant(el) {
+  const all = el.querySelectorAll("*");
+  for (const e of Array.from(all)) {
+    if (BLOCK_TRIGGER_TAGS.has(e.tagName.toLowerCase())) return true;
+  }
+  return false;
+}
+function walkBlockLevel(container, marks, blocks) {
+  let loose = [];
+  const flushLoose = () => {
+    if (loose.length === 0) return;
+    const nodes = loose;
+    loose = [];
+    const delta = inlineDeltaFromNodes(nodes, marks);
+    if (delta.length > 0) blocks.push(makeBlock("paragraph", delta, {}));
+  };
+  for (const node of Array.from(container.childNodes)) {
+    if (node.nodeType === Node.COMMENT_NODE) continue;
+    if (node.nodeType === Node.TEXT_NODE) {
+      loose.push(node);
+      continue;
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) continue;
+    const el = node;
+    const tag = el.tagName.toLowerCase();
+    if (IGNORED_TAGS.has(tag) || isNamespacedTag(tag)) continue;
+    switch (tag) {
+      case "ul":
+      case "ol": {
+        flushLoose();
+        handleList(el, tag === "ol" ? "ordered" : "bullet", 0, marks, blocks);
+        break;
+      }
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6": {
+        flushLoose();
+        const level = Number(tag[1]);
+        const attrs = { level };
+        const align = readAlign(el);
+        if (align) attrs.align = align;
+        const delta = inlineDeltaFromNodes(Array.from(el.childNodes), marks);
+        blocks.push(makeBlock("heading", delta, attrs));
+        break;
+      }
+      case "blockquote": {
+        flushLoose();
+        handleBlockquote(el, marks, blocks);
+        break;
+      }
+      case "table": {
+        flushLoose();
+        handleTable(el, marks, blocks);
+        break;
+      }
+      case "li": {
+        flushLoose();
+        const nestedLists = topLevelListDescendants(el);
+        const clone = el.cloneNode(true);
+        for (const l of topLevelListDescendants(clone)) l.remove();
+        const delta = inlineDeltaFromNodes(Array.from(clone.childNodes), marks);
+        blocks.push(makeBlock("listItem", delta, { listKind: "bullet", listLevel: 0 }));
+        for (const nested of nestedLists) {
+          const nestedKind = nested.tagName.toLowerCase() === "ol" ? "ordered" : "bullet";
+          handleList(nested, nestedKind, 1, marks, blocks);
+        }
+        break;
+      }
+      case "img":
+        loose.push(node);
+        break;
+      case "br":
+        loose.push(node);
+        break;
+      default: {
+        const styleAttr = el.getAttribute("style") ?? "";
+        const wordListLevel = parseWordListLevel(styleAttr);
+        if (wordListLevel != null && !hasBlockDescendant(el)) {
+          flushLoose();
+          const marker = findWordListMarker(el);
+          const listKind = marker ? detectWordListKind(marker) : "bullet";
+          const attrs = { listKind, listLevel: wordListLevel };
+          const align = readAlign(el);
+          if (align) attrs.align = align;
+          const delta = inlineDeltaFromNodes(Array.from(el.childNodes), marks);
+          blocks.push(makeBlock("listItem", delta, attrs));
+          break;
+        }
+        if (hasBlockDescendant(el)) {
+          flushLoose();
+          let nextMarks = applyTagMarks(tag, marks);
+          nextMarks = applyStyleMarks(el.getAttribute("style"), nextMarks);
+          walkBlockLevel(el, nextMarks, blocks);
+          break;
+        }
+        if (BLOCK_LEVEL_TAGS.has(tag)) {
+          flushLoose();
+          const attrs = {};
+          const align = readAlign(el);
+          if (align) attrs.align = align;
+          const delta = inlineDeltaFromNodes(Array.from(el.childNodes), marks);
+          blocks.push(makeBlock("paragraph", delta, attrs));
+          break;
+        }
+        loose.push(node);
+      }
+    }
+  }
+  flushLoose();
+}
+function handleList(listEl, kind, level, marks, blocks) {
+  for (const child of Array.from(listEl.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag === "ul" || tag === "ol") {
+      const siblingKind = tag === "ol" ? "ordered" : "bullet";
+      handleList(child, siblingKind, level + 1, marks, blocks);
+      continue;
+    }
+    if (tag !== "li") continue;
+    const nestedLists = topLevelListDescendants(child);
+    const clone = child.cloneNode(true);
+    for (const l of topLevelListDescendants(clone)) l.remove();
+    const delta = inlineDeltaFromNodes(Array.from(clone.childNodes), marks);
+    const attrs = { listKind: kind, listLevel: clampLevel(level) };
+    const align = readAlign(child);
+    if (align) attrs.align = align;
+    blocks.push(makeBlock("listItem", delta, attrs));
+    for (const nested of nestedLists) {
+      const nestedKind = nested.tagName.toLowerCase() === "ol" ? "ordered" : "bullet";
+      handleList(nested, nestedKind, level + 1, marks, blocks);
+    }
+  }
+}
+function topLevelListDescendants(root) {
+  const all = Array.from(root.querySelectorAll("ul, ol"));
+  return all.filter((el) => {
+    let p = el.parentElement;
+    while (p && p !== root) {
+      const t = p.tagName.toLowerCase();
+      if (t === "ul" || t === "ol" || t === "table" || t === "td" || t === "th") return false;
+      p = p.parentElement;
+    }
+    return true;
+  });
+}
+function handleBlockquote(el, marks, blocks) {
+  if (!hasBlockDescendant(el)) {
+    const attrs = {};
+    const align = readAlign(el);
+    if (align) attrs.align = align;
+    const delta = inlineDeltaFromNodes(Array.from(el.childNodes), marks);
+    blocks.push(makeBlock("blockquote", delta, attrs));
+    return;
+  }
+  const nested = [];
+  walkBlockLevel(el, marks, nested);
+  for (const b of nested) {
+    blocks.push(b.type === "paragraph" ? { ...b, type: "blockquote" } : b);
+  }
+}
+function handleTable(table, marks, blocks) {
+  for (const row of directRows(table)) {
+    const cells = Array.from(row.children).filter(
+      (c) => ["td", "th"].includes(c.tagName.toLowerCase())
+    );
+    for (const cell of cells) {
+      const cellBlocks = [];
+      walkBlockLevel(cell, marks, cellBlocks);
+      for (const b of cellBlocks) {
+        const attrs = {};
+        if (b.attrs.align) attrs.align = b.attrs.align;
+        blocks.push(makeBlock("paragraph", b.delta, attrs));
+      }
+    }
+  }
+}
+function directRows(table) {
+  const rows = [];
+  for (const child of Array.from(table.children)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag === "tr") {
+      rows.push(child);
+    } else if (tag === "tbody" || tag === "thead" || tag === "tfoot") {
+      for (const r of Array.from(child.children)) {
+        if (r.tagName.toLowerCase() === "tr") rows.push(r);
+      }
+    }
+  }
+  return rows;
+}
+function parseWordListLevel(styleAttr) {
+  const m = /mso-list\s*:\s*l\d+\s+level(\d+)/i.exec(styleAttr);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  const fromLevelN = Number.isFinite(n) ? Math.max(0, n - 1) : 0;
+  const fromMargin = wordListLevelFromMarginLeft(marginLeftPt(styleAttr));
+  return clampLevel(Math.max(fromLevelN, fromMargin));
+}
+function marginLeftPt(styleAttr) {
+  const raw = parseStyle(styleAttr)["margin-left"];
+  if (!raw) return 0;
+  const m = /^(-?[\d.]+)\s*(pt|cm|in|px)$/i.exec(raw.trim());
+  if (!m) return 0;
+  const val = Number.parseFloat(m[1]);
+  if (!Number.isFinite(val) || val < 0) return 0;
+  switch (m[2].toLowerCase()) {
+    case "pt":
+      return val;
+    case "cm":
+      return val * 28.3465;
+    case "in":
+      return val * 72;
+    case "px":
+      return val * 0.75;
+    default:
+      return 0;
+  }
+}
+function wordListLevelFromMarginLeft(pt) {
+  if (pt <= 0) return 0;
+  return Math.max(0, Math.round(pt / 36) - 1);
+}
+function findWordListMarker(el) {
+  const all = el.querySelectorAll("*");
+  for (const e of Array.from(all)) {
+    const style = (e.getAttribute("style") ?? "").toLowerCase().replace(/\s+/g, "");
+    if (style.includes("mso-list:ignore")) return e;
+  }
+  return null;
+}
+function detectWordListKind(markerEl) {
+  const all = [markerEl, ...Array.from(markerEl.querySelectorAll("*"))];
+  for (const e of all) {
+    const style = (e.getAttribute("style") ?? "").toLowerCase();
+    if (style.includes("symbol") || style.includes("wingdings")) return "bullet";
+  }
+  const text = (markerEl.textContent ?? "").replace(/ /g, " ").trim();
+  if (/^[0-9]+[.)]/.test(text)) return "ordered";
+  if (/^[a-zA-Z][.)]/.test(text)) return "ordered";
+  return "bullet";
+}
+function inlineDeltaFromNodes(nodes, marks) {
+  const ops = [];
+  for (const n of nodes) walkInlineNode(n, marks, ops);
+  return trimEdgeWhitespace(collapseRepeatedSpaces(mergeAdjacentOps(ops)));
+}
+function collapseRepeatedSpaces(ops) {
+  return ops.map(
+    (op) => typeof op.insert === "string" ? { ...op, insert: op.insert.replace(/ {2,}/g, " ") } : op
+  );
+}
+function walkInlineNode(node, marks, ops) {
+  if (node.nodeType === Node.COMMENT_NODE) return;
+  if (node.nodeType === Node.TEXT_NODE) {
+    const text = normalizeWhitespace(node.textContent ?? "");
+    if (text.length > 0) pushOp(ops, text, marks);
+    return;
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) return;
+  const el = node;
+  const tag = el.tagName.toLowerCase();
+  if (IGNORED_TAGS.has(tag) || isNamespacedTag(tag)) return;
+  if (tag === "img") {
+    const op = imageEmbedFromElement(el);
+    if (op) ops.push(op);
+    return;
+  }
+  if (tag === "br") {
+    ops.push({ insert: " " });
+    return;
+  }
+  const styleAttr = (el.getAttribute("style") ?? "").toLowerCase().replace(/\s+/g, "");
+  if (styleAttr.includes("mso-list:ignore")) return;
+  let nextMarks = applyTagMarks(tag, marks);
+  nextMarks = applyStyleMarks(el.getAttribute("style"), nextMarks);
+  if (tag === "a") {
+    const href = el.getAttribute("href");
+    if (href) nextMarks = { ...nextMarks, link: { href } };
+  }
+  for (const child of Array.from(el.childNodes)) walkInlineNode(child, nextMarks, ops);
+}
+var MIN_EMBED_BYTES = 1024;
+function decodedDataUrlByteLength(dataUrl) {
+  const commaIndex = dataUrl.indexOf(",");
+  if (commaIndex === -1) return 0;
+  const meta = dataUrl.slice(0, commaIndex);
+  const payload = dataUrl.slice(commaIndex + 1);
+  if (/;base64$/i.test(meta)) {
+    const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;
+    return Math.max(0, Math.floor(payload.length * 3 / 4) - padding);
+  }
+  try {
+    return decodeURIComponent(payload).length;
+  } catch {
+    return payload.length;
+  }
+}
+function imageEmbedFromElement(el) {
+  const src = el.getAttribute("src");
+  if (!src || !src.startsWith("data:image/")) return null;
+  if (decodedDataUrlByteLength(src) < MIN_EMBED_BYTES) return null;
+  const style = parseStyle(el.getAttribute("style"));
+  const width = readImageDimension(el, "width", style);
+  const height = readImageDimension(el, "height", style);
+  if (width == null || height == null) return null;
+  let w = width;
+  let h = height;
+  if (w > MAX_INSERT_WIDTH) {
+    h = h * MAX_INSERT_WIDTH / w;
+    w = MAX_INSERT_WIDTH;
+  }
+  return { insert: { type: "image", src, width: Math.round(w), height: Math.round(h) } };
+}
+function readImageDimension(el, attr, style) {
+  const raw = el.getAttribute(attr);
+  if (raw && /^\d+(\.\d+)?$/.test(raw.trim())) {
+    const n = Number.parseFloat(raw);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const fromStyle = style[attr];
+  if (fromStyle) {
+    const n = cssLengthToPx(fromStyle);
+    if (n != null) return n;
+  }
+  return void 0;
+}
+function cssLengthToPx(raw) {
+  const v = raw.trim();
+  const m = /^(-?[\d.]+)\s*(px|pt|in|cm|mm)?$/i.exec(v);
+  if (!m) return void 0;
+  const num = Number.parseFloat(m[1]);
+  if (!Number.isFinite(num) || num <= 0) return void 0;
+  const unit = (m[2] ?? "px").toLowerCase();
+  switch (unit) {
+    case "px":
+      return num;
+    case "pt":
+      return num * (96 / 72);
+    case "in":
+      return num * 96;
+    case "cm":
+      return num * (96 / 2.54);
+    case "mm":
+      return num * (96 / 25.4);
+    default:
+      return void 0;
+  }
+}
+function applyTagMarks(tag, marks) {
+  switch (tag) {
+    case "b":
+    case "strong":
+      return { ...marks, bold: true };
+    case "i":
+    case "em":
+      return { ...marks, italic: true };
+    case "u":
+      return { ...marks, underline: true };
+    case "s":
+    case "strike":
+    case "del":
+      return { ...marks, strike: true };
+    default:
+      return marks;
+  }
+}
+function parseStyle(styleAttr) {
+  const out = {};
+  if (!styleAttr) return out;
+  for (const decl of styleAttr.split(";")) {
+    const idx = decl.indexOf(":");
+    if (idx === -1) continue;
+    const prop = decl.slice(0, idx).trim().toLowerCase();
+    const val = decl.slice(idx + 1).trim();
+    if (prop) out[prop] = val;
+  }
+  return out;
+}
+function applyStyleMarks(styleAttr, marks) {
+  const decls = parseStyle(styleAttr);
+  if (Object.keys(decls).length === 0) return marks;
+  const next = { ...marks };
+  if ("font-weight" in decls) {
+    const v = decls["font-weight"].toLowerCase();
+    if (v === "bold" || /^[5-9]00$/.test(v)) next.bold = true;
+    else if (v === "normal" || /^[1-4]00$/.test(v)) delete next.bold;
+  }
+  if ("font-style" in decls) {
+    const v = decls["font-style"].toLowerCase();
+    if (v === "italic" || v === "oblique") next.italic = true;
+    else if (v === "normal") delete next.italic;
+  }
+  const deco = decls["text-decoration-line"] ?? decls["text-decoration"];
+  if (deco !== void 0) {
+    const v = deco.toLowerCase();
+    delete next.underline;
+    delete next.strike;
+    if (v.includes("underline")) next.underline = true;
+    if (v.includes("line-through")) next.strike = true;
+  }
+  if ("color" in decls) {
+    const css = normalizeCssColor(decls.color);
+    if (css && !isBlack(css)) next.color = css;
+    else delete next.color;
+  }
+  const bg = decls["background-color"] ?? decls.background;
+  if (bg !== void 0) {
+    const css = normalizeCssColor(bg);
+    if (css && css !== "#ffffff") next.highlight = css;
+    else delete next.highlight;
+  }
+  if ("font-size" in decls) {
+    const pt = parseFontSizePt(decls["font-size"]);
+    if (pt != null) next.fontSize = formatFontSizePt(pt);
+  }
+  return next;
+}
+function parseFontSizePt(raw) {
+  const v = raw.trim().toLowerCase();
+  const m = /^(-?[\d.]+)\s*(pt|px|in)$/.exec(v);
+  if (!m) return void 0;
+  const num = Number.parseFloat(m[1]);
+  if (!Number.isFinite(num)) return void 0;
+  let pt;
+  switch (m[2]) {
+    case "pt":
+      pt = num;
+      break;
+    case "px":
+      pt = num * 0.75;
+      break;
+    case "in":
+      pt = num * 72;
+      break;
+    default:
+      return void 0;
+  }
+  const rounded = Math.round(pt * 10) / 10;
+  if (rounded <= 0 || rounded > 200) return void 0;
+  return rounded;
+}
+function formatFontSizePt(pt) {
+  const rounded = Math.round(pt * 10) / 10;
+  const str = Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+  return `${str}pt`;
+}
+var NAMED_COLORS = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  gray: "#808080",
+  grey: "#808080",
+  orange: "#ffa500",
+  purple: "#800080"
+};
+function normalizeCssColor(raw) {
+  if (!raw) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (!v || v === "transparent" || v === "none" || v === "inherit" || v === "initial") return void 0;
+  if (v.startsWith("#")) {
+    let hex = v.slice(1);
+    if (hex.length === 3) hex = hex.split("").map((c) => c + c).join("");
+    return /^[0-9a-f]{6}$/.test(hex) ? `#${hex}` : void 0;
+  }
+  const rgbMatch = /^rgba?\(([^)]+)\)$/.exec(v);
+  if (rgbMatch) {
+    const parts = rgbMatch[1].split(",").map((s) => s.trim());
+    if (parts.length < 3) return void 0;
+    const alpha = parts[3] !== void 0 ? Number.parseFloat(parts[3]) : 1;
+    if (alpha === 0) return void 0;
+    const toHex = (n) => {
+      const num = Math.max(0, Math.min(255, Number.parseInt(n, 10) || 0));
+      return num.toString(16).padStart(2, "0");
+    };
+    return `#${toHex(parts[0])}${toHex(parts[1])}${toHex(parts[2])}`;
+  }
+  return NAMED_COLORS[v];
+}
+function isBlack(hex) {
+  return hex.toLowerCase() === "#000000";
+}
+function readAlign(el) {
+  const style = parseStyle(el.getAttribute("style"));
+  const v = style["text-align"];
+  if (!v) return void 0;
+  switch (v.toLowerCase()) {
+    case "left":
+    case "start":
+      return "left";
+    case "center":
+      return "center";
+    case "right":
+    case "end":
+      return "right";
+    case "justify":
+      return "justify";
+    default:
+      return void 0;
+  }
+}
+function clampLevel(n) {
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(import_core.MAX_LIST_LEVEL, Math.trunc(n)));
+}
+function normalizeListLevels(blocks) {
+  let i = 0;
+  while (i < blocks.length) {
+    if (blocks[i].type !== "listItem") {
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    while (j < blocks.length && blocks[j].type === "listItem") j++;
+    if (j - i > 1) {
+      let min = Number.POSITIVE_INFINITY;
+      for (let k = i; k < j; k++) {
+        const lvl = blocks[k].attrs.listLevel ?? 0;
+        if (lvl < min) min = lvl;
+      }
+      if (min > 0) {
+        for (let k = i; k < j; k++) {
+          const lvl = blocks[k].attrs.listLevel ?? 0;
+          blocks[k].attrs.listLevel = clampLevel(lvl - min);
+        }
+      }
+    }
+    i = j;
+  }
+}
+function pushOp(ops, text, marks) {
+  const hasMarks = Object.keys(marks).length > 0;
+  ops.push(hasMarks ? { insert: text, attributes: { ...marks } } : { insert: text });
+}
+function normalizeWhitespace(raw) {
+  return raw.replace(/[ \t\r\n]+/g, " ");
+}
+function trimEdgeWhitespace(ops) {
+  let out = ops;
+  if (out.length > 0 && typeof out[0].insert === "string") {
+    const trimmed = out[0].insert.replace(/^ +/, "");
+    if (trimmed.length === 0) out = out.slice(1);
+    else if (trimmed !== out[0].insert) out = [{ ...out[0], insert: trimmed }, ...out.slice(1)];
+  }
+  if (out.length > 0 && typeof out[out.length - 1].insert === "string") {
+    const last = out[out.length - 1];
+    const trimmed = last.insert.replace(/ +$/, "");
+    if (trimmed.length === 0) out = out.slice(0, -1);
+    else if (trimmed !== last.insert) out = [...out.slice(0, -1), { ...last, insert: trimmed }];
+  }
+  return out;
+}
+function mergeAdjacentOps(ops) {
+  const out = [];
+  for (const op of ops) {
+    const prev = out[out.length - 1];
+    if (prev && typeof prev.insert === "string" && typeof op.insert === "string" && sameMarks(prev.attributes, op.attributes)) {
+      prev.insert = prev.insert + op.insert;
+      continue;
+    }
+    out.push({ ...op });
+  }
+  return out;
+}
+function sameMarks(a, b) {
+  const ak = a ? Object.keys(a).sort() : [];
+  const bk = b ? Object.keys(b).sort() : [];
+  if (ak.length !== bk.length) return false;
+  for (let i = 0; i < ak.length; i++) {
+    if (ak[i] !== bk[i]) return false;
+    const av = a[ak[i]];
+    const bv = b[bk[i]];
+    if (typeof av === "object" && av !== null && typeof bv === "object" && bv !== null) {
+      if (JSON.stringify(av) !== JSON.stringify(bv)) return false;
+    } else if (av !== bv) {
+      return false;
+    }
+  }
+  return true;
+}
+function deltaToText(delta) {
+  let s = "";
+  for (const op of delta) if (typeof op.insert === "string") s += op.insert;
+  return s;
+}
+function makeBlock(type, delta, attrs) {
+  return { type, text: deltaToText(delta), delta, attrs };
+}
+
+// src/pastePlan.ts
+function planPaste(cd) {
+  const raw = cd.getData(import_core2.SOFER_MIME);
+  if (raw) {
+    try {
+      const slice = JSON.parse(raw);
+      if (slice && Array.isArray(slice.blocks)) return { kind: "sofer", slice };
+    } catch {
+    }
+  }
+  const html = cd.getData("text/html");
+  if (html) {
+    const slice = htmlToSlice(html);
+    if (slice) return { kind: "html", slice };
+  }
+  const files = Array.from(cd.files ?? []).filter((f) => f.type.startsWith("image/"));
+  if (files.length > 0) return { kind: "images", files };
+  const text = cd.getData("text/plain");
+  if (text.length > 0) return { kind: "text", text };
+  return { kind: "none" };
+}
+
+// src/resolvePastedImages.ts
+var import_core3 = require("@sofereditor/core");
+function sliceHasDataImageEmbeds(slice) {
+  return slice.blocks.some(
+    (b) => b.delta.some((op) => (0, import_core3.isImageEmbed)(op.insert) && op.insert.src.startsWith("data:image/"))
+  );
+}
+async function resolvePastedImageUploads(slice, upload) {
+  if (!upload) return slice;
+  const blocks = await Promise.all(
+    slice.blocks.map(async (block) => {
+      let changed = false;
+      const delta = await Promise.all(
+        block.delta.map(async (op) => {
+          if (!(0, import_core3.isImageEmbed)(op.insert) || !op.insert.src.startsWith("data:image/")) return op;
+          try {
+            const file = await dataUrlToFile(op.insert.src);
+            const newSrc = await upload(file);
+            changed = true;
+            return { ...op, insert: { ...op.insert, src: newSrc } };
+          } catch (err) {
+            console.error(
+              "[sofereditor] falha ao subir imagem colada para o storage \u2014 mantendo a imagem embutida (data:) nesta colagem",
+              err
+            );
+            return op;
+          }
+        })
+      );
+      return changed ? { ...block, delta } : block;
+    })
+  );
+  return { ...slice, blocks };
+}
+async function dataUrlToFile(dataUrl) {
+  const blob = await fetch(dataUrl).then((r) => r.blob());
+  const mime = blob.type;
+  return new File([blob], `imagem-colada-${Date.now()}.${extensionForMime(mime)}`, { type: mime });
+}
+var MIME_EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/bmp": "bmp",
+  "image/svg+xml": "svg"
+};
+function extensionForMime(mime) {
+  return MIME_EXTENSIONS[mime.toLowerCase()] ?? "png";
+}
+
 // src/BehindImageSelectAffordance.tsx
 var import_react = require("react");
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -645,7 +1386,7 @@ function LinkDialog() {
 
 // src/PageConfigDialog.tsx
 var import_react3 = require("react");
-var import_core = require("@sofereditor/core");
+var import_core4 = require("@sofereditor/core");
 var import_jsx_runtime4 = require("react/jsx-runtime");
 function PageConfigDialog() {
   const { pageConfigRequest, resolvePageConfigRequest, setPageSettings } = useEditorContext();
@@ -679,14 +1420,14 @@ function PageConfigDialog() {
   }, [pageConfigRequest]);
   (0, import_react3.useEffect)(() => {
     if (sizePreset === "custom") return;
-    const p = import_core.PAGE_PRESETS[sizePreset];
-    setWidthMm(roundMm((0, import_core.pxToMm)(p.width)));
-    setHeightMm(roundMm((0, import_core.pxToMm)(p.height)));
+    const p = import_core4.PAGE_PRESETS[sizePreset];
+    setWidthMm(roundMm((0, import_core4.pxToMm)(p.width)));
+    setHeightMm(roundMm((0, import_core4.pxToMm)(p.height)));
   }, [sizePreset]);
   (0, import_react3.useEffect)(() => {
     if (marginPreset === "custom") return;
-    const px = import_core.MARGIN_PRESETS[marginPreset];
-    const mm = roundMm((0, import_core.pxToMm)(px));
+    const px = import_core4.MARGIN_PRESETS[marginPreset];
+    const mm = roundMm((0, import_core4.pxToMm)(px));
     setMarginTopMm(mm);
     setMarginBottomMm(mm);
     setMarginLeftMm(mm);
@@ -695,8 +1436,8 @@ function PageConfigDialog() {
   const customWidth = sizePreset === "custom";
   const previewPx = (0, import_react3.useMemo)(
     () => ({
-      width: Math.round((0, import_core.mmToPx)(widthMm)),
-      height: Math.round((0, import_core.mmToPx)(heightMm))
+      width: Math.round((0, import_core4.mmToPx)(widthMm)),
+      height: Math.round((0, import_core4.mmToPx)(heightMm))
     }),
     [widthMm, heightMm]
   );
@@ -704,12 +1445,12 @@ function PageConfigDialog() {
   const onApply = (e) => {
     e.preventDefault();
     const next = {
-      width: (0, import_core.mmToPx)(widthMm),
-      height: (0, import_core.mmToPx)(heightMm),
-      marginTop: (0, import_core.mmToPx)(marginTopMm),
-      marginBottom: (0, import_core.mmToPx)(marginBottomMm),
-      marginLeft: (0, import_core.mmToPx)(marginLeftMm),
-      marginRight: (0, import_core.mmToPx)(marginRightMm)
+      width: (0, import_core4.mmToPx)(widthMm),
+      height: (0, import_core4.mmToPx)(heightMm),
+      marginTop: (0, import_core4.mmToPx)(marginTopMm),
+      marginBottom: (0, import_core4.mmToPx)(marginBottomMm),
+      marginLeft: (0, import_core4.mmToPx)(marginLeftMm),
+      marginRight: (0, import_core4.mmToPx)(marginRightMm)
     };
     setPageSettings(next);
     resolvePageConfigRequest(true);
@@ -968,14 +1709,14 @@ function roundMm(mm) {
   return Math.round(mm * 10) / 10;
 }
 function hydrateFromSettings(s, setters) {
-  const preset = (0, import_core.detectPreset)(s.width, s.height);
+  const preset = (0, import_core4.detectPreset)(s.width, s.height);
   setters.setSizePreset(preset);
-  setters.setWidthMm(roundMm((0, import_core.pxToMm)(s.width)));
-  setters.setHeightMm(roundMm((0, import_core.pxToMm)(s.height)));
-  const top = roundMm((0, import_core.pxToMm)(s.marginTop));
-  const bottom = roundMm((0, import_core.pxToMm)(s.marginBottom));
-  const left = roundMm((0, import_core.pxToMm)(s.marginLeft));
-  const right = roundMm((0, import_core.pxToMm)(s.marginRight));
+  setters.setWidthMm(roundMm((0, import_core4.pxToMm)(s.width)));
+  setters.setHeightMm(roundMm((0, import_core4.pxToMm)(s.height)));
+  const top = roundMm((0, import_core4.pxToMm)(s.marginTop));
+  const bottom = roundMm((0, import_core4.pxToMm)(s.marginBottom));
+  const left = roundMm((0, import_core4.pxToMm)(s.marginLeft));
+  const right = roundMm((0, import_core4.pxToMm)(s.marginRight));
   setters.setMarginTopMm(top);
   setters.setMarginBottomMm(bottom);
   setters.setMarginLeftMm(left);
@@ -986,7 +1727,7 @@ 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(import_core.MARGIN_PRESETS)) {
+  for (const [name, px] of Object.entries(import_core4.MARGIN_PRESETS)) {
     if (Math.abs(s.marginTop - px) <= TOL) return name;
   }
   return "custom";
@@ -1546,7 +2287,7 @@ function Handle({
 
 // src/RemoteCursorsOverlay.tsx
 var import_react7 = require("react");
-var import_core2 = require("@sofereditor/core");
+var import_core5 = require("@sofereditor/core");
 var import_jsx_runtime8 = require("react/jsx-runtime");
 var DEFAULT_COLOR = "#3b82f6";
 function RemoteCursorsOverlay({
@@ -1569,7 +2310,7 @@ function RemoteCursorsOverlay({
       if (clientId === awareness.clientID) return;
       const s = state;
       if (!s.cursor) return;
-      const sel = (0, import_core2.decodeSelection)(doc, s.cursor);
+      const sel = (0, import_core5.decodeSelection)(doc, s.cursor);
       if (!sel) return;
       const color = s.user?.color || DEFAULT_COLOR;
       const name = s.user?.name || "An\xF4nimo";
@@ -1716,11 +2457,11 @@ function RemoteCursorsOverlay({
 
 // src/NodeView.tsx
 var import_react10 = require("react");
-var import_core4 = require("@sofereditor/core");
+var import_core7 = require("@sofereditor/core");
 
 // src/renderInline.tsx
 var import_react8 = require("react");
-var import_core3 = require("@sofereditor/core");
+var import_core6 = require("@sofereditor/core");
 var import_jsx_runtime9 = require("react/jsx-runtime");
 function renderInline(delta, keyPrefix) {
   if (delta.length === 0 || delta.length === 1 && typeof delta[0].insert === "string" && delta[0].insert === "") {
@@ -1736,7 +2477,7 @@ function renderInline(delta, keyPrefix) {
       const key = `${keyPrefix}-${offset}`;
       body.push(/* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react8.Fragment, { children: wrap(text, op.attributes) }, key));
       offset += text.length;
-    } else if ((0, import_core3.isImageEmbed)(op.insert)) {
+    } else if ((0, import_core6.isImageEmbed)(op.insert)) {
       const key = `${keyPrefix}-${offset}`;
       const layout = op.insert.layout ?? "inline";
       const commentMarkId = op.attributes?.comment?.markId;
@@ -1900,10 +2641,10 @@ function ImageEmbedViewImpl({
   );
 }
 function decorateBlanks(text) {
-  const segs = (0, import_core3.splitUnderscoreRuns)(text);
+  const segs = (0, import_core6.splitUnderscoreRuns)(text);
   if (segs.length === 1 && !segs[0].blank) return text;
   return segs.map(
-    (s, i) => s.blank ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { "data-blank": "true", style: import_core3.BLANK_STYLE, children: s.text }, i) : /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react8.Fragment, { children: s.text }, i)
+    (s, i) => s.blank ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { "data-blank": "true", style: import_core6.BLANK_STYLE, children: s.text }, i) : /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react8.Fragment, { children: s.text }, i)
   );
 }
 function wrap(text, attrs) {
@@ -2101,7 +2842,7 @@ function NodeView({ block, index, children, fragment, tableFragment }) {
   const common = commonBlockProps(block.attrs, index, block.type, fragment);
   switch (block.type) {
     case "heading": {
-      const level = clampLevel(block.attrs.level);
+      const level = clampLevel2(block.attrs.level);
       const Tag = `h${level}`;
       return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
         Tag,
@@ -2162,7 +2903,7 @@ function NodeView({ block, index, children, fragment, tableFragment }) {
 function commonBlockProps(attrs, index, type, fragment) {
   const style = {};
   if (attrs.align) style.textAlign = attrs.align;
-  Object.assign(style, (0, import_core4.answerLineStyle)(attrs) ?? {});
+  Object.assign(style, (0, import_core7.answerLineStyle)(attrs) ?? {});
   const base = {
     "data-block-index": index,
     "data-block-type": type,
@@ -2188,7 +2929,7 @@ function cellStyle(attrs, border) {
   if (attrs?.bgColor) style.backgroundColor = attrs.bgColor;
   return Object.keys(style).length > 0 ? style : void 0;
 }
-function clampLevel(l) {
+function clampLevel2(l) {
   if (l === 2 || l === 3 || l === 4 || l === 5 || l === 6) return l;
   return 1;
 }
@@ -2209,7 +2950,7 @@ function TableView({ block, index, tableFragment }) {
   const rect = (0, import_react10.useMemo)(() => {
     if (editor.selection.anchor.blockIndex !== index) return null;
     if (editor.selection.focus.blockIndex !== index) return null;
-    return (0, import_core4.tableRectSelection)(editor.doc, editor.selection);
+    return (0, import_core7.tableRectSelection)(editor.doc, editor.selection);
   }, [editor.doc, editor.selection, index]);
   return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "ed-table-wrap", children: [
     /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(
@@ -2245,7 +2986,7 @@ function TableView({ block, index, tableFragment }) {
                     cell?.attrs,
                     // rowStart/rowEnd são os limites do FRAGMENTO: numa tabela
                     // quebrada entre páginas, cada página fecha a própria caixa.
-                    (0, import_core4.cellBorderStyle)(
+                    (0, import_core7.cellBorderStyle)(
                       block.attrs.borderPreset,
                       { row: r, col: c, rowspan, colspan, cols, rowStart, rowEnd },
                       "screen",
@@ -2821,14 +3562,13 @@ function shallowEqual(a, b) {
 }
 
 // src/useEditor.ts
-var import_core5 = require("@sofereditor/core");
-var MAX_INSERT_WIDTH = 600;
+var import_core8 = require("@sofereditor/core");
 function useEditor(opts = {}) {
-  const doc = (0, import_react13.useMemo)(() => opts.document ?? new import_core5.EditorDocument(), [opts.document]);
-  const history = (0, import_react13.useMemo)(() => new import_core5.EditorHistory(doc), [doc]);
+  const doc = (0, import_react13.useMemo)(() => opts.document ?? new import_core8.EditorDocument(), [opts.document]);
+  const history = (0, import_react13.useMemo)(() => new import_core8.EditorHistory(doc), [doc]);
   const [snapshot, setSnapshot] = (0, import_react13.useState)(() => doc.toJSON());
   const [selection, setSelectionState] = (0, import_react13.useState)(
-    () => (0, import_core5.collapsedSelection)({ blockIndex: 0, offset: 0 })
+    () => (0, import_core8.collapsedSelection)({ blockIndex: 0, offset: 0 })
   );
   const selectionRef = (0, import_react13.useRef)(selection);
   selectionRef.current = selection;
@@ -2893,7 +3633,7 @@ function useEditor(opts = {}) {
   const isMarkActive = (0, import_react13.useCallback)(
     (name, value) => {
       const sel = selectionRef.current;
-      const { start, end } = (0, import_core5.orderedRange)(sel);
+      const { start, end } = (0, import_core8.orderedRange)(sel);
       if (start.blockIndex === end.blockIndex && start.offset === end.offset) {
         const pending = pendingMarksRef.current[name];
         if (pending !== void 0) {
@@ -2902,7 +3642,7 @@ function useEditor(opts = {}) {
         }
         const yText2 = doc.getBlockText(start.blockIndex);
         if (!yText2 || start.offset === 0) return false;
-        return (0, import_core5.isMarkUniformInRange)(yText2, start.offset - 1, start.offset, name, value);
+        return (0, import_core8.isMarkUniformInRange)(yText2, start.offset - 1, start.offset, name, value);
       }
       if (start.blockIndex !== end.blockIndex) {
         for (let i = start.blockIndex; i <= end.blockIndex; i++) {
@@ -2911,19 +3651,19 @@ function useEditor(opts = {}) {
           const s = i === start.blockIndex ? start.offset : 0;
           const e = i === end.blockIndex ? end.offset : yText2.length;
           if (s >= e) continue;
-          if (!(0, import_core5.isMarkUniformInRange)(yText2, s, e, name, value)) return false;
+          if (!(0, import_core8.isMarkUniformInRange)(yText2, s, e, name, value)) return false;
         }
         return true;
       }
       const yText = doc.getBlockText(start.blockIndex);
       if (!yText) return false;
-      return (0, import_core5.isMarkUniformInRange)(yText, start.offset, end.offset, name, value);
+      return (0, import_core8.isMarkUniformInRange)(yText, start.offset, end.offset, name, value);
     },
     [doc]
   );
   const getActiveMarks = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
-    const { start, end } = (0, import_core5.orderedRange)(sel);
+    const { start, end } = (0, import_core8.orderedRange)(sel);
     if (start.blockIndex !== end.blockIndex) {
       return {};
     }
@@ -2931,14 +3671,14 @@ function useEditor(opts = {}) {
     if (!yText) return {};
     if (start.offset === end.offset) {
       if (start.offset === 0) return {};
-      return (0, import_core5.getMarksInRange)(yText, start.offset - 1, start.offset);
+      return (0, import_core8.getMarksInRange)(yText, start.offset - 1, start.offset);
     }
-    return (0, import_core5.getMarksInRange)(yText, start.offset, end.offset);
+    return (0, import_core8.getMarksInRange)(yText, start.offset, end.offset);
   }, [doc]);
   const toggleMark = (0, import_react13.useCallback)(
     (name, value) => {
       const sel = selectionRef.current;
-      const { start, end } = (0, import_core5.orderedRange)(sel);
+      const { start, end } = (0, import_core8.orderedRange)(sel);
       const isCollapsed = start.blockIndex === end.blockIndex && start.offset === end.offset;
       if (isCollapsed) {
         const next = { ...pendingMarksRef.current };
@@ -2951,39 +3691,39 @@ function useEditor(opts = {}) {
         setPendingMarks(next);
         return;
       }
-      (0, import_core5.toggleMark)(ctxRef.current, name, value);
+      (0, import_core8.toggleMark)(ctxRef.current, name, value);
     },
     [isMarkActive, setPendingMarks]
   );
   const setMark = (0, import_react13.useCallback)(
     (name, value) => {
       const sel = selectionRef.current;
-      const { start, end } = (0, import_core5.orderedRange)(sel);
+      const { start, end } = (0, import_core8.orderedRange)(sel);
       const isCollapsed = start.blockIndex === end.blockIndex && start.offset === end.offset;
       if (isCollapsed) {
         setPendingMarks({ ...pendingMarksRef.current, [name]: value });
         return;
       }
-      (0, import_core5.setMark)(ctxRef.current, name, value);
+      (0, import_core8.setMark)(ctxRef.current, name, value);
     },
     [setPendingMarks]
   );
   const removeMark = (0, import_react13.useCallback)(
     (name) => {
       const sel = selectionRef.current;
-      const { start, end } = (0, import_core5.orderedRange)(sel);
+      const { start, end } = (0, import_core8.orderedRange)(sel);
       const isCollapsed = start.blockIndex === end.blockIndex && start.offset === end.offset;
       if (isCollapsed) {
         setPendingMarks({ ...pendingMarksRef.current, [name]: null });
         return;
       }
-      (0, import_core5.removeMark)(ctxRef.current, name);
+      (0, import_core8.removeMark)(ctxRef.current, name);
     },
     [setPendingMarks]
   );
   const getBlockType = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
-    const { start, end } = (0, import_core5.orderedRange)(sel);
+    const { start, end } = (0, import_core8.orderedRange)(sel);
     const first = doc.getBlockType(start.blockIndex);
     if (first === void 0) return "paragraph";
     for (let i = start.blockIndex + 1; i <= end.blockIndex; i++) {
@@ -2994,7 +3734,7 @@ function useEditor(opts = {}) {
   const getBlockAttr = (0, import_react13.useCallback)(
     (key) => {
       const sel = selectionRef.current;
-      const { start, end } = (0, import_core5.orderedRange)(sel);
+      const { start, end } = (0, import_core8.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];
@@ -3005,19 +3745,19 @@ function useEditor(opts = {}) {
     [doc]
   );
   const setBlockType = (0, import_react13.useCallback)((type, attrs) => {
-    (0, import_core5.setBlockType)(ctxRef.current, type, attrs);
+    (0, import_core8.setBlockType)(ctxRef.current, type, attrs);
   }, []);
   const setBlockAttr = (0, import_react13.useCallback)(
     (key, value) => {
-      (0, import_core5.setBlockAttr)(ctxRef.current, key, value);
+      (0, import_core8.setBlockAttr)(ctxRef.current, key, value);
     },
     []
   );
   const setAlign = (0, import_react13.useCallback)((value) => {
     const sel = selectionRef.current;
     const inCell = sel.focus.cellIndex != null;
-    if (inCell) (0, import_core5.setCellAttr)(ctxRef.current, "align", value);
-    else (0, import_core5.setBlockAttr)(ctxRef.current, "align", value);
+    if (inCell) (0, import_core8.setCellAttr)(ctxRef.current, "align", value);
+    else (0, import_core8.setBlockAttr)(ctxRef.current, "align", value);
   }, []);
   const getAlign = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
@@ -3027,7 +3767,7 @@ function useEditor(opts = {}) {
     return getBlockAttr("align");
   }, [doc, getBlockAttr]);
   const setCellBackground = (0, import_react13.useCallback)((color) => {
-    (0, import_core5.setCellAttr)(ctxRef.current, "bgColor", color);
+    (0, import_core8.setCellAttr)(ctxRef.current, "bgColor", color);
   }, []);
   const getCellBackground = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
@@ -3037,7 +3777,7 @@ function useEditor(opts = {}) {
   const setTableBorderPreset = (0, import_react13.useCallback)((preset) => {
     const sel = selectionRef.current;
     if (!doc.isTable(sel.focus.blockIndex)) return;
-    (0, import_core5.setBlockAttrAtIndex)(ctxRef.current, sel.focus.blockIndex, "borderPreset", preset);
+    (0, import_core8.setBlockAttrAtIndex)(ctxRef.current, sel.focus.blockIndex, "borderPreset", preset);
   }, [doc]);
   const getTableBorderPreset = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
@@ -3047,7 +3787,7 @@ function useEditor(opts = {}) {
   const setTableBorderColor = (0, import_react13.useCallback)((color) => {
     const sel = selectionRef.current;
     if (!doc.isTable(sel.focus.blockIndex)) return;
-    (0, import_core5.setBlockAttrAtIndex)(ctxRef.current, sel.focus.blockIndex, "borderColor", color);
+    (0, import_core8.setBlockAttrAtIndex)(ctxRef.current, sel.focus.blockIndex, "borderColor", color);
   }, [doc]);
   const getTableBorderColor = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
@@ -3057,7 +3797,7 @@ function useEditor(opts = {}) {
   const isListActive = (0, import_react13.useCallback)(
     (kind) => {
       const sel = selectionRef.current;
-      const { start, end } = (0, import_core5.orderedRange)(sel);
+      const { start, end } = (0, import_core8.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;
@@ -3067,112 +3807,112 @@ function useEditor(opts = {}) {
     [doc]
   );
   const toggleList = (0, import_react13.useCallback)((kind) => {
-    (0, import_core5.toggleList)(ctxRef.current, kind);
+    (0, import_core8.toggleList)(ctxRef.current, kind);
   }, []);
   const indentList = (0, import_react13.useCallback)(() => {
-    (0, import_core5.indentList)(ctxRef.current);
+    (0, import_core8.indentList)(ctxRef.current);
   }, []);
   const dedentList = (0, import_react13.useCallback)(() => {
-    (0, import_core5.dedentList)(ctxRef.current);
+    (0, import_core8.dedentList)(ctxRef.current);
   }, []);
   const splitListItem = (0, import_react13.useCallback)(() => {
-    return (0, import_core5.splitListItem)(ctxRef.current);
+    return (0, import_core8.splitListItem)(ctxRef.current);
   }, []);
   const isInTable = (0, import_react13.useCallback)(() => {
     return selectionRef.current.focus.cellIndex != null;
   }, []);
   const getTableLocation = (0, import_react13.useCallback)(() => {
-    return (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    return (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
   }, [doc]);
   const insertTable = (0, import_react13.useCallback)((rows, cols) => {
-    (0, import_core5.insertTable)(ctxRef.current, rows, cols);
+    (0, import_core8.insertTable)(ctxRef.current, rows, cols);
   }, []);
   const insertAnswerLines = (0, import_react13.useCallback)((count, spacing) => {
-    (0, import_core5.insertAnswerLines)(ctxRef.current, count, spacing);
+    (0, import_core8.insertAnswerLines)(ctxRef.current, count, spacing);
   }, []);
   const deleteTable = (0, import_react13.useCallback)((blockIndex) => {
     const idx = blockIndex ?? selectionRef.current.focus.blockIndex;
-    (0, import_core5.deleteTable)(ctxRef.current, idx);
+    (0, import_core8.deleteTable)(ctxRef.current, idx);
   }, []);
   const insertRowAbove = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return;
-    (0, import_core5.insertTableRow)(ctxRef.current, loc.blockIndex, loc.row, "before");
+    (0, import_core8.insertTableRow)(ctxRef.current, loc.blockIndex, loc.row, "before");
   }, [doc]);
   const insertRowBelow = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return;
-    (0, import_core5.insertTableRow)(ctxRef.current, loc.blockIndex, loc.row, "after");
+    (0, import_core8.insertTableRow)(ctxRef.current, loc.blockIndex, loc.row, "after");
   }, [doc]);
   const deleteCurrentRow = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return;
-    (0, import_core5.deleteTableRow)(ctxRef.current, loc.blockIndex, loc.row);
+    (0, import_core8.deleteTableRow)(ctxRef.current, loc.blockIndex, loc.row);
   }, [doc]);
   const insertColumnLeft = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return;
-    (0, import_core5.insertTableColumn)(ctxRef.current, loc.blockIndex, loc.col, "before");
+    (0, import_core8.insertTableColumn)(ctxRef.current, loc.blockIndex, loc.col, "before");
   }, [doc]);
   const insertColumnRight = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return;
-    (0, import_core5.insertTableColumn)(ctxRef.current, loc.blockIndex, loc.col, "after");
+    (0, import_core8.insertTableColumn)(ctxRef.current, loc.blockIndex, loc.col, "after");
   }, [doc]);
   const deleteCurrentColumn = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return;
-    (0, import_core5.deleteTableColumn)(ctxRef.current, loc.blockIndex, loc.col);
+    (0, import_core8.deleteTableColumn)(ctxRef.current, loc.blockIndex, loc.col);
   }, [doc]);
   const moveToNextCell = (0, import_react13.useCallback)(() => {
-    (0, import_core5.moveToNextCell)(ctxRef.current);
+    (0, import_core8.moveToNextCell)(ctxRef.current);
   }, []);
   const moveToPrevCell = (0, import_react13.useCallback)(() => {
-    (0, import_core5.moveToPrevCell)(ctxRef.current);
+    (0, import_core8.moveToPrevCell)(ctxRef.current);
   }, []);
   const mergeRight = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return false;
-    return (0, import_core5.mergeRight)(ctxRef.current, loc.blockIndex, loc.row, loc.col);
+    return (0, import_core8.mergeRight)(ctxRef.current, loc.blockIndex, loc.row, loc.col);
   }, [doc]);
   const mergeDown = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return false;
-    return (0, import_core5.mergeDown)(ctxRef.current, loc.blockIndex, loc.row, loc.col);
+    return (0, import_core8.mergeDown)(ctxRef.current, loc.blockIndex, loc.row, loc.col);
   }, [doc]);
   const splitCell = (0, import_react13.useCallback)(() => {
-    const loc = (0, import_core5.tableLocationOf)(doc, selectionRef.current.focus);
+    const loc = (0, import_core8.tableLocationOf)(doc, selectionRef.current.focus);
     if (!loc) return false;
-    return (0, import_core5.splitCell)(ctxRef.current, loc.blockIndex, loc.row, loc.col);
+    return (0, import_core8.splitCell)(ctxRef.current, loc.blockIndex, loc.row, loc.col);
   }, [doc]);
   const setColumnWidth = (0, import_react13.useCallback)(
     (blockIndex, col, widthPx) => {
-      (0, import_core5.setColumnWidth)(ctxRef.current, blockIndex, col, widthPx);
+      (0, import_core8.setColumnWidth)(ctxRef.current, blockIndex, col, widthPx);
     },
     []
   );
   const getTableRect = (0, import_react13.useCallback)(
-    () => (0, import_core5.tableRectSelection)(doc, selectionRef.current),
+    () => (0, import_core8.tableRectSelection)(doc, selectionRef.current),
     [doc]
   );
   const hasTableRectSelection = (0, import_react13.useCallback)(() => {
-    return (0, import_core5.tableRectSelection)(doc, selectionRef.current) !== null;
+    return (0, import_core8.tableRectSelection)(doc, selectionRef.current) !== null;
   }, [doc]);
   const mergeSelection = (0, import_react13.useCallback)(() => {
-    return (0, import_core5.mergeSelection)(ctxRef.current);
+    return (0, import_core8.mergeSelection)(ctxRef.current);
   }, []);
   const insertImage = (0, import_react13.useCallback)((embed) => {
-    (0, import_core5.insertImage)(ctxRef.current, embed);
+    (0, import_core8.insertImage)(ctxRef.current, embed);
   }, []);
   const setImageAttrs = (0, import_react13.useCallback)(
     (blockIndex, offset, partial, cellIndex, newOffset) => {
-      (0, import_core5.setImageAttrs)(ctxRef.current, blockIndex, offset, partial, cellIndex, newOffset);
+      (0, import_core8.setImageAttrs)(ctxRef.current, blockIndex, offset, partial, cellIndex, newOffset);
     },
     []
   );
   const moveEmbedAnchor = (0, import_react13.useCallback)(
     (from, to, newOffsetX, newOffsetY) => {
-      (0, import_core5.moveEmbedAnchor)(ctxRef.current, from, to, newOffsetX, newOffsetY);
+      (0, import_core8.moveEmbedAnchor)(ctxRef.current, from, to, newOffsetX, newOffsetY);
     },
     []
   );
@@ -3190,7 +3930,7 @@ function useEditor(opts = {}) {
     }
     const upload = uploadImageRef.current;
     const src = upload ? await upload(file) : dataUrl;
-    (0, import_core5.insertImage)(ctxRef.current, { type: "image", src, width: w, height: h });
+    (0, import_core8.insertImage)(ctxRef.current, { type: "image", src, width: w, height: h });
   }, []);
   const getSelectedEmbed = (0, import_react13.useCallback)(() => {
     const sel = selectionRef.current;
@@ -3209,7 +3949,7 @@ function useEditor(opts = {}) {
         cursor += op.insert.length;
         continue;
       }
-      if (cursor === start && (0, import_core5.isImageEmbed)(op.insert)) {
+      if (cursor === start && (0, import_core8.isImageEmbed)(op.insert)) {
         return {
           blockIndex: sel.anchor.blockIndex,
           cellIndex: sel.anchor.cellIndex,
@@ -3342,7 +4082,8 @@ function useEditor(opts = {}) {
     resolvePageConfigRequest,
     imageCaptionRequest,
     requestImageCaption,
-    resolveImageCaptionRequest
+    resolveImageCaptionRequest,
+    uploadImage: opts.uploadImage
   };
 }
 function readAsDataURL(file) {
@@ -3389,6 +4130,7 @@ function Editor({
   const { doc, history, snapshot, getSelection, setSelection } = editor;
   const rootRef = (0, import_react14.useRef)(null);
   const isComposingRef = (0, import_react14.useRef)(false);
+  const pasteInFlightRef = (0, import_react14.useRef)(false);
   const [hoveredBehind, setHoveredBehind] = (0, import_react14.useState)(null);
   const hoveredBehindRef = (0, import_react14.useRef)(null);
   const [hoveredLink, setHoveredLink] = (0, import_react14.useState)(null);
@@ -3404,7 +4146,7 @@ function Editor({
       const sel = readDomSelection(root);
       awareness.setLocalStateField(
         "cursor",
-        sel ? (0, import_core6.encodeSelection)(doc, sel) ?? null : null
+        sel ? (0, import_core9.encodeSelection)(doc, sel) ?? null : null
       );
     };
     const onSelChange = () => {
@@ -3705,14 +4447,14 @@ function Editor({
           const data = e.data ?? "";
           if (data.length > 0) {
             e.preventDefault();
-            (0, import_core6.insertText)(ctx, data, ed.consumePendingMarks());
+            (0, import_core9.insertText)(ctx, data, ed.consumePendingMarks());
           }
           return;
         }
         case "insertLineBreak": {
           e.preventDefault();
           if (ed.getBlockType() === "listItem") {
-            (0, import_core6.insertText)(ctx, "\n", ed.consumePendingMarks());
+            (0, import_core9.insertText)(ctx, "\n", ed.consumePendingMarks());
             return;
           }
           const selEmbed = ed.getSelectedEmbed();
@@ -3732,7 +4474,7 @@ function Editor({
             });
           }
           if (ed.splitListItem()) return;
-          (0, import_core6.insertParagraph)(ctx);
+          (0, import_core9.insertParagraph)(ctx);
           return;
         }
         case "insertParagraph": {
@@ -3754,14 +4496,14 @@ function Editor({
             });
           }
           if (ed.splitListItem()) return;
-          (0, import_core6.insertParagraph)(ctx);
+          (0, import_core9.insertParagraph)(ctx);
           return;
         }
         case "insertReplacementText": {
           const text = e.data ?? e.dataTransfer?.getData("text/plain") ?? "";
           if (text.length > 0) {
             e.preventDefault();
-            (0, import_core6.insertText)(ctx, text, ed.consumePendingMarks());
+            (0, import_core9.insertText)(ctx, text, ed.consumePendingMarks());
           }
           return;
         }
@@ -3774,7 +4516,7 @@ function Editor({
         case "deleteSoftLineBackward":
         case "deleteHardLineBackward": {
           e.preventDefault();
-          (0, import_core6.deleteBackward)(ctx);
+          (0, import_core9.deleteBackward)(ctx);
           return;
         }
         case "deleteContentForward":
@@ -3782,7 +4524,7 @@ function Editor({
         case "deleteSoftLineForward":
         case "deleteHardLineForward": {
           e.preventDefault();
-          (0, import_core6.deleteForward)(ctx);
+          (0, import_core9.deleteForward)(ctx);
           return;
         }
         case "historyUndo": {
@@ -3809,10 +4551,10 @@ function Editor({
     if (!root) return;
     const writeSlice = (e) => {
       const ctx = ctxRef.current;
-      const slice = (0, import_core6.serializeSelection)(ctx.doc, ctx.getSelection());
+      const slice = (0, import_core9.serializeSelection)(ctx.doc, ctx.getSelection());
       if (!slice || !e.clipboardData) return false;
-      e.clipboardData.setData(import_core6.SOFER_MIME, JSON.stringify(slice));
-      e.clipboardData.setData("text/plain", (0, import_core6.sliceToText)(slice));
+      e.clipboardData.setData(import_core9.SOFER_MIME, JSON.stringify(slice));
+      e.clipboardData.setData("text/plain", (0, import_core9.sliceToText)(slice));
       return true;
     };
     const onCopy = (e) => {
@@ -3820,40 +4562,73 @@ function Editor({
     };
     const onCut = (e) => {
       e.preventDefault();
-      if (writeSlice(e)) (0, import_core6.deleteSelection)(ctxRef.current);
+      if (writeSlice(e)) (0, import_core9.deleteSelection)(ctxRef.current);
     };
     const onPaste = (e) => {
       const ctx = ctxRef.current;
       const cd = e.clipboardData;
       if (!cd) return;
-      const raw = cd.getData(import_core6.SOFER_MIME);
-      if (raw) {
-        try {
-          const slice = JSON.parse(raw);
-          if (slice && Array.isArray(slice.blocks)) {
-            e.preventDefault();
-            (0, import_core6.insertSlice)(ctx, slice);
+      const plan = planPaste(cd);
+      if (plan.kind === "none") return;
+      e.preventDefault();
+      switch (plan.kind) {
+        case "sofer":
+          (0, import_core9.insertSlice)(ctx, plan.slice);
+          return;
+        case "html": {
+          if (!sliceHasDataImageEmbeds(plan.slice)) {
+            (0, import_core9.insertSlice)(ctx, plan.slice);
             return;
           }
-        } catch {
+          if (pasteInFlightRef.current) {
+            console.warn(
+              "[sofereditor] colagem com imagem ainda subindo \u2014 descartando esta colagem concorrente para n\xE3o corromper a posi\xE7\xE3o de inser\xE7\xE3o"
+            );
+            return;
+          }
+          pasteInFlightRef.current = true;
+          const capturedSelection = ctx.getSelection();
+          void (async () => {
+            try {
+              const resolved = await resolvePastedImageUploads(plan.slice, editorRef.current.uploadImage);
+              const liveSelection = ctxRef.current.getSelection();
+              const userMovedAway = !selectionsEqual(liveSelection, capturedSelection);
+              const { blockIndex, cellIndex } = capturedSelection.focus;
+              const targetText = ctxRef.current.doc.textAt(blockIndex, cellIndex);
+              let insertAt = capturedSelection;
+              if (!targetText) {
+                console.error(
+                  "[sofereditor] bloco de destino da colagem sumiu durante o upload da imagem \u2014 inserindo no fim do documento em vez de descartar a colagem"
+                );
+                const lastIndex = Math.max(0, ctxRef.current.doc.blockCount() - 1);
+                const lastText = ctxRef.current.doc.getBlockText(lastIndex);
+                insertAt = (0, import_core9.collapsedSelection)({ blockIndex: lastIndex, offset: lastText ? lastText.length : 0 });
+              }
+              ctxRef.current.setSelection(insertAt);
+              (0, import_core9.insertSlice)(ctxRef.current, resolved);
+              if (userMovedAway) {
+                ctxRef.current.setSelection(liveSelection);
+              }
+            } finally {
+              pasteInFlightRef.current = false;
+            }
+          })();
+          return;
+        }
+        case "images":
+          void (async () => {
+            for (const f of plan.files) await editorRef.current.insertImageFromFile(f);
+          })();
+          return;
+        case "text": {
+          const lines = plan.text.split(/\r\n|\r|\n/);
+          lines.forEach((line, i) => {
+            if (i > 0) (0, import_core9.insertParagraph)(ctx);
+            if (line.length > 0) (0, import_core9.insertText)(ctx, line);
+          });
+          return;
         }
       }
-      const images = Array.from(cd.files ?? []).filter((f) => f.type.startsWith("image/"));
-      if (images.length > 0) {
-        e.preventDefault();
-        void (async () => {
-          for (const f of images) await editorRef.current.insertImageFromFile(f);
-        })();
-        return;
-      }
-      const text = cd.getData("text/plain");
-      if (text.length === 0) return;
-      e.preventDefault();
-      const lines = text.split(/\r\n|\r|\n/);
-      lines.forEach((line, i) => {
-        if (i > 0) (0, import_core6.insertParagraph)(ctx);
-        if (line.length > 0) (0, import_core6.insertText)(ctx, line);
-      });
     };
     root.addEventListener("copy", onCopy);
     root.addEventListener("cut", onCut);
@@ -3892,6 +4667,17 @@ function Editor({
       }
       return;
     }
+    if (!mod && (e.key === "Backspace" || e.key === "Delete")) {
+      if (isComposingRef.current) return;
+      const direction = e.key === "Backspace" ? "backward" : "forward";
+      const shouldIntercept = ed.getSelectedEmbed() != null || (0, import_core9.isEmbedAdjacentToCaret)(ctxRef.current, direction);
+      if (shouldIntercept) {
+        e.preventDefault();
+        if (direction === "backward") (0, import_core9.deleteBackward)(ctxRef.current);
+        else (0, import_core9.deleteForward)(ctxRef.current);
+      }
+      return;
+    }
     if (!mod) return;
     const key = e.key.toLowerCase();
     if (!e.shiftKey && !e.altKey && key === "z") {
@@ -3944,7 +4730,7 @@ function Editor({
   const onCompositionEnd = (0, import_react14.useCallback)((e) => {
     isComposingRef.current = false;
     if (e.data && e.data.length > 0) {
-      (0, import_core6.insertText)(ctxRef.current, e.data);
+      (0, import_core9.insertText)(ctxRef.current, e.data);
     }
   }, []);
   const topLevels = (0, import_react14.useMemo)(() => groupTopLevels(snapshot.blocks), [snapshot]);
@@ -4108,11 +4894,15 @@ function groupTopLevels(snapshot) {
       const groupStart = i;
       const items = [];
       const kind = block.attrs.listKind === "ordered" ? "ordered" : "bullet";
+      const leaderLevel = clampListLevel2(block.attrs.listLevel);
       const groupStyle = block.attrs.listStyle;
       while (i < snapshot.length) {
         const b = snapshot[i];
         if (b.type !== "listItem") break;
-        if ((b.attrs.listKind ?? "bullet") !== kind) break;
+        const bLevel = clampListLevel2(b.attrs.listLevel);
+        if (bLevel <= leaderLevel && (b.attrs.listKind ?? "bullet") !== kind) {
+          break;
+        }
         if (i > groupStart) {
           if (typeof b.attrs.listStart === "number") break;
           const itemStyle = b.attrs.listStyle;
@@ -4220,7 +5010,7 @@ function buildListTree(items) {
 function renderListTree(tree, top, start, key) {
   const className = `ed-list ed-list-${top.listKind}`;
   const style = top.listStyle ? { listStyleType: top.listStyle } : void 0;
-  const items = tree.map((node) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(NodeView, { block: node.entry.block, index: node.entry.index, children: node.children.length > 0 ? renderNestedListTree(node.children, top.listKind, `nested-${node.entry.index}`) : null }, node.entry.index));
+  const items = tree.map((node) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(NodeView, { block: node.entry.block, index: node.entry.index, children: node.children.length > 0 ? renderNestedListTree(node.children, `nested-${node.entry.index}`) : null }, node.entry.index));
   if (top.listKind === "ordered") {
     return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
       "ol",
@@ -4236,9 +5026,10 @@ function renderListTree(tree, top, start, key) {
   }
   return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("ul", { className, "data-list-kind": "bullet", style, children: items }, key);
 }
-function renderNestedListTree(tree, kind, key) {
+function renderNestedListTree(tree, key) {
+  const kind = tree[0]?.entry.block.attrs.listKind === "ordered" ? "ordered" : "bullet";
   const Tag = kind === "ordered" ? "ol" : "ul";
-  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Tag, { className: `ed-list ed-list-${kind}`, "data-list-kind": kind, children: tree.map((node) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(NodeView, { block: node.entry.block, index: node.entry.index, children: node.children.length > 0 ? renderNestedListTree(node.children, kind, `nested-${node.entry.index}`) : null }, node.entry.index)) }, key);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Tag, { className: `ed-list ed-list-${kind}`, "data-list-kind": kind, children: tree.map((node) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(NodeView, { block: node.entry.block, index: node.entry.index, children: node.children.length > 0 ? renderNestedListTree(node.children, `nested-${node.entry.index}`) : null }, node.entry.index)) }, key);
 }
 function clampListLevel2(l) {
   if (typeof l !== "number" || !Number.isFinite(l)) return 0;
@@ -4267,7 +5058,7 @@ function caretRangeFromPoint(x, y) {
 
 // src/Toolbar.tsx
 var import_react15 = require("react");
-var import_core7 = require("@sofereditor/core");
+var import_core10 = require("@sofereditor/core");
 var import_jsx_runtime13 = require("react/jsx-runtime");
 var FONT_FAMILIES = ["Arial"];
 var FONT_SIZES = ["8pt", "10pt", "11pt", "12pt", "14pt", "16pt", "18pt", "24pt", "32pt", "48pt"];
@@ -4739,7 +5530,7 @@ function AnswerLinesMenu() {
     document.addEventListener("mousedown", onDown);
     return () => document.removeEventListener("mousedown", onDown);
   }, [open]);
-  const clamped = Math.max(1, Math.min(import_core7.ANSWER_LINE_MAX, Math.trunc(count) || 1));
+  const clamped = Math.max(1, Math.min(import_core10.ANSWER_LINE_MAX, Math.trunc(count) || 1));
   return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { ref: rootRef, className: "ed-toolbar-tablemenu", children: [
     /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
       "button",
@@ -4772,7 +5563,7 @@ function AnswerLinesMenu() {
               {
                 type: "number",
                 min: 1,
-                max: import_core7.ANSWER_LINE_MAX,
+                max: import_core10.ANSWER_LINE_MAX,
                 value: count,
                 onChange: (e) => setCount(Number(e.target.value)),
                 "aria-label": "Quantidade de linhas"
@@ -4965,7 +5756,7 @@ function TableMenu() {
                 {
                   className: "ed-toolbar-swatch",
                   "aria-hidden": true,
-                  style: { background: editor.getTableBorderColor() ?? import_core7.TABLE_BORDER_COLOR }
+                  style: { background: editor.getTableBorderColor() ?? import_core10.TABLE_BORDER_COLOR }
                 }
               ),
               "Cor da borda",
@@ -4973,7 +5764,7 @@ function TableMenu() {
                 "input",
                 {
                   type: "color",
-                  value: editor.getTableBorderColor() ?? import_core7.TABLE_BORDER_COLOR,
+                  value: editor.getTableBorderColor() ?? import_core10.TABLE_BORDER_COLOR,
                   onChange: (e) => editor.setTableBorderColor(e.target.value),
                   "aria-label": "Cor da borda"
                 }
@@ -5095,6 +5886,7 @@ function MarkButton({ title, pressed, onClick, children }) {
   getBlockElement,
   getCellElement,
   getFragmentForOffset,
+  htmlToSlice,
   isTableRectSelection,
   locatePoint,
   readDomSelection,