@sofereditor/react 0.5.0 → 0.7.0

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   useState as useState10
 } from "react";
 import {
+  collapsedSelection as collapsedSelection2,
   deleteBackward,
   deleteForward,
   deleteSelection,
@@ -15,9 +16,10 @@ import {
   insertParagraph,
   insertSlice,
   insertText,
+  isEmbedAdjacentToCaret,
   serializeSelection,
   sliceToText,
-  SOFER_MIME
+  SOFER_MIME as SOFER_MIME2
 } from "@sofereditor/core";
 
 // src/dom-bridge.ts
@@ -293,6 +295,746 @@ function applyDomSelection(root, modelSel) {
   }
 }
 
+// src/pastePlan.ts
+import { SOFER_MIME } from "@sofereditor/core";
+
+// src/htmlToSlice.ts
+import { isImageEmbed, MAX_LIST_LEVEL } from "@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) => 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(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(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
+import { isImageEmbed as isImageEmbed2 } from "@sofereditor/core";
+function sliceHasDataImageEmbeds(slice) {
+  return slice.blocks.some(
+    (b) => b.delta.some((op) => isImageEmbed2(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 (!isImageEmbed2(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
 import {
   useCallback,
@@ -1718,7 +2460,7 @@ import {
 import { Fragment as Fragment3, memo } from "react";
 import {
   BLANK_STYLE,
-  isImageEmbed,
+  isImageEmbed as isImageEmbed3,
   splitUnderscoreRuns
 } from "@sofereditor/core";
 import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
@@ -1736,7 +2478,7 @@ function renderInline(delta, keyPrefix) {
       const key = `${keyPrefix}-${offset}`;
       body.push(/* @__PURE__ */ jsx9(Fragment3, { children: wrap(text, op.attributes) }, key));
       offset += text.length;
-    } else if (isImageEmbed(op.insert)) {
+    } else if (isImageEmbed3(op.insert)) {
       const key = `${keyPrefix}-${offset}`;
       const layout = op.insert.layout ?? "inline";
       const commentMarkId = op.attributes?.comment?.markId;
@@ -2107,7 +2849,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__ */ jsx11(
         Tag,
@@ -2194,7 +2936,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;
 }
@@ -2851,7 +3593,7 @@ import {
   insertTable as cmdInsertTable,
   insertTableColumn as cmdInsertColumn,
   insertTableRow as cmdInsertRow,
-  isImageEmbed as isImageEmbed2,
+  isImageEmbed as isImageEmbed4,
   isMarkUniformInRange,
   moveToNextCell as cmdMoveNextCell,
   moveToPrevCell as cmdMovePrevCell,
@@ -2866,7 +3608,6 @@ import {
   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]);
@@ -3253,7 +3994,7 @@ function useEditor(opts = {}) {
         cursor += op.insert.length;
         continue;
       }
-      if (cursor === start && isImageEmbed2(op.insert)) {
+      if (cursor === start && isImageEmbed4(op.insert)) {
         return {
           blockIndex: sel.anchor.blockIndex,
           cellIndex: sel.anchor.cellIndex,
@@ -3386,7 +4127,8 @@ function useEditor(opts = {}) {
     resolvePageConfigRequest,
     imageCaptionRequest,
     requestImageCaption,
-    resolveImageCaptionRequest
+    resolveImageCaptionRequest,
+    uploadImage: opts.uploadImage
   };
 }
 function readAsDataURL(file) {
@@ -3433,6 +4175,7 @@ function Editor({
   const { doc, history, snapshot, getSelection, setSelection } = editor;
   const rootRef = useRef11(null);
   const isComposingRef = useRef11(false);
+  const pasteInFlightRef = useRef11(false);
   const [hoveredBehind, setHoveredBehind] = useState10(null);
   const hoveredBehindRef = useRef11(null);
   const [hoveredLink, setHoveredLink] = useState10(null);
@@ -3855,7 +4598,7 @@ function Editor({
       const ctx = ctxRef.current;
       const slice = serializeSelection(ctx.doc, ctx.getSelection());
       if (!slice || !e.clipboardData) return false;
-      e.clipboardData.setData(SOFER_MIME, JSON.stringify(slice));
+      e.clipboardData.setData(SOFER_MIME2, JSON.stringify(slice));
       e.clipboardData.setData("text/plain", sliceToText(slice));
       return true;
     };
@@ -3870,34 +4613,67 @@ function Editor({
       const ctx = ctxRef.current;
       const cd = e.clipboardData;
       if (!cd) return;
-      const raw = cd.getData(SOFER_MIME);
-      if (raw) {
-        try {
-          const slice = JSON.parse(raw);
-          if (slice && Array.isArray(slice.blocks)) {
-            e.preventDefault();
-            insertSlice(ctx, slice);
+      const plan = planPaste(cd);
+      if (plan.kind === "none") return;
+      e.preventDefault();
+      switch (plan.kind) {
+        case "sofer":
+          insertSlice(ctx, plan.slice);
+          return;
+        case "html": {
+          if (!sliceHasDataImageEmbeds(plan.slice)) {
+            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 = collapsedSelection2({ blockIndex: lastIndex, offset: lastText ? lastText.length : 0 });
+              }
+              ctxRef.current.setSelection(insertAt);
+              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) insertParagraph(ctx);
+            if (line.length > 0) 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) insertParagraph(ctx);
-        if (line.length > 0) insertText(ctx, line);
-      });
     };
     root.addEventListener("copy", onCopy);
     root.addEventListener("cut", onCut);
@@ -3936,6 +4712,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 || isEmbedAdjacentToCaret(ctxRef.current, direction);
+      if (shouldIntercept) {
+        e.preventDefault();
+        if (direction === "backward") deleteBackward(ctxRef.current);
+        else deleteForward(ctxRef.current);
+      }
+      return;
+    }
     if (!mod) return;
     const key = e.key.toLowerCase();
     if (!e.shiftKey && !e.altKey && key === "z") {
@@ -4152,11 +4939,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;
@@ -4264,7 +5055,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__ */ jsx12(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__ */ jsx12(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__ */ jsx12(
       "ol",
@@ -4280,9 +5071,10 @@ function renderListTree(tree, top, start, key) {
   }
   return /* @__PURE__ */ jsx12("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__ */ jsx12(Tag, { className: `ed-list ed-list-${kind}`, "data-list-kind": kind, children: tree.map((node) => /* @__PURE__ */ jsx12(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__ */ jsx12(Tag, { className: `ed-list ed-list-${kind}`, "data-list-kind": kind, children: tree.map((node) => /* @__PURE__ */ jsx12(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;
@@ -5143,6 +5935,7 @@ export {
   getBlockElement,
   getCellElement,
   getFragmentForOffset,
+  htmlToSlice,
   isTableRectSelection,
   locatePoint,
   readDomSelection,