@meistrari/minuta-editor 1.0.0

package/dist/chunks/docxExport.mjs

@@ -0,0 +1,1282 @@
+import { f as footnoteHtmlToRuns, p as pocLoneCellIndex } from '../shared/minuta-editor.b2512170.mjs';
+import { BorderStyle, TextRun, ExternalHyperlink, Paragraph, Document, Header, Packer, AlignmentType, PageBreak, LineRuleType, Table, TableRow, TableCell, WidthType, TableLayoutType, Footer, FootnoteReferenceRun, VerticalAlign, ImageRun, HorizontalPositionRelativeFrom, VerticalPositionRelativeFrom, TextWrappingType, FrameAnchorType, PageNumber, HeadingLevel } from 'docx';
+import '@tiptap/pm/state';
+import '@tiptap/pm/view';
+
+const A4 = { width: 11906, height: 16838 };
+const PX_TO_TWIP = 15;
+const PX_PER_PT = 96 / 72;
+function getProp(style, prop) {
+  if (!style)
+    return void 0;
+  const match = style.match(new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i"));
+  return match?.[1]?.trim();
+}
+function cssColorToHex(value) {
+  if (!value)
+    return void 0;
+  if (value.startsWith("#"))
+    return value.length === 4 ? value.slice(1).split("").map((c) => c + c).join("") : value.slice(1);
+  const rgb = value.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+  if (rgb) {
+    if (rgb[4] !== void 0 && Number.parseFloat(rgb[4]) === 0)
+      return void 0;
+    return [rgb[1], rgb[2], rgb[3]].map((n) => Number(n).toString(16).padStart(2, "0")).join("");
+  }
+  return void 0;
+}
+function cssLengthToTwips(value) {
+  if (!value)
+    return void 0;
+  const num = Number.parseFloat(value);
+  if (!Number.isFinite(num))
+    return void 0;
+  if (value.endsWith("cm"))
+    return Math.round(num * 567);
+  if (value.endsWith("pt"))
+    return Math.round(num * 20);
+  if (value.endsWith("rem"))
+    return Math.round(num * 16 * PX_TO_TWIP);
+  if (value.endsWith("px"))
+    return Math.round(num * PX_TO_TWIP);
+  return void 0;
+}
+function cssSizeToHalfPoints(value) {
+  if (!value)
+    return void 0;
+  const num = Number.parseFloat(value);
+  if (!Number.isFinite(num))
+    return void 0;
+  if (value.endsWith("pt"))
+    return Math.round(num * 2);
+  if (value.endsWith("px"))
+    return Math.round(num / PX_PER_PT * 2);
+  return void 0;
+}
+function parseStyle(style) {
+  const info = {};
+  const weight = getProp(style, "font-weight");
+  if (weight && (weight === "bold" || Number.parseInt(weight) >= 600))
+    info.bold = true;
+  if (getProp(style, "font-style")?.includes("italic"))
+    info.italics = true;
+  const deco = getProp(style, "text-decoration");
+  if (deco?.includes("underline"))
+    info.underline = true;
+  if (deco?.includes("line-through"))
+    info.strike = true;
+  info.color = cssColorToHex(getProp(style, "color"));
+  const bg = cssColorToHex(getProp(style, "background-color"));
+  if (bg && bg.toLowerCase() !== "ffffff")
+    info.highlight = bg;
+  info.size = cssSizeToHalfPoints(getProp(style, "font-size"));
+  const family = getProp(style, "font-family");
+  if (family)
+    info.font = family.split(",")[0].trim().replace(/["']/g, "");
+  return info;
+}
+function cssAlignToDocx(align) {
+  switch (align) {
+    case "center":
+      return AlignmentType.CENTER;
+    case "right":
+      return AlignmentType.RIGHT;
+    case "justify":
+      return AlignmentType.JUSTIFIED;
+    case "left":
+      return AlignmentType.LEFT;
+    default:
+      return void 0;
+  }
+}
+function parseAlignment(style) {
+  return cssAlignToDocx(getProp(style, "text-align"));
+}
+function domAt(ctx, pos) {
+  try {
+    const dom = ctx.view.nodeDOM(pos);
+    return dom instanceof HTMLElement ? dom : null;
+  } catch {
+    return null;
+  }
+}
+function measureEl(el) {
+  const cs = getComputedStyle(el);
+  const fontPx = Number.parseFloat(cs.fontSize) || 16;
+  const lineHpx = cs.lineHeight === "normal" ? null : Number.parseFloat(cs.lineHeight);
+  return {
+    el,
+    cs,
+    fontPx,
+    sizeHalf: Math.round(fontPx / PX_PER_PT * 2),
+    // line EXACT MENOR que a fonte CLIPA verticalmente no Word (o preview
+    // deixa o texto transbordar o box; o Word não tem overflow) — ex.: os
+    // títulos de ementa (h3 com line-height 14px e fonte maior).
+    // Piso = 1.0em: protege o caso patológico (0.7em) SEM inflar entrelinha
+    // justa (1.0em, comum em citações) — com 1.15em o export ficava mais
+    // alto que o preview mediu, o conteúdo derramava no Word e a quebra
+    // explícita seguinte abria página quase vazia (TLF ¶36/¶52).
+    lineExactTw: lineHpx && Number.isFinite(lineHpx) ? Math.round(Math.max(lineHpx, fontPx) * PX_TO_TWIP) : null,
+    afterTw: Math.round((Number.parseFloat(cs.marginBottom) || 0) * PX_TO_TWIP),
+    beforeTw: Math.round((Number.parseFloat(cs.marginTop) || 0) * PX_TO_TWIP),
+    marginLeftTw: Math.round((Number.parseFloat(cs.marginLeft) || 0) * PX_TO_TWIP),
+    color: cssColorToHex(cs.color),
+    bold: (Number.parseInt(cs.fontWeight) || 400) >= 600,
+    italics: cs.fontStyle.includes("italic"),
+    align: cssAlignToDocx(cs.textAlign)
+  };
+}
+function measureAt(ctx, pos) {
+  const el = domAt(ctx, pos);
+  return el ? measureEl(el) : null;
+}
+function cleanUndefined(obj) {
+  const out = {};
+  for (const key of Object.keys(obj)) {
+    if (obj[key] !== void 0)
+      out[key] = obj[key];
+  }
+  return out;
+}
+const TRACKING_COMPENSATION_TW = -4;
+function runOptions(info) {
+  return {
+    bold: info.bold,
+    italics: info.italics,
+    underline: info.underline ? {} : void 0,
+    strike: info.strike,
+    color: info.color,
+    size: info.size,
+    font: info.font,
+    shading: info.highlight ? { fill: info.highlight } : void 0,
+    characterSpacing: TRACKING_COMPENSATION_TW + (info.trackingTw ?? 0)
+  };
+}
+let measureCanvas2d = null;
+function measureTextPx(text, font) {
+  if (!measureCanvas2d)
+    measureCanvas2d = document.createElement("canvas").getContext("2d");
+  if (!measureCanvas2d)
+    return 0;
+  measureCanvas2d.font = font;
+  return measureCanvas2d.measureText(text).width;
+}
+function primaryFont(cs) {
+  const family = cs.fontFamily?.split(",")[0]?.trim().replace(/["']/g, "");
+  return family || void 0;
+}
+function inlineToRuns(node, base, ctx) {
+  const runs = [];
+  node.forEach((child) => {
+    if (child.type.name === "footnoteRef") {
+      const text2 = String(child.attrs.text ?? "").trim();
+      if (ctx && text2) {
+        ctx.footnotes.push({ html: text2, sizePt: child.attrs.size ?? null });
+        runs.push(new FootnoteReferenceRun(ctx.footnotes.length));
+      } else if (child.attrs.number) {
+        runs.push(new TextRun({ text: `[${child.attrs.number}]`, ...runOptions(base) }));
+      }
+      return;
+    }
+    if (child.type.name === "templateVariable") {
+      const label = child.attrs.label || child.attrs.varKey || "";
+      if (label)
+        runs.push(new TextRun({ text: `[${label}]`, ...runOptions(base) }));
+      return;
+    }
+    if (child.type.name === "variableChip") {
+      if (child.attrs.text)
+        runs.push(new TextRun({ text: child.attrs.text, ...runOptions(base) }));
+      return;
+    }
+    if (child.type.name === "hardBreak") {
+      runs.push(new TextRun({ break: 1 }));
+      return;
+    }
+    if (!child.isText || !child.text)
+      return;
+    const info = { ...base };
+    let text = child.text;
+    for (const mark of child.marks) {
+      if (mark.type.name === "bold")
+        info.bold = true;
+      if (mark.type.name === "italic")
+        info.italics = true;
+      if (mark.type.name === "underline")
+        info.underline = true;
+      if (mark.type.name === "strike")
+        info.strike = true;
+      if (mark.type.name === "inlineStyle") {
+        Object.assign(info, cleanUndefined(parseStyle(mark.attrs.style)));
+        const mr = Number.parseFloat(getProp(mark.attrs.style, "margin-right") ?? "");
+        if (Number.isFinite(mr) && mr > 0 && !text.endsWith(" "))
+          text = `${text} `;
+        const ml = Number.parseFloat(getProp(mark.attrs.style, "margin-left") ?? "");
+        if (Number.isFinite(ml) && ml > 0 && !text.startsWith(" "))
+          text = ` ${text}`;
+      }
+    }
+    runs.push(new TextRun({ text, ...runOptions(info) }));
+  });
+  return runs;
+}
+function domInlineToRuns(root, fallback = {}) {
+  const runs = [];
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  while (true) {
+    const node = walker.nextNode();
+    if (!node)
+      break;
+    const text = node.textContent || "";
+    if (!text.trim().length && !text.includes(" "))
+      continue;
+    const parent = node.parentElement;
+    if (!parent)
+      continue;
+    const cs = getComputedStyle(parent);
+    runs.push(new TextRun({
+      text,
+      // sem rFonts o run cai no default Arial do Document — a fonte
+      // REAL do preview (ex.: Calibri do TLF) tem que viajar no run
+      font: primaryFont(cs) ?? fallback.font,
+      size: Math.round((Number.parseFloat(cs.fontSize) || 16) / PX_PER_PT * 2),
+      color: cssColorToHex(cs.color) ?? fallback.color,
+      bold: (Number.parseInt(cs.fontWeight) || 400) >= 600 || void 0,
+      italics: cs.fontStyle.includes("italic") || void 0,
+      underline: cs.textDecorationLine?.includes("underline") ? {} : void 0,
+      strike: cs.textDecorationLine?.includes("line-through") || void 0,
+      characterSpacing: TRACKING_COMPENSATION_TW
+    }));
+  }
+  return runs;
+}
+function headingLevelFor(level) {
+  return [HeadingLevel.HEADING_1, HeadingLevel.HEADING_2, HeadingLevel.HEADING_3, HeadingLevel.HEADING_4, HeadingLevel.HEADING_5, HeadingLevel.HEADING_6][level - 1];
+}
+function consumeBreak(ctx) {
+  if (ctx.pending.breakBefore) {
+    ctx.pending.breakBefore = false;
+    return true;
+  }
+  return false;
+}
+function tinyBreakParagraph() {
+  return new Paragraph({
+    children: [],
+    pageBreakBefore: true,
+    spacing: { after: 0, before: 0, line: 20, lineRule: LineRuleType.EXACT }
+  });
+}
+function spacingFrom(m, style) {
+  if (m) {
+    const spacing2 = { after: m.afterTw, before: m.beforeTw };
+    if (m.lineExactTw) {
+      spacing2.line = m.lineExactTw;
+      spacing2.lineRule = LineRuleType.EXACT;
+    }
+    return spacing2;
+  }
+  const spacing = { after: 160, line: 276 };
+  const mb = getProp(style, "margin-bottom");
+  if (mb?.endsWith("px"))
+    spacing.after = Math.round(Number.parseFloat(mb) * PX_TO_TWIP);
+  else if (mb?.endsWith("pt"))
+    spacing.after = Math.round(Number.parseFloat(mb) * 20);
+  const mt = getProp(style, "margin-top");
+  if (mt?.endsWith("px"))
+    spacing.before = Math.round(Number.parseFloat(mt) * PX_TO_TWIP);
+  const lh = getProp(style, "line-height");
+  if (lh) {
+    const num = Number.parseFloat(lh);
+    if (Number.isFinite(num) && !lh.endsWith("px"))
+      spacing.line = Math.round(num * 240);
+  }
+  return spacing;
+}
+function textBlockToParagraph(node, pos, ctx, opts = {}) {
+  const m = measureAt(ctx, pos);
+  const style = node.attrs.style;
+  const base = m ? { bold: m.bold, italics: m.italics, color: m.color, size: m.sizeHalf, font: primaryFont(m.cs) } : parseStyle(style);
+  if (ctx.extraTrackingTw)
+    base.trackingTw = ctx.extraTrackingTw;
+  const ownIndent = m ? m.marginLeftTw + Math.round((Number.parseFloat(m.cs.paddingLeft) || 0) * PX_TO_TWIP) : cssLengthToTwips(getProp(style, "margin-left")) ?? 0;
+  const total = (ctx.indentLeft ?? 0) + ownIndent;
+  const breakBefore = consumeBreak(ctx);
+  const spacing = spacingFrom(m, style);
+  if (spacing.before && !breakBefore)
+    spacing.before = Math.max(0, spacing.before - ctx.lastAfterTw);
+  ctx.lastAfterTw = spacing.after ?? 0;
+  const runs = inlineToRuns(node, base, ctx);
+  const paragraph = new Paragraph({
+    children: runs,
+    // sem alinhamento explícito, corpo de peça vai justificado (o Word
+    // usaria esquerda e o .docx sairia diferente da praxe e do preview)
+    alignment: m?.align ?? parseAlignment(style) ?? (opts.heading ? void 0 : AlignmentType.JUSTIFIED),
+    spacing,
+    indent: total ? { left: total } : void 0,
+    heading: opts.heading ? headingLevelFor(opts.heading) : void 0,
+    pageBreakBefore: breakBefore
+  });
+  ctx.meta.set(paragraph, { spacer: runs.length === 0 && !opts.heading, breakBefore });
+  return paragraph;
+}
+async function srcToDataUrl(src) {
+  if (src.startsWith("data:"))
+    return src;
+  if (!src.startsWith("blob:") && !src.startsWith("http"))
+    return null;
+  try {
+    const blob = await (await fetch(src)).blob();
+    return await new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(String(reader.result));
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  } catch {
+    return null;
+  }
+}
+async function dataUrlToImageRun(src, widthPx) {
+  const match = src.match(/^data:image\/([\w+.-]+);base64,(.+)$/);
+  if (!match)
+    return null;
+  let [, mime, base64] = match;
+  if (mime === "svg+xml") {
+    try {
+      const png = await rasterizeToPng(src);
+      const m2 = png.match(/^data:image\/(\w+);base64,(.+)$/);
+      if (!m2)
+        return null;
+      mime = m2[1];
+      base64 = m2[2];
+    } catch {
+      return null;
+    }
+  }
+  const bytes = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  const natural = await new Promise((resolve) => {
+    const probe = new Image();
+    probe.onload = () => resolve({ w: probe.naturalWidth || 400, h: probe.naturalHeight || 300 });
+    probe.onerror = () => resolve({ w: 400, h: 300 });
+    probe.src = src;
+  });
+  const height = Math.round(widthPx * (natural.h / natural.w));
+  return new ImageRun({
+    data: bytes,
+    type: mime === "jpeg" ? "jpg" : mime,
+    transformation: { width: Math.round(widthPx), height }
+  });
+}
+function rasterizeToPng(src) {
+  return new Promise((resolve, reject) => {
+    const probe = new Image();
+    probe.onload = () => {
+      const w = probe.naturalWidth || 100;
+      const h = probe.naturalHeight || 100;
+      const canvas = document.createElement("canvas");
+      canvas.width = w * 2;
+      canvas.height = h * 2;
+      canvas.getContext("2d").drawImage(probe, 0, 0, canvas.width, canvas.height);
+      resolve(canvas.toDataURL("image/png"));
+    };
+    probe.onerror = reject;
+    probe.src = src;
+  });
+}
+function islandImageAlignment(islandEl, imgEl) {
+  if (!islandEl || !imgEl)
+    return AlignmentType.CENTER;
+  const left = imgEl.offsetLeft;
+  const right = islandEl.clientWidth - (imgEl.offsetLeft + imgEl.offsetWidth);
+  if (Math.abs(left - right) <= 3)
+    return AlignmentType.CENTER;
+  return left < right ? AlignmentType.LEFT : AlignmentType.RIGHT;
+}
+async function islandToDocx(node, pos, contentWidthPx, ctx) {
+  const html = node.attrs.html || "";
+  const islandEl = domAt(ctx, pos);
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  const el = tpl.content.firstElementChild;
+  if (!el)
+    return [];
+  const tag = el.tagName.toLowerCase();
+  const breakBefore = consumeBreak(ctx);
+  if (tag === "ul" || tag === "ol") {
+    const paragraphs = [];
+    const liveLis = islandEl ? [...islandEl.querySelectorAll(":scope > ul > li, :scope > ol > li, :scope > li")] : [];
+    const parsedLis = [...el.querySelectorAll(":scope > li")];
+    let n = 1;
+    for (let i = 0; i < parsedLis.length; i++) {
+      const live = liveLis[i] ?? null;
+      const source = live ?? parsedLis[i];
+      const m = live ? measureEl(live) : null;
+      const marker = tag === "ol" ? `${n++}. ` : "\u2022  ";
+      const markerColor = m?.color;
+      const runs = live ? domInlineToRuns(live) : [new TextRun({ text: source.textContent?.trim() || "", ...runOptions(parseStyle(source.getAttribute("style"))) })];
+      const indentPx = live && islandEl ? live.offsetLeft : 24;
+      paragraphs.push(new Paragraph({
+        children: [
+          new TextRun({ text: marker, color: markerColor, size: m?.sizeHalf, font: m ? primaryFont(m.cs) : void 0 }),
+          ...runs
+        ],
+        spacing: m ? { after: m.afterTw, before: m.beforeTw, ...m.lineExactTw ? { line: m.lineExactTw, lineRule: LineRuleType.EXACT } : {} } : { after: 80 },
+        indent: { left: Math.round(indentPx * PX_TO_TWIP) },
+        alignment: m?.align,
+        pageBreakBefore: paragraphs.length === 0 && breakBefore
+      }));
+    }
+    if (breakBefore && paragraphs.length)
+      ctx.meta.set(paragraphs[0], { breakBefore: true });
+    return paragraphs;
+  }
+  if (tag === "img" || el.querySelector("img")) {
+    const parsedImg = tag === "img" ? el : el.querySelector("img");
+    const liveImg = islandEl?.querySelector("img");
+    const src = await srcToDataUrl(parsedImg.getAttribute("src") || "");
+    if (!src)
+      return [];
+    const styleW = getProp(parsedImg.getAttribute("style"), "width");
+    const widthPx = Math.min(
+      liveImg?.offsetWidth || (styleW?.endsWith("px") ? Number.parseFloat(styleW) : contentWidthPx),
+      contentWidthPx
+    );
+    const run = await dataUrlToImageRun(src, widthPx);
+    if (!run)
+      return [];
+    const islandM = islandEl ? measureEl(islandEl) : null;
+    const before = breakBefore ? islandM?.beforeTw ?? 0 : Math.max(0, (islandM?.beforeTw ?? 0) - ctx.lastAfterTw);
+    ctx.lastAfterTw = islandM?.afterTw ?? 0;
+    const imgParagraph = new Paragraph({
+      alignment: islandImageAlignment(islandEl, liveImg),
+      children: [run],
+      spacing: { after: islandM?.afterTw ?? 0, before },
+      pageBreakBefore: breakBefore
+    });
+    ctx.meta.set(imgParagraph, { breakBefore });
+    return [imgParagraph];
+  }
+  if (tag === "svg") {
+    const liveSvg = islandEl?.querySelector("svg");
+    const rectW = liveSvg ? liveSvg.getBoundingClientRect().width / zoomFactor(islandEl) : 0;
+    const wAttr = Number.parseFloat(el.getAttribute("width") || "") || 0;
+    const widthPx = Math.min(rectW || wAttr || contentWidthPx, contentWidthPx);
+    try {
+      let svgHtml = html;
+      if (!svgHtml.includes("xmlns"))
+        svgHtml = svgHtml.replace("<svg", '<svg xmlns="http://www.w3.org/2000/svg"');
+      if (liveSvg) {
+        try {
+          const bbox = liveSvg.getBBox();
+          const vb = (el.getAttribute("viewBox") || "").trim().split(/[\s,]+/).map(Number);
+          const declaredH = Number.parseFloat(el.getAttribute("height") || "") || 0;
+          const neededH = Math.ceil(bbox.y + bbox.height) + 2;
+          if (vb.length === 4 && Number.isFinite(vb[3]) && neededH > vb[1] + vb[3]) {
+            const newVbH = neededH - vb[1];
+            const scale = declaredH && vb[3] ? declaredH / vb[3] : 1;
+            svgHtml = svgHtml.replace(/viewBox="[^"]*"/, `viewBox="${vb[0]} ${vb[1]} ${vb[2]} ${newVbH}"`).replace(/height="[^"]*"/, `height="${Math.ceil(newVbH * scale)}"`);
+          } else if (vb.length !== 4 && declaredH && neededH > declaredH) {
+            svgHtml = svgHtml.replace(/height="[^"]*"/, `height="${neededH}"`);
+          }
+        } catch {
+        }
+      }
+      const dataUrl = `data:image/svg+xml;base64,${btoa(unescape(encodeURIComponent(svgHtml)))}`;
+      const run = await dataUrlToImageRun(dataUrl, widthPx);
+      if (!run)
+        return [];
+      const islandM = islandEl ? measureEl(islandEl) : null;
+      const before = breakBefore ? islandM?.beforeTw ?? 0 : Math.max(0, (islandM?.beforeTw ?? 0) - ctx.lastAfterTw);
+      ctx.lastAfterTw = islandM?.afterTw ?? 0;
+      const svgParagraph = new Paragraph({
+        alignment: AlignmentType.CENTER,
+        children: [run],
+        spacing: { after: islandM?.afterTw ?? 0, before },
+        pageBreakBefore: breakBefore
+      });
+      ctx.meta.set(svgParagraph, { breakBefore });
+      return [svgParagraph];
+    } catch {
+      return [];
+    }
+  }
+  const text = el.textContent?.trim();
+  return text ? [new Paragraph({ children: [new TextRun({ text })], pageBreakBefore: breakBefore })] : [];
+}
+function zoomFactor(el) {
+  const sheet = el.closest(".poc-sheet");
+  if (!sheet || !sheet.offsetWidth)
+    return 1;
+  return sheet.getBoundingClientRect().width / sheet.offsetWidth || 1;
+}
+const NO_BORDER = { style: BorderStyle.NONE, size: 0, color: "FFFFFF" };
+const INVISIBLE_BORDERS = { top: NO_BORDER, bottom: NO_BORDER, left: NO_BORDER, right: NO_BORDER, insideHorizontal: NO_BORDER, insideVertical: NO_BORDER };
+function bordersFrom(m, style) {
+  if (m) {
+    const side2 = (w, s, c) => {
+      const px = Number.parseFloat(w);
+      if (!px || s === "none" || s === "hidden")
+        return void 0;
+      return { style: BorderStyle.SINGLE, size: Math.max(2, Math.round(px / PX_PER_PT * 8)), color: cssColorToHex(c) ?? "000000" };
+    };
+    const top = side2(m.cs.borderTopWidth, m.cs.borderTopStyle, m.cs.borderTopColor);
+    const bottom = side2(m.cs.borderBottomWidth, m.cs.borderBottomStyle, m.cs.borderBottomColor);
+    const left = side2(m.cs.borderLeftWidth, m.cs.borderLeftStyle, m.cs.borderLeftColor);
+    const right = side2(m.cs.borderRightWidth, m.cs.borderRightStyle, m.cs.borderRightColor);
+    if (!top && !bottom && !left && !right)
+      return void 0;
+    return {
+      top: top ?? NO_BORDER,
+      bottom: bottom ?? NO_BORDER,
+      left: left ?? NO_BORDER,
+      right: right ?? NO_BORDER
+    };
+  }
+  const border = getProp(style, "border");
+  if (!border)
+    return void 0;
+  const width = border.match(/(\d+(?:\.\d+)?)px/)?.[1];
+  const color = cssColorToHex(border.match(/#[0-9a-f]{3,6}|rgba?\([^)]*\)/i)?.[0] || "");
+  if (border.includes("none") || !width && !color)
+    return void 0;
+  const sz = Math.max(4, Math.round(Number.parseFloat(width || "1") / PX_PER_PT * 8));
+  const side = { style: BorderStyle.SINGLE, size: sz, color: color || "000000" };
+  return { top: side, bottom: side, left: side, right: side };
+}
+async function walkChildren(node, pos, widthPx, ctx) {
+  const out = [];
+  let childPos = pos + 1;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    out.push(...await nodeToDocx(child, childPos, widthPx, ctx));
+    childPos += child.nodeSize;
+  }
+  return out;
+}
+async function flexRowToDocx(node, pos, contentWidthPx, ctx) {
+  const cellsIn = [];
+  let childPos = pos + 1;
+  for (let i = 0; i < node.childCount; i++) {
+    const dom = domAt(ctx, childPos);
+    if (!dom || dom.offsetWidth > 0)
+      cellsIn.push({ node: node.child(i), pos: childPos, dom });
+    childPos += node.child(i).nodeSize;
+  }
+  if (!cellsIn.length)
+    return [];
+  const rowDom = domAt(ctx, pos);
+  const parent = rowDom?.parentElement;
+  const zoom = rowDom ? zoomFactor(rowDom) : 1;
+  const parentRect = parent?.getBoundingClientRect();
+  const columnWidthPx = parent?.clientWidth || contentWidthPx;
+  const rectOf = (el) => el ? el.getBoundingClientRect() : null;
+  const lines = [];
+  for (const cell of cellsIn) {
+    const top = rectOf(cell.dom)?.top ?? 0;
+    const line = lines[lines.length - 1];
+    const lineTop = line ? rectOf(line[0].dom)?.top ?? 0 : 0;
+    if (line && Math.abs(top - lineTop) <= 8 * zoom)
+      line.push(cell);
+    else
+      lines.push([cell]);
+  }
+  const tables = [];
+  for (const line of lines) {
+    const rawPx = line.map((cell) => cell.dom?.offsetWidth || contentWidthPx / line.length);
+    const totalPx = rawPx.reduce((a, b) => a + b, 0);
+    const scale = totalPx > contentWidthPx ? contentWidthPx / totalPx : 1;
+    const cells = [];
+    const widths = [];
+    for (let i = 0; i < line.length; i++) {
+      const cell = line[i];
+      const cellWidthPx = rawPx[i] * scale;
+      widths.push(Math.round(cellWidthPx * PX_TO_TWIP));
+      const cellCs = cell.dom ? getComputedStyle(cell.dom) : null;
+      const cellCtx = { ...ctx, insideCell: true, indentLeft: 0, lastAfterTw: 0, pending: { breakBefore: false } };
+      const cellBorders = bordersFrom(measureAt(ctx, cell.pos), cell.node.attrs.style);
+      const cellBg = cellShading(cellCs);
+      const hoistBox = Boolean(cellBorders || cellBg) && isPlainContainer(cell.node);
+      const children = hoistBox ? await walkChildren(cell.node, cell.pos, cellWidthPx, cellCtx) : await nodeToDocx(cell.node, cell.pos, cellWidthPx, cellCtx);
+      cells.push(new TableCell({
+        children: children.length ? children : [new Paragraph({ children: [] })],
+        width: { size: Math.round(cellWidthPx * PX_TO_TWIP), type: WidthType.DXA },
+        borders: hoistBox && cellBorders || { top: NO_BORDER, bottom: NO_BORDER, left: NO_BORDER, right: NO_BORDER },
+        shading: hoistBox ? cellBg : void 0,
+        // o padding da coluna vira margem de célula (era do container
+        // que deixou de existir ao subir a caixa para cá)
+        margins: hoistBox && cellCs ? {
+          top: Math.round((Number.parseFloat(cellCs.paddingTop) || 0) * PX_TO_TWIP),
+          bottom: Math.round((Number.parseFloat(cellCs.paddingBottom) || 0) * PX_TO_TWIP),
+          left: Math.round((Number.parseFloat(cellCs.paddingLeft) || 0) * PX_TO_TWIP),
+          right: Math.round((Number.parseFloat(cellCs.paddingRight) || 0) * PX_TO_TWIP)
+        } : void 0,
+        verticalAlign: cellCs?.display.includes("flex") && cellCs.flexDirection === "column" && cellCs.justifyContent === "center" ? VerticalAlign.CENTER : void 0
+      }));
+    }
+    let alignment;
+    const firstRect = rectOf(line[0].dom);
+    const lastRect = rectOf(line[line.length - 1].dom);
+    if (firstRect && lastRect && parentRect && scale === 1) {
+      const leftGap = (firstRect.left - parentRect.left) / zoom;
+      const rightGap = columnWidthPx - (lastRect.right - parentRect.left) / zoom;
+      if (leftGap > 8 || rightGap > 8) {
+        alignment = Math.abs(leftGap - rightGap) <= 8 ? AlignmentType.CENTER : leftGap > rightGap + 8 ? AlignmentType.RIGHT : void 0;
+      }
+    }
+    tables.push(new Table({
+      rows: [new TableRow({ children: cells })],
+      width: { size: widths.reduce((a, b) => a + b, 0), type: WidthType.DXA },
+      borders: INVISIBLE_BORDERS,
+      columnWidths: widths,
+      alignment,
+      layout: TableLayoutType.FIXED
+    }));
+  }
+  return tables;
+}
+function isPlainContainer(node) {
+  return node.type.name === "styledDiv" && !isFlexRow(node);
+}
+function cellShading(cs) {
+  const bg = cs ? cssColorToHex(cs.backgroundColor) : null;
+  return bg && bg.toLowerCase() !== "ffffff" ? { fill: bg } : void 0;
+}
+function isFlexRow(node) {
+  if (node.type.name !== "styledDiv")
+    return false;
+  const display = getProp(node.attrs.style, "display");
+  if (display !== "flex" && display !== "table")
+    return false;
+  if (getProp(node.attrs.style, "flex-direction") === "column")
+    return false;
+  return node.childCount > 1;
+}
+async function tableToDocx(node, pos, contentWidthPx, ctx) {
+  const tableDomRaw = domAt(ctx, pos);
+  const tableEl = tableDomRaw?.tagName === "TABLE" ? tableDomRaw : tableDomRaw?.querySelector("table") ?? null;
+  const breakBefore = consumeBreak(ctx);
+  const rows = [];
+  const colWidths = [];
+  let rowPos = pos + 1;
+  for (let r = 0; r < node.childCount; r++) {
+    const rowNode = node.child(r);
+    const cellsOut = [];
+    let cellPos = rowPos + 1;
+    for (let c = 0; c < rowNode.childCount; c++) {
+      const cellNode = rowNode.child(c);
+      const cellM = measureAt(ctx, cellPos);
+      const cellContent = [];
+      let extraTrackingTw = 0;
+      if (cellM?.el) {
+        const innerPx = cellM.el.clientWidth - (Number.parseFloat(cellM.cs.paddingLeft) || 0) - (Number.parseFloat(cellM.cs.paddingRight) || 0);
+        const longest = (cellNode.textContent || "").split(/\s+/).reduce((a, b) => b.length > a.length ? b : a, "");
+        if (longest.length >= 4 && innerPx > 0) {
+          const font = `${cellM.cs.fontWeight} ${cellM.cs.fontSize} ${cellM.cs.fontFamily}`;
+          const projectedPx = measureTextPx(longest, font) * 1.04;
+          if (projectedPx > innerPx) {
+            const deficitPt = (projectedPx - innerPx) / PX_PER_PT;
+            extraTrackingTw = Math.max(-20, -Math.ceil(deficitPt * 20 / longest.length) - 1);
+          }
+        }
+      }
+      const cellCtx = { ...ctx, insideCell: true, indentLeft: 0, lastAfterTw: 0, pending: { breakBefore: false }, extraTrackingTw: extraTrackingTw || void 0 };
+      let childPos = cellPos + 1;
+      for (let k = 0; k < cellNode.childCount; k++) {
+        const child = cellNode.child(k);
+        if (child.isTextblock)
+          cellContent.push(textBlockToParagraph(child, childPos, cellCtx));
+        else
+          cellContent.push(...await nodeToDocx(child, childPos, cellM?.el.clientWidth || contentWidthPx / 2, cellCtx));
+        childPos += child.nodeSize;
+      }
+      if (!cellContent.length)
+        cellContent.push(new Paragraph({ children: [new TextRun({ text: cellNode.textContent || "" })] }));
+      const colspan = cellNode.attrs.colspan > 1 ? cellNode.attrs.colspan : 1;
+      if (r === 0 && cellM?.el) {
+        const per = Math.round(cellM.el.offsetWidth * PX_TO_TWIP / colspan);
+        for (let s = 0; s < colspan; s++)
+          colWidths.push(per);
+      }
+      const bg = cellM ? cssColorToHex(cellM.cs.backgroundColor) : cssColorToHex(getProp(cellNode.attrs.style, "background-color"));
+      cellsOut.push(new TableCell({
+        children: cellContent,
+        width: cellM?.el ? { size: Math.round(cellM.el.offsetWidth * PX_TO_TWIP), type: WidthType.DXA } : void 0,
+        columnSpan: colspan > 1 ? colspan : void 0,
+        rowSpan: cellNode.attrs.rowspan > 1 ? cellNode.attrs.rowspan : void 0,
+        shading: bg && bg.toLowerCase() !== "ffffff" ? { fill: bg } : void 0,
+        borders: bordersFrom(cellM, cellNode.attrs.style),
+        verticalAlign: cellM?.cs.verticalAlign === "middle" ? VerticalAlign.CENTER : void 0,
+        margins: cellM ? {
+          top: Math.round((Number.parseFloat(cellM.cs.paddingTop) || 0) * PX_TO_TWIP),
+          bottom: Math.round((Number.parseFloat(cellM.cs.paddingBottom) || 0) * PX_TO_TWIP),
+          left: Math.round((Number.parseFloat(cellM.cs.paddingLeft) || 0) * PX_TO_TWIP),
+          right: Math.round((Number.parseFloat(cellM.cs.paddingRight) || 0) * PX_TO_TWIP)
+        } : void 0
+      }));
+      cellPos += cellNode.nodeSize;
+    }
+    if (cellsOut.length)
+      rows.push(new TableRow({ children: cellsOut }));
+    rowPos += rowNode.nodeSize;
+  }
+  if (!rows.length)
+    return [];
+  const tableWidthTw = tableEl?.offsetWidth ? Math.round(tableEl.offsetWidth * PX_TO_TWIP) : Math.round(contentWidthPx * PX_TO_TWIP);
+  let nCols = colWidths.length;
+  if (!nCols) {
+    const firstRow = node.child(0);
+    nCols = 0;
+    for (let c = 0; c < firstRow.childCount; c++)
+      nCols += Math.max(1, firstRow.child(c).attrs.colspan || 1);
+    const per = Math.floor(tableWidthTw / Math.max(1, nCols));
+    for (let s = 0; s < nCols; s++)
+      colWidths.push(per);
+  }
+  const tableM = tableEl ? measureEl(tableEl) : null;
+  const out = [];
+  if (breakBefore) {
+    const tiny = tinyBreakParagraph();
+    ctx.meta.set(tiny, { breakBefore: true });
+    out.push(tiny);
+  }
+  out.push(new Table({
+    rows,
+    width: { size: tableWidthTw, type: WidthType.DXA },
+    columnWidths: colWidths,
+    layout: TableLayoutType.FIXED
+  }));
+  if (tableM && tableM.afterTw > 0) {
+    const spacer = new Paragraph({
+      children: [],
+      spacing: { after: 0, before: 0, line: Math.max(20, tableM.afterTw), lineRule: LineRuleType.EXACT }
+    });
+    ctx.meta.set(spacer, { spacer: true });
+    out.push(spacer);
+  }
+  ctx.lastAfterTw = tableM?.afterTw ?? 0;
+  return out;
+}
+async function nodeToDocx(node, pos, contentWidthPx, ctx) {
+  if (ctx.breakSet.has(pos))
+    ctx.pending.breakBefore = true;
+  switch (node.type.name) {
+    case "minutaBlock":
+      return walkChildren(node, pos, contentWidthPx, ctx);
+    case "blockquote": {
+      const m = measureAt(ctx, pos);
+      const styleIndent = m ? m.marginLeftTw : cssLengthToTwips(getProp(node.attrs.style, "margin-left"));
+      const indentLeft = styleIndent ?? Math.round(contentWidthPx * 0.35 * PX_TO_TWIP);
+      const remaining = Math.max(120, m?.el.clientWidth || contentWidthPx - indentLeft / PX_TO_TWIP);
+      return walkChildren(node, pos, remaining, { ...ctx, indentLeft: (ctx.indentLeft ?? 0) + indentLeft });
+    }
+    case "styledDiv": {
+      if (isFlexRow(node)) {
+        const loneIndex = pocLoneCellIndex(node);
+        if (loneIndex != null) {
+          let childPos = pos + 1;
+          for (let i = 0; i < loneIndex; i++)
+            childPos += node.child(i).nodeSize;
+          return nodeToDocx(node.child(loneIndex), childPos, contentWidthPx, ctx);
+        }
+        const rowM = measureAt(ctx, pos);
+        const tables = await flexRowToDocx(node, pos, contentWidthPx, ctx);
+        if (tables.length) {
+          const breakBefore = consumeBreak(ctx);
+          const out2 = [...tables];
+          if (breakBefore) {
+            const tiny = tinyBreakParagraph();
+            ctx.meta.set(tiny, { breakBefore: true });
+            out2.unshift(tiny);
+          }
+          if (rowM && rowM.afterTw > 0) {
+            const spacer = new Paragraph({
+              children: [],
+              spacing: { after: 0, before: 0, line: Math.max(20, rowM.afterTw), lineRule: LineRuleType.EXACT }
+            });
+            ctx.meta.set(spacer, { spacer: true });
+            out2.push(spacer);
+          }
+          ctx.lastAfterTw = rowM?.afterTw ?? 0;
+          return out2;
+        }
+      }
+      const m = measureAt(ctx, pos);
+      const boxBorders = bordersFrom(m, node.attrs.style);
+      const boxBg = m ? cssColorToHex(m.cs.backgroundColor) : cssColorToHex(getProp(node.attrs.style, "background-color"));
+      const padLeftTw = m && !boxBorders ? Math.round((Number.parseFloat(m.cs.paddingLeft) || 0) * PX_TO_TWIP) : 0;
+      const prevIndent = ctx.indentLeft;
+      if (padLeftTw)
+        ctx.indentLeft = (ctx.indentLeft ?? 0) + padLeftTw;
+      const out = await walkChildren(node, pos, m?.el.clientWidth || contentWidthPx, ctx);
+      ctx.indentLeft = prevIndent;
+      if ((boxBorders || boxBg && boxBg.toLowerCase() !== "ffffff") && out.length) {
+        return [new Table({
+          rows: [new TableRow({
+            children: [new TableCell({
+              children: out,
+              borders: boxBorders,
+              shading: boxBg && boxBg.toLowerCase() !== "ffffff" ? { fill: boxBg } : void 0,
+              width: { size: Math.round((m?.el.offsetWidth || contentWidthPx) * PX_TO_TWIP), type: WidthType.DXA }
+            })]
+          })],
+          width: { size: Math.round((m?.el.offsetWidth || contentWidthPx) * PX_TO_TWIP), type: WidthType.DXA },
+          columnWidths: [Math.round((m?.el.offsetWidth || contentWidthPx) * PX_TO_TWIP)],
+          layout: TableLayoutType.FIXED
+        })];
+      }
+      return out;
+    }
+    case "paragraph": {
+      if (node.textContent.trim() === "PAGEBREAK") {
+        if (ctx.breakSet.size)
+          return [];
+        return [new Paragraph({ children: [new PageBreak()] })];
+      }
+      return [textBlockToParagraph(node, pos, ctx)];
+    }
+    case "heading":
+      return [textBlockToParagraph(node, pos, ctx, { heading: node.attrs.level || 2 })];
+    case "htmlIsland":
+      return islandToDocx(node, pos, contentWidthPx, ctx);
+    case "table":
+      return tableToDocx(node, pos, contentWidthPx, ctx);
+    case "missingImage": {
+      const aviso = new Paragraph({
+        children: [new TextRun({
+          text: `A imagem ${node.attrs.variableId ?? ""} est\xE1 faltando`,
+          italics: true,
+          color: "773613"
+        })],
+        alignment: AlignmentType.CENTER,
+        border: {
+          top: { style: BorderStyle.DASHED, size: 4, color: "DF8B0D" },
+          bottom: { style: BorderStyle.DASHED, size: 4, color: "DF8B0D" },
+          left: { style: BorderStyle.DASHED, size: 4, color: "DF8B0D" },
+          right: { style: BorderStyle.DASHED, size: 4, color: "DF8B0D" }
+        },
+        pageBreakBefore: consumeBreak(ctx)
+      });
+      return [aviso];
+    }
+    case "horizontalRule":
+      return [new Paragraph({ children: [], border: { bottom: { style: BorderStyle.SINGLE, size: 4, color: "AAAAAA" } } })];
+    case "bulletList":
+    case "orderedList": {
+      const paragraphs = [];
+      let n = 1;
+      let liPos = pos + 1;
+      for (let i = 0; i < node.childCount; i++) {
+        const li = node.child(i);
+        let childPos = liPos + 1;
+        li.forEach((child) => {
+          if (child.isTextblock) {
+            const m = measureAt(ctx, childPos);
+            const base = m ? { bold: m.bold, italics: m.italics, color: m.color, size: m.sizeHalf } : parseStyle(child.attrs.style);
+            const marker = node.type.name === "orderedList" ? `${n}. ` : "\u2022  ";
+            const liDom = domAt(ctx, liPos);
+            const indentPx = liDom?.offsetLeft ?? 48;
+            const liBreak = consumeBreak(ctx);
+            const liParagraph = new Paragraph({
+              children: [new TextRun({ text: marker, ...runOptions(base) }), ...inlineToRuns(child, base, ctx)],
+              spacing: spacingFrom(m, child.attrs.style),
+              indent: { left: Math.round(indentPx * PX_TO_TWIP) },
+              pageBreakBefore: liBreak
+            });
+            ctx.meta.set(liParagraph, { breakBefore: liBreak });
+            paragraphs.push(liParagraph);
+          }
+          childPos += child.nodeSize;
+        });
+        n++;
+        liPos += li.nodeSize;
+      }
+      return paragraphs;
+    }
+    default: {
+      if (node.isTextblock)
+        return [textBlockToParagraph(node, pos, ctx)];
+      return walkChildren(node, pos, contentWidthPx, ctx);
+    }
+  }
+}
+async function chromeHtmlToRuns(html) {
+  const runs = [];
+  if (!html)
+    return runs;
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  const walker = document.createTreeWalker(tpl.content, NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT);
+  while (true) {
+    const node = walker.nextNode();
+    if (!node)
+      break;
+    if (node.nodeType === Node.TEXT_NODE) {
+      const text = node.textContent || "";
+      if (!text.trim())
+        continue;
+      const closest = (tag) => !!node.parentElement?.closest(tag);
+      runs.push(new TextRun({
+        text,
+        size: 17,
+        // 11px do preview ≈ 8.25pt
+        color: "64748B",
+        bold: closest("b") || closest("strong"),
+        italics: closest("i") || closest("em"),
+        underline: closest("u") ? {} : void 0
+      }));
+    } else if (node instanceof HTMLImageElement) {
+      const src = node.getAttribute("src") || "";
+      const [, mime = "", base64 = ""] = src.match(/^data:image\/(\w+);base64,(.+)$/) || [];
+      if (!base64 || mime === "svg+xml")
+        continue;
+      const style = node.getAttribute("style");
+      const styleW = Number.parseFloat(getProp(style, "width") ?? "");
+      const styleH = Number.parseFloat(getProp(style, "height") ?? "");
+      let width;
+      let height;
+      if (Number.isFinite(styleW) && Number.isFinite(styleH) && styleW > 0 && styleH > 0) {
+        width = Math.round(styleW);
+        height = Math.round(styleH);
+      } else {
+        const dims = await new Promise((resolve) => {
+          const probe = new Image();
+          probe.onload = () => resolve({ w: probe.naturalWidth || 120, h: probe.naturalHeight || 40 });
+          probe.onerror = () => resolve({ w: 120, h: 40 });
+          probe.src = src;
+        });
+        const scale = Math.min(1, 44 / dims.h);
+        width = Math.round(dims.w * scale);
+        height = Math.round(dims.h * scale);
+      }
+      runs.push(new ImageRun({
+        data: Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)),
+        type: mime === "jpeg" ? "jpg" : mime,
+        transformation: { width, height }
+      }));
+    }
+  }
+  return runs;
+}
+const PX_TO_EMU = 9525;
+const A4_PAGE_HEIGHT_PX = 1123;
+function isChromeCanvasHtml(html) {
+  return !!html && html.includes("data-el=");
+}
+function rectToPngDataUrl(widthPx, heightPx, color) {
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.max(2, Math.round(widthPx * 2));
+  canvas.height = Math.max(2, Math.round(heightPx * 2));
+  const ctx2d = canvas.getContext("2d");
+  if (!ctx2d)
+    return null;
+  ctx2d.fillStyle = color || "#000";
+  ctx2d.fillRect(0, 0, canvas.width, canvas.height);
+  return canvas.toDataURL("image/png");
+}
+function styleFontHalfPt(fontSize) {
+  if (!fontSize)
+    return void 0;
+  const num = Number.parseFloat(fontSize);
+  if (!Number.isFinite(num))
+    return void 0;
+  return Math.round(fontSize.endsWith("pt") ? num * 2 : num * 1.5);
+}
+function canvasTextRuns(root) {
+  const firstFamily = (value) => value.split(",")[0]?.replace(/["']/g, "").trim() || void 0;
+  const base = {
+    font: root.style.fontFamily ? firstFamily(root.style.fontFamily) : void 0,
+    size: styleFontHalfPt(root.style.fontSize) ?? 17,
+    color: cssColorToHex(root.style.color) ?? "64748B",
+    bold: root.style.fontWeight === "bold" || Number.parseInt(root.style.fontWeight) >= 600 || void 0,
+    italics: root.style.fontStyle === "italic" || void 0,
+    underline: root.style.textDecoration?.includes("underline") || void 0
+  };
+  const runs = [];
+  const walk = (node, info) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const text = node.textContent ?? "";
+      if (text)
+        runs.push(new TextRun({ text, ...runOptions(info) }));
+      return;
+    }
+    if (!(node instanceof HTMLElement))
+      return;
+    if (node.tagName === "BR") {
+      runs.push(new TextRun({ break: 1 }));
+      return;
+    }
+    if (node instanceof HTMLImageElement) {
+      const src = node.getAttribute("src") || "";
+      const match = src.match(/^data:image\/([\w+.-]+);base64,(.+)$/);
+      if (match && match[1] !== "svg+xml") {
+        const w = Number.parseFloat(node.style.width) || node.width || 120;
+        const h = Number.parseFloat(node.style.height) || node.height || 28;
+        runs.push(new ImageRun({
+          data: Uint8Array.from(atob(match[2]), (c) => c.charCodeAt(0)),
+          type: match[1] === "jpeg" ? "jpg" : match[1],
+          transformation: { width: Math.round(w), height: Math.round(h) }
+        }));
+      }
+      return;
+    }
+    const next = { ...info };
+    if (node.tagName === "B" || node.tagName === "STRONG")
+      next.bold = true;
+    if (node.tagName === "I" || node.tagName === "EM")
+      next.italics = true;
+    if (node.tagName === "U")
+      next.underline = true;
+    if (node.style.fontFamily)
+      next.font = firstFamily(node.style.fontFamily);
+    const half = styleFontHalfPt(node.style.fontSize);
+    if (half)
+      next.size = half;
+    const color = cssColorToHex(node.style.color);
+    if (color)
+      next.color = color;
+    if (node.style.fontWeight === "bold" || Number.parseInt(node.style.fontWeight) >= 600)
+      next.bold = true;
+    if ((node.tagName === "DIV" || node.tagName === "P") && runs.length)
+      runs.push(new TextRun({ break: 1 }));
+    node.childNodes.forEach((child) => walk(child, next));
+  };
+  root.childNodes.forEach((child) => walk(child, base));
+  return runs;
+}
+async function chromeCanvasToDocx(html, bandTopPx) {
+  const anchors = [];
+  const frames = [];
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  let zIndex = 0;
+  for (const el of [...tpl.content.children]) {
+    const kind = el.getAttribute("data-el");
+    if (!kind)
+      continue;
+    const left = Number.parseFloat(el.style.left) || 0;
+    const top = Number.parseFloat(el.style.top) || 0;
+    const width = Number.parseFloat(el.style.width) || 0;
+    const height = Number.parseFloat(el.style.height) || 0;
+    if (kind === "img" || kind === "rect") {
+      let src = null;
+      let w = width;
+      let h = height;
+      if (kind === "rect") {
+        w = Math.max(2, width || 100);
+        h = Math.max(2, height || 8);
+        src = rectToPngDataUrl(w, h, el.style.background || el.style.backgroundColor || "#000");
+      } else {
+        src = await srcToDataUrl(el.getAttribute("src") || "");
+        if ((!w || !h) && src) {
+          const dims = await new Promise((resolve) => {
+            const probe = new Image();
+            probe.onload = () => resolve({ w: probe.naturalWidth || 120, h: probe.naturalHeight || 40 });
+            probe.onerror = () => resolve({ w: 120, h: 40 });
+            probe.src = src;
+          });
+          w = w || dims.w;
+          h = h || dims.h;
+        }
+      }
+      const match = src?.match(/^data:image\/([\w+.-]+);base64,(.+)$/);
+      if (!match || match[1] === "svg+xml")
+        continue;
+      anchors.push(new ImageRun({
+        data: Uint8Array.from(atob(match[2]), (c) => c.charCodeAt(0)),
+        type: match[1] === "jpeg" ? "jpg" : match[1],
+        transformation: { width: Math.round(w), height: Math.round(h) },
+        floating: {
+          zIndex: zIndex++,
+          horizontalPosition: { relative: HorizontalPositionRelativeFrom.PAGE, offset: Math.round(left * PX_TO_EMU) },
+          verticalPosition: { relative: VerticalPositionRelativeFrom.PAGE, offset: Math.round((bandTopPx + top) * PX_TO_EMU) },
+          wrap: { type: TextWrappingType.NONE },
+          behindDocument: kind === "rect",
+          allowOverlap: true
+        }
+      }));
+    } else if (kind === "text") {
+      const runs = canvasTextRuns(el);
+      if (!runs.length)
+        continue;
+      const font = `${el.style.fontWeight || "normal"} ${el.style.fontSize || "11px"} ${el.style.fontFamily || "Arial"}`;
+      const longestLinePx = Math.max(24, ...(el.textContent ?? "").split("\n").map((line) => measureTextPx(line, font)));
+      const frameWidthPx = width || Math.min(794 - left, longestLinePx * 1.08 + 8);
+      frames.push(new Paragraph({
+        frame: {
+          type: "absolute",
+          position: {
+            x: Math.round(left * PX_TO_TWIP),
+            y: Math.round((bandTopPx + top) * PX_TO_TWIP)
+          },
+          width: Math.round(frameWidthPx * PX_TO_TWIP),
+          height: Math.round(Math.max(height, 14) * PX_TO_TWIP),
+          anchor: { horizontal: FrameAnchorType.PAGE, vertical: FrameAnchorType.PAGE }
+        },
+        children: runs
+      }));
+    }
+  }
+  return { anchors, frames };
+}
+async function buildLogoRun(logoUrl, marginsPx) {
+  try {
+    const response = await fetch(logoUrl);
+    const buffer = await response.arrayBuffer();
+    const mime = response.headers.get("content-type") || "image/png";
+    const type = mime.includes("jpeg") || mime.includes("jpg") ? "jpg" : "png";
+    const blobUrl = URL.createObjectURL(new Blob([buffer], { type: mime }));
+    const dims = await new Promise((resolve) => {
+      const probe = new Image();
+      probe.onload = () => resolve({ w: probe.naturalWidth || 140, h: probe.naturalHeight || 46 });
+      probe.onerror = () => resolve({ w: 140, h: 46 });
+      probe.src = blobUrl;
+    });
+    URL.revokeObjectURL(blobUrl);
+    const maxH = Math.max(24, marginsPx.top - 36);
+    const scale = Math.min(1, maxH / dims.h);
+    return new ImageRun({
+      data: new Uint8Array(buffer),
+      type,
+      transformation: { width: Math.round(dims.w * scale), height: Math.round(dims.h * scale) }
+    });
+  } catch {
+    return null;
+  }
+}
+async function buildDocxHeader(chrome, marginsPx) {
+  if (!chrome || !chrome.headerText && !chrome.headerLogoUrl)
+    return void 0;
+  if (isChromeCanvasHtml(chrome.headerText)) {
+    const { anchors, frames } = await chromeCanvasToDocx(chrome.headerText, 0);
+    const anchorRuns = [...anchors];
+    if (chrome.headerLogoUrl) {
+      const logo = await buildLogoRun(chrome.headerLogoUrl, marginsPx);
+      if (logo)
+        anchorRuns.unshift(logo);
+    }
+    if (!anchorRuns.length && !frames.length)
+      return void 0;
+    return new Header({ children: [...frames, new Paragraph({ children: anchorRuns })] });
+  }
+  const runs = [];
+  if (chrome.headerLogoUrl) {
+    const logo = await buildLogoRun(chrome.headerLogoUrl, marginsPx);
+    if (logo)
+      runs.push(logo);
+  }
+  runs.push(...await chromeHtmlToRuns(chrome.headerText || ""));
+  if (!runs.length)
+    return void 0;
+  const alignment = chrome.headerPosition === "center" ? AlignmentType.CENTER : chrome.headerPosition === "right" ? AlignmentType.RIGHT : AlignmentType.LEFT;
+  return new Header({ children: [new Paragraph({ children: runs, alignment })] });
+}
+async function buildDocxFooter(chrome, withCustom, marginsPx) {
+  const showPageNumber = chrome?.showPageNumber !== false;
+  const pageNumberParagraph = (extra = [], spacer = false) => new Paragraph({
+    alignment: AlignmentType.RIGHT,
+    children: [
+      ...extra,
+      ...showPageNumber ? [
+        new TextRun({ text: spacer ? "   " : "", size: 17, color: "94A3B8" }),
+        new TextRun({ children: ["P\xE1gina ", PageNumber.CURRENT, " de ", PageNumber.TOTAL_PAGES], size: 17, color: "94A3B8" })
+      ] : []
+    ]
+  });
+  if (withCustom && isChromeCanvasHtml(chrome?.footerText)) {
+    const { anchors, frames } = await chromeCanvasToDocx(chrome.footerText, A4_PAGE_HEIGHT_PX - marginsPx.bottom);
+    return new Footer({ children: [...frames, pageNumberParagraph(anchors)] });
+  }
+  const custom = withCustom ? await chromeHtmlToRuns(chrome?.footerText || "") : [];
+  return new Footer({ children: [pageNumberParagraph(custom, custom.length > 0)] });
+}
+async function pocExportDocx(editor, margins, chrome, options = {}) {
+  const contentWidthPx = 794 - margins.left - margins.right;
+  const doc = editor.state.doc;
+  const ctx = {
+    view: editor.view,
+    // quebras `soft` (dentro de um parágrafo) não viram pageBreakBefore:
+    // partir o parágrafo em dois no Word entregaria ao advogado um arquivo
+    // que não reflui ao editar. Ali o Word quebra sozinho, no mesmo lugar
+    // ou a uma linha de distância.
+    breakSet: new Set((options.breaks ?? []).filter((b) => !b.soft).map((b) => b.pos)),
+    pending: { breakBefore: false },
+    lastAfterTw: 0,
+    meta: /* @__PURE__ */ new WeakMap(),
+    footnotes: []
+  };
+  const children = [];
+  let pos = 0;
+  for (let i = 0; i < doc.childCount; i++) {
+    const child = doc.child(i);
+    children.push(...await nodeToDocx(child, pos, contentWidthPx, ctx));
+    pos += child.nodeSize;
+  }
+  const cleaned = [];
+  for (const el of children) {
+    if (ctx.meta.get(el)?.breakBefore) {
+      while (cleaned.length && ctx.meta.get(cleaned[cleaned.length - 1])?.spacer)
+        cleaned.pop();
+    }
+    cleaned.push(el);
+  }
+  const header = await buildDocxHeader(chrome, margins);
+  const headerFirstOnly = chrome?.headerScope === "first";
+  const footerFirstOnly = chrome?.footerScope === "first";
+  const footerFull = await buildDocxFooter(chrome, true, margins);
+  const footerPlain = footerFirstOnly ? await buildDocxFooter(chrome, false, margins) : footerFull;
+  const useTitlePage = headerFirstOnly || footerFirstOnly;
+  const footnotes = Object.fromEntries(ctx.footnotes.map((note, i) => {
+    const size = Math.round((note.sizePt ?? 8) * 2);
+    const children2 = footnoteHtmlToRuns(note.html).map((run) => {
+      const textRun = new TextRun({
+        text: run.text,
+        bold: run.bold,
+        italics: run.italics,
+        // link herda a cara de link do Word (sublinhado + azul)
+        underline: run.underline || run.href ? {} : void 0,
+        color: run.href ? "0563C1" : run.color,
+        break: run.break ? 1 : void 0,
+        // personalização por trecho vence o corpo base da nota
+        font: run.font,
+        size: run.sizePt ? Math.round(run.sizePt * 2) : size
+      });
+      return run.href ? new ExternalHyperlink({ children: [textRun], link: run.href }) : textRun;
+    });
+    return [String(i + 1), { children: [new Paragraph({ children: children2 })] }];
+  }));
+  const document2 = new Document({
+    styles: {
+      default: {
+        document: { run: { font: "Arial", size: 20 } }
+      }
+    },
+    footnotes: Object.keys(footnotes).length ? footnotes : void 0,
+    sections: [{
+      properties: {
+        page: {
+          size: { width: A4.width, height: A4.height },
+          margin: {
+            top: margins.top * PX_TO_TWIP,
+            right: margins.right * PX_TO_TWIP,
+            bottom: margins.bottom * PX_TO_TWIP,
+            left: margins.left * PX_TO_TWIP,
+            // distâncias de header/footer DENTRO da margem: o default do
+            // Word (708tw = 1,25cm) é MAIOR que margens pequenas (ex.:
+            // 0,5cm) e faz o rodapé "Página N" EMPURRAR o corpo — a
+            // página perde altura e a paginação diverge do preview
+            header: Math.min(708, Math.max(30, margins.top * PX_TO_TWIP - 280)),
+            footer: Math.min(708, Math.max(30, margins.bottom * PX_TO_TWIP - 280))
+          }
+        },
+        titlePage: useTitlePage || void 0
+      },
+      headers: header ? headerFirstOnly ? { first: header, default: new Header({ children: [] }) } : useTitlePage ? { first: header, default: header } : { default: header } : void 0,
+      footers: useTitlePage ? { first: footerFull, default: footerPlain } : { default: footerFull },
+      children: cleaned
+    }]
+  });
+  return Packer.toBlob(document2);
+}
+
+export { pocExportDocx };