@meistrari/minuta-editor 1.0.0

package/dist/shared/minuta-editor.b2512170.mjs

@@ -0,0 +1,711 @@
+import { PluginKey, Plugin } from '@tiptap/pm/state';
+import { Decoration, DecorationSet } from '@tiptap/pm/view';
+
+const BLOCKED_TAGS = /* @__PURE__ */ new Set([
+  "SCRIPT",
+  "STYLE",
+  "IFRAME",
+  "OBJECT",
+  "EMBED",
+  "LINK",
+  "META",
+  "BASE",
+  "FORM",
+  "INPUT",
+  "BUTTON",
+  "TEXTAREA",
+  "SELECT",
+  "TEMPLATE",
+  "DIALOG",
+  // SMIL: anima/troca atributo de outro elemento DEPOIS da sanitização —
+  // <a><animate attributeName="href" to="javascript:…"> devolve o href
+  // proibido no clique, com a URL nunca passando pelo allowlist abaixo
+  "ANIMATE",
+  "ANIMATEMOTION",
+  "ANIMATETRANSFORM",
+  "SET",
+  "DISCARD",
+  // hospedam markup de outro namespace (HTML dentro de SVG, MathML) — o
+  // parser reinterpreta na 2ª passada e é o vetor clássico de mXSS
+  "FOREIGNOBJECT",
+  "ANNOTATION-XML",
+  "NOSCRIPT",
+  "NOEMBED",
+  "NOFRAMES",
+  "XMP",
+  "PLAINTEXT",
+  // <use> puxa e clona um nó por referência (inclusive de fora do documento)
+  "USE"
+]);
+const BLOCKED_ATTRS = /* @__PURE__ */ new Set(["attributename", "attributetype", "to", "values", "from", "by"]);
+const SAFE_URL = /^(?:https?:|data:image\/|blob:|vault:)/i;
+function scrubElement(el) {
+  for (const child of [...el.children]) {
+    if (BLOCKED_TAGS.has(child.tagName.toUpperCase())) {
+      child.remove();
+      continue;
+    }
+    for (const attr of [...child.attributes]) {
+      const name = attr.name.toLowerCase();
+      if (name.startsWith("on")) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if (BLOCKED_ATTRS.has(name)) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if ((name === "src" || name === "href" || name === "xlink:href" || name === "formaction" || name === "srcdoc") && (name === "srcdoc" || !SAFE_URL.test(attr.value.trim()))) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      if (name === "style" && /url\s*\(/i.test(attr.value) && !/url\s*\(\s*['"]?(?:https?:|data:image\/|blob:)/i.test(attr.value)) {
+        child.removeAttribute(attr.name);
+      }
+    }
+    scrubElement(child);
+  }
+}
+function sanitizeRichHtml(html) {
+  if (!html)
+    return "";
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  scrubElement(tpl.content);
+  return tpl.innerHTML;
+}
+
+const INLINE_TAGS = /* @__PURE__ */ new Set(["B", "STRONG", "I", "EM", "U", "SUP", "SUB", "BR"]);
+function safeHref(value) {
+  const href = (value ?? "").trim();
+  return /^https?:\/\//i.test(href) ? href : null;
+}
+function rgbToHex(value) {
+  const match = value.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i);
+  if (!match)
+    return null;
+  return `#${match.slice(1, 4).map((n) => Number(n).toString(16).padStart(2, "0")).join("")}`;
+}
+function safeSpanStyle(style) {
+  if (!style)
+    return null;
+  const out = [];
+  const family = style.match(/font-family\s*:\s*([^;]+)/i)?.[1]?.trim();
+  if (family && /^[\w\s,'"-]+$/.test(family))
+    out.push(`font-family: ${family.replace(/"/g, "'")}`);
+  const size = style.match(/font-size\s*:\s*([\d.]+)\s*pt/i)?.[1];
+  if (size)
+    out.push(`font-size: ${size}pt`);
+  const rawColor = style.match(/(?:^|;)\s*color\s*:\s*([^;]+)/i)?.[1]?.trim();
+  if (rawColor) {
+    const hex = rawColor.startsWith("#") ? /^#[0-9a-f]{6}$/i.test(rawColor) ? rawColor : null : rgbToHex(rawColor);
+    if (hex)
+      out.push(`color: ${hex}`);
+  }
+  return out.length ? out.join("; ") : null;
+}
+function sanitizeFootnoteHtml(html) {
+  if (!html)
+    return "";
+  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, "text/html");
+  const root = doc.body.firstElementChild;
+  if (!root)
+    return "";
+  const walk = (node) => {
+    if (node.nodeType === Node.TEXT_NODE)
+      return (node.textContent ?? "").replace(/[<>&]/g, (c) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;" })[c]);
+    if (!(node instanceof Element))
+      return "";
+    if (node.tagName === "SCRIPT" || node.tagName === "STYLE")
+      return "";
+    const inner = Array.from(node.childNodes).map(walk).join("");
+    if (node.tagName === "BR")
+      return "<br>";
+    if (node.tagName === "A") {
+      const href = safeHref(node.getAttribute("href"));
+      return href ? `<a href="${href.replace(/"/g, "&quot;")}">${inner}</a>` : inner;
+    }
+    if (node.tagName === "SPAN" || node.tagName === "FONT") {
+      const style = safeSpanStyle(node.getAttribute("style"));
+      return style ? `<span style="${style}">${inner}</span>` : inner;
+    }
+    if (node.tagName === "DIV" || node.tagName === "P")
+      return inner ? `${inner}<br>` : "";
+    if (INLINE_TAGS.has(node.tagName))
+      return `<${node.tagName.toLowerCase()}>${inner}</${node.tagName.toLowerCase()}>`;
+    return inner;
+  };
+  return Array.from(root.childNodes).map(walk).join("").replace(/\s+/g, " ").replace(/(<br>\s*)+$/i, "").trim();
+}
+function footnoteHtmlToRuns(html) {
+  const runs = [];
+  if (!html)
+    return runs;
+  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, "text/html");
+  const root = doc.body.firstElementChild;
+  if (!root)
+    return runs;
+  const walk = (node, style) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const text = node.textContent ?? "";
+      if (text)
+        runs.push({ ...style, text });
+      return;
+    }
+    if (!(node instanceof Element))
+      return;
+    if (node.tagName === "BR") {
+      runs.push({ text: "", break: true });
+      return;
+    }
+    const next = { ...style };
+    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.tagName === "A") {
+      const href = safeHref(node.getAttribute("href"));
+      if (href)
+        next.href = href;
+    }
+    if (node.tagName === "SPAN") {
+      const spanStyle = node.getAttribute("style") ?? "";
+      const family = spanStyle.match(/font-family\s*:\s*([^;]+)/i)?.[1]?.split(",")[0]?.trim().replace(/['"]/g, "");
+      if (family)
+        next.font = family;
+      const size = spanStyle.match(/font-size\s*:\s*([\d.]+)\s*pt/i)?.[1];
+      if (size)
+        next.sizePt = Number.parseFloat(size);
+      const color = spanStyle.match(/color\s*:\s*#([0-9a-f]{6})/i)?.[1];
+      if (color)
+        next.color = color.toUpperCase();
+    }
+    node.childNodes.forEach((child) => walk(child, next));
+  };
+  root.childNodes.forEach((child) => walk(child, {}));
+  return runs;
+}
+function footnoteSizePt(style) {
+  const match = style?.match(/font-size\s*:\s*([\d.]+)\s*pt/i);
+  const value = match ? Number.parseFloat(match[1]) : Number.NaN;
+  return Number.isFinite(value) ? value : null;
+}
+
+function shouldMoveBreakToHeading(params) {
+  const { heading, item, pageStart, capacity } = params;
+  if (!heading || !heading.heading || heading.marker)
+    return false;
+  const headingStart = heading.top - heading.marginTop;
+  if (headingStart <= pageStart)
+    return false;
+  return item.top + item.height - headingStart <= capacity;
+}
+
+const pocPageKey = new PluginKey("pocPagination");
+const PAGINATE_META = "poc-paginate";
+function pocChromeFlowHeight(cfg) {
+  return cfg.margins.bottom + cfg.gap + cfg.margins.top;
+}
+function editHint(part) {
+  return (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    window.dispatchEvent(new CustomEvent("poc:edit-chrome", { detail: { part } }));
+  };
+}
+function isPocChromeCanvas(html) {
+  return !!html && html.includes("data-el=");
+}
+function chromeContentEl(html, cfg) {
+  const clean = sanitizeRichHtml(html);
+  if (isPocChromeCanvas(clean)) {
+    const canvas = document.createElement("div");
+    canvas.className = "poc-chrome-canvas";
+    canvas.style.cssText = `position:absolute;top:0;left:${-cfg.margins.left}px;width:794px;height:100%;pointer-events:none;`;
+    canvas.innerHTML = clean;
+    return canvas;
+  }
+  const text = document.createElement("div");
+  text.className = "poc-chrome-text";
+  text.innerHTML = clean;
+  return text;
+}
+function buildPocHeaderEl(cfg) {
+  const header = document.createElement("div");
+  header.className = "poc-page-headerarea";
+  header.style.height = `${cfg.margins.top}px`;
+  header.style.position = "relative";
+  header.style.justifyContent = cfg.headerPosition === "center" ? "center" : cfg.headerPosition === "right" ? "flex-end" : "flex-start";
+  header.title = "Clique para editar o cabe\xE7alho";
+  header.addEventListener("click", editHint("header"));
+  if (cfg.headerScope === "first")
+    return header;
+  if (cfg.headerLogoUrl) {
+    const img = document.createElement("img");
+    img.src = cfg.headerLogoUrl;
+    img.style.maxHeight = `${Math.max(24, cfg.margins.top - 36)}px`;
+    img.style.maxWidth = "50%";
+    img.style.display = "inline-block";
+    header.appendChild(img);
+  }
+  const content = chromeContentEl(cfg.headerText, cfg);
+  if (content.className === "poc-chrome-text" && !content.innerHTML && !cfg.headerLogoUrl)
+    content.innerHTML = "&nbsp;";
+  header.appendChild(content);
+  return header;
+}
+function buildPocFooterEl(cfg, pageNo, total) {
+  const footer = document.createElement("div");
+  footer.className = "poc-page-footerarea";
+  footer.style.height = `${cfg.margins.bottom}px`;
+  footer.style.position = "relative";
+  footer.title = "Clique para editar o rodap\xE9";
+  footer.addEventListener("click", editHint("footer"));
+  const showCustom = !(cfg.footerScope === "first" && pageNo !== 1);
+  const custom = showCustom ? chromeContentEl(cfg.footerText, cfg) : document.createElement("div");
+  if (!showCustom)
+    custom.className = "poc-chrome-text";
+  footer.appendChild(custom);
+  if (cfg.showPageNumber !== false) {
+    const pageLabel = document.createElement("span");
+    pageLabel.textContent = `P\xE1gina ${pageNo} de ${total}`;
+    footer.appendChild(pageLabel);
+  }
+  if (custom.className === "poc-chrome-canvas")
+    footer.style.justifyContent = "flex-end";
+  return footer;
+}
+function buildPocNotesEl(notes) {
+  const box = document.createElement("div");
+  box.className = "poc-page-notes";
+  for (const note of notes) {
+    const line = document.createElement("p");
+    line.className = "poc-page-note";
+    if (note.size)
+      line.style.fontSize = `${note.size}pt`;
+    line.innerHTML = `<sup>${note.n}</sup> ${sanitizeFootnoteHtml(note.text)}`;
+    box.appendChild(line);
+  }
+  return box;
+}
+function buildChrome(cfg, brk, total) {
+  const chrome = document.createElement("div");
+  chrome.className = "poc-page-chrome";
+  chrome.contentEditable = "false";
+  chrome.style.height = `${brk.filler + (brk.notesH ?? 0) + pocChromeFlowHeight(cfg)}px`;
+  const filler = document.createElement("div");
+  filler.style.height = `${brk.filler}px`;
+  chrome.appendChild(filler);
+  if (brk.notes?.length)
+    chrome.appendChild(buildPocNotesEl(brk.notes));
+  chrome.appendChild(buildPocFooterEl(cfg, brk.pageNo, total));
+  const band = document.createElement("div");
+  band.className = "poc-page-gapband";
+  band.style.height = `${cfg.gap}px`;
+  band.style.marginLeft = `-${cfg.margins.left}px`;
+  band.style.marginRight = `-${cfg.margins.right}px`;
+  chrome.appendChild(band);
+  chrome.appendChild(buildPocHeaderEl(cfg));
+  return chrome;
+}
+function absTop(el, sheet) {
+  let top = 0;
+  let node = el;
+  while (node && node !== sheet) {
+    top += node.offsetTop;
+    node = node.offsetParent;
+  }
+  return top;
+}
+const HEADING_TAGS = /* @__PURE__ */ new Set(["H1", "H2", "H3", "H4"]);
+const SPLITTABLE_TAGS = /* @__PURE__ */ new Set(["P"]);
+const MIN_LINES_PER_SIDE = 2;
+function findInlineSplit(view, dom, availablePx, fromLine = 0, minHead = MIN_LINES_PER_SIDE, minTail = MIN_LINES_PER_SIDE) {
+  if (!SPLITTABLE_TAGS.has(dom.tagName))
+    return null;
+  let rects;
+  try {
+    const range = document.createRange();
+    range.selectNodeContents(dom);
+    rects = Array.from(range.getClientRects()).filter((r) => r.height > 0 && r.width > 0);
+  } catch {
+    return null;
+  }
+  if (rects.length < minHead + minTail)
+    return null;
+  const lines = [];
+  for (const r of rects) {
+    const last2 = lines[lines.length - 1];
+    if (last2 && r.top < last2.bottom - 1) {
+      last2.bottom = Math.max(last2.bottom, r.bottom);
+      last2.left = Math.min(last2.left, r.left);
+    } else {
+      lines.push({ top: r.top, bottom: r.bottom, left: r.left });
+    }
+  }
+  if (lines.length < minHead + minTail)
+    return null;
+  const scale = dom.offsetHeight > 0 ? dom.getBoundingClientRect().height / dom.offsetHeight : 1;
+  if (!Number.isFinite(scale) || scale <= 0)
+    return null;
+  const originTop = lines[0].top;
+  const first = fromLine + minHead;
+  const last = lines.length - minTail;
+  let cut = -1;
+  for (let i = first; i <= last; i++) {
+    if ((lines[i].bottom - originTop) / scale > availablePx) {
+      cut = i;
+      break;
+    }
+  }
+  if (cut < first || cut > last)
+    return null;
+  const line = lines[cut];
+  const found = view.posAtCoords({ left: line.left + 1, top: (line.top + line.bottom) / 2 });
+  if (!found)
+    return null;
+  return { pos: found.pos, usedPx: (lines[cut - 1].bottom - originTop) / scale, line: cut };
+}
+function pageSafetyPx(contentHeight) {
+  return Math.max(32, Math.round(contentHeight * 0.08));
+}
+const NOTES_RULE_PX = 4;
+function createNotesMeasurer(sheet, contentWidth) {
+  const host = document.createElement("div");
+  host.className = "poc-page-notes poc-notes-measure";
+  host.style.cssText = "position:absolute;left:0;top:0;visibility:hidden;pointer-events:none;";
+  host.style.width = `${contentWidth}px`;
+  sheet.appendChild(host);
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    /** altura total (filete + notas) de um conjunto de notas */
+    height(notes) {
+      if (!notes.length)
+        return 0;
+      const key = notes.map((n) => `${n.n}:${n.size ?? ""}:${n.text.length}`).join("|");
+      const hit = cache.get(key);
+      if (hit != null)
+        return hit;
+      host.replaceChildren(...Array.from(buildPocNotesEl(notes).childNodes));
+      const value = host.offsetHeight + NOTES_RULE_PX;
+      cache.set(key, value);
+      return value;
+    },
+    dispose() {
+      host.remove();
+    }
+  };
+}
+function computePocBreaks(view, cfg, sheet) {
+  const bandH = cfg.pageHeight - cfg.margins.top - cfg.margins.bottom;
+  const safety = pageSafetyPx(bandH);
+  const contentH = bandH - safety;
+  if (contentH <= 40)
+    return { breaks: [], total: 1, markers: [], lastNotes: [] };
+  const chromes = Array.from(sheet.querySelectorAll(".poc-page-chrome")).map((el) => ({ top: absTop(el, sheet), height: el.offsetHeight })).sort((a, b) => a.top - b.top);
+  const chromeAbove = (top) => {
+    let sum = 0;
+    for (const c of chromes) {
+      if (c.top < top)
+        sum += c.height;
+      else
+        break;
+    }
+    return sum;
+  };
+  const items = [];
+  const baseY = cfg.margins.top;
+  let noteCounter = 0;
+  view.state.doc.forEach((block, blockOffset) => {
+    if (block.type.name !== "minutaBlock") {
+      return;
+    }
+    block.forEach((child, childOffset) => {
+      const pos = blockOffset + 1 + childOffset;
+      const dom = view.nodeDOM(pos);
+      if (!(dom instanceof HTMLElement))
+        return;
+      const top = absTop(dom, sheet) - baseY - chromeAbove(absTop(dom, sheet));
+      const notes = [];
+      child.descendants((inner, innerPos) => {
+        if (inner.type.name === "footnoteRef" && inner.attrs.text) {
+          noteCounter += 1;
+          notes.push({ n: noteCounter, text: String(inner.attrs.text), size: inner.attrs.size ?? null, at: pos + 1 + innerPos });
+        }
+        return true;
+      });
+      items.push({
+        pos,
+        size: child.nodeSize,
+        top,
+        height: dom.offsetHeight,
+        notes,
+        dom,
+        // margem superior conta como parte da página que o item abre —
+        // senão a "página" do preview fica mais alta que um A4 real e
+        // o DOCX (página física) divergiria
+        marginTop: Number.parseFloat(getComputedStyle(dom).marginTop) || 0,
+        heading: HEADING_TAGS.has(dom.tagName),
+        marker: (dom.textContent || "").trim() === "PAGEBREAK",
+        // quebra que cai no 1º filho de um bloco vai ANTES do bloco
+        // (o chrome fora do div do bloco — senão o outline/label de
+        // proveniência "vaza" para a página anterior)
+        blockStartPos: childOffset === 0 ? blockOffset : null
+      });
+    });
+  });
+  if (!items.length)
+    return { breaks: [], total: 1, markers: [], lastNotes: [] };
+  const markers = items.filter((i) => i.marker).map((i) => ({ from: i.pos, to: i.pos + i.size }));
+  const hasNotes = items.some((i) => i.notes.length);
+  const measurer = hasNotes ? createNotesMeasurer(sheet, sheet.clientWidth - cfg.margins.left - cfg.margins.right) : null;
+  const breaks = [];
+  let pageStart = 0;
+  let pageNo = 1;
+  let forcedBreakPending = false;
+  let pageNotes = [];
+  const notesH = (notes) => measurer && notes.length ? measurer.height(notes) : 0;
+  const closePage = (pos, filler, soft = false) => {
+    const height = notesH(pageNotes);
+    breaks.push({ pos, filler: Math.max(0, filler - height), pageNo, notes: pageNotes, notesH: height, soft });
+    pageNo++;
+    pageNotes = [];
+  };
+  const maxSteps = items.length * 4 + 64;
+  let steps = 0;
+  for (let i = 0; i < items.length; i++) {
+    if (++steps > maxSteps) {
+      console.warn("[poc] pagina\xE7\xE3o interrompida: la\xE7o sem progresso", { items: items.length, breaks: breaks.length });
+      break;
+    }
+    const item = items[i];
+    if (item.marker) {
+      forcedBreakPending = true;
+      continue;
+    }
+    const fullH = contentH + safety;
+    const itemEnd = item.top + item.height;
+    const capacity = contentH - notesH([...pageNotes, ...item.notes]);
+    if (forcedBreakPending && item.top > pageStart) {
+      const startWithMargin = item.top - item.marginTop;
+      closePage(item.blockStartPos ?? item.pos, fullH - (startWithMargin - pageStart));
+      pageStart = startWithMargin;
+      forcedBreakPending = false;
+    } else if (item.top > pageStart && itemEnd - pageStart > capacity) {
+      const disponivel = capacity - (item.top - pageStart);
+      let split = findInlineSplit(view, item.dom, disponivel);
+      if (!split)
+        split = findInlineSplit(view, item.dom, disponivel, 0, MIN_LINES_PER_SIDE, 1);
+      if (split) {
+        let pending = [...item.notes];
+        let lastLine = split.line;
+        while (split) {
+          lastLine = split.line;
+          const usedEnd = item.top + split.usedPx;
+          const cutAt = split.pos;
+          const stay = pending.filter((n) => n.at === void 0 || n.at < cutAt);
+          pending = pending.filter((n) => !stay.includes(n));
+          pageNotes.push(...stay);
+          closePage(cutAt, fullH - (usedEnd - pageStart), true);
+          pageStart = usedEnd;
+          if (itemEnd - pageStart <= contentH - notesH(pending))
+            break;
+          const fromTop = pageStart - item.top;
+          split = findInlineSplit(
+            view,
+            item.dom,
+            fromTop + contentH - notesH(pending),
+            split.line,
+            1,
+            1
+          );
+          if (!split)
+            split = findInlineSplit(view, item.dom, fromTop + contentH, lastLine, 1, 1);
+        }
+        pageNotes.push(...pending);
+        forcedBreakPending = false;
+        while (item.top + item.height - pageStart > contentH) {
+          pageStart += contentH;
+          pageNo++;
+        }
+        continue;
+      }
+      let breakIndex = i;
+      if (shouldMoveBreakToHeading({ heading: items[i - 1], item, pageStart, capacity }))
+        breakIndex = i - 1;
+      const target = items[breakIndex];
+      const startWithMargin = target.top - target.marginTop;
+      const moved = [];
+      for (let k = breakIndex; k < i; k++) {
+        for (const note of items[k].notes) {
+          const at = pageNotes.indexOf(note);
+          if (at >= 0)
+            pageNotes.splice(at, 1);
+          moved.push(note);
+        }
+      }
+      closePage(target.blockStartPos ?? target.pos, fullH - (startWithMargin - pageStart));
+      pageNotes = moved;
+      pageStart = startWithMargin;
+      if (breakIndex < i) {
+        i = breakIndex;
+        continue;
+      }
+    }
+    forcedBreakPending = false;
+    pageNotes.push(...item.notes);
+    while (item.top + item.height - pageStart > contentH) {
+      pageStart += contentH;
+      pageNo++;
+    }
+  }
+  measurer?.dispose();
+  return { breaks, total: pageNo, markers, lastNotes: pageNotes };
+}
+function pocStyleProp(style, prop) {
+  if (!style)
+    return void 0;
+  const match = style.match(new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i"));
+  return match?.[1]?.trim();
+}
+function isPocFlexRow(node) {
+  if (node.type.name !== "styledDiv")
+    return false;
+  const display = pocStyleProp(node.attrs.style, "display");
+  if (display !== "flex" && display !== "table")
+    return false;
+  if (pocStyleProp(node.attrs.style, "flex-direction") === "column")
+    return false;
+  return node.childCount > 1;
+}
+function pocNodeHasVisibleContent(node) {
+  if (node.textContent.trim().length > 0)
+    return true;
+  let found = false;
+  const checkIsland = (island) => {
+    const html = island.attrs.html || "";
+    if (/<img[^>]*src\s*=\s*"[^"]+"/i.test(html) || html.includes("<svg"))
+      found = true;
+  };
+  if (node.type.name === "htmlIsland")
+    checkIsland(node);
+  node.descendants((child) => {
+    if (found)
+      return false;
+    if (child.type.name === "htmlIsland")
+      checkIsland(child);
+    return !found;
+  });
+  return found;
+}
+function paintsSomething(value) {
+  if (!value)
+    return false;
+  const v = value.trim().toLowerCase();
+  if (!v || /\b(?:none|hidden|transparent)\b/.test(v))
+    return false;
+  const width = v.match(/(?:^|\s)(\d*\.?\d+)(?:px|pt|em|rem|cm|mm|in)?(?=\s|$)/);
+  return !(width && Number.parseFloat(width[1]) === 0);
+}
+function pocNodePaintsBox(node) {
+  const style = node.attrs?.style ?? null;
+  if (!style)
+    return false;
+  const props = ["border", "border-top", "border-right", "border-bottom", "border-left", "background", "background-color"];
+  return props.some((prop) => paintsSomething(pocStyleProp(style, prop)));
+}
+function pocLoneCellIndex(row) {
+  if (pocNodePaintsBox(row))
+    return null;
+  let found = -1;
+  for (let i = 0; i < row.childCount; i++) {
+    const child = row.child(i);
+    if (pocNodePaintsBox(child))
+      return null;
+    if (pocNodeHasVisibleContent(child)) {
+      if (found !== -1)
+        return null;
+      found = i;
+    }
+  }
+  return found === -1 ? null : found;
+}
+function computePocLoneRows(doc) {
+  const out = [];
+  doc.descendants((node, pos) => {
+    if (!isPocFlexRow(node))
+      return true;
+    const index = pocLoneCellIndex(node);
+    if (index == null)
+      return true;
+    let offset = pos + 1;
+    for (let i = 0; i < index; i++)
+      offset += node.child(i).nodeSize;
+    out.push({
+      rowFrom: pos,
+      rowTo: pos + node.nodeSize,
+      cellFrom: offset,
+      cellTo: offset + node.child(index).nodeSize
+    });
+    return true;
+  });
+  return out;
+}
+function breaksEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].pos !== b[i].pos || Math.abs(a[i].filler - b[i].filler) > 1)
+      return false;
+    if ((a[i].notes?.length ?? 0) !== (b[i].notes?.length ?? 0))
+      return false;
+  }
+  return true;
+}
+function PocPaginationPlugin(cfg) {
+  return new Plugin({
+    key: pocPageKey,
+    state: {
+      init: () => ({ breaks: [], total: 1, markers: [] }),
+      apply(tr, value) {
+        const next = tr.getMeta(PAGINATE_META);
+        if (next)
+          return { markers: value.markers, ...next };
+        if (tr.docChanged) {
+          return {
+            ...value,
+            breaks: value.breaks.map((b) => ({ ...b, pos: tr.mapping.map(b.pos) })),
+            markers: value.markers.map((m) => ({ from: tr.mapping.map(m.from), to: tr.mapping.map(m.to) }))
+          };
+        }
+        return value;
+      }
+    },
+    props: {
+      decorations(state) {
+        const pag = pocPageKey.getState(state);
+        const decorations = (pag?.breaks ?? []).map(
+          (brk) => Decoration.widget(brk.pos, () => buildChrome(cfg, brk, pag.total), {
+            side: -1,
+            key: `chrome-${brk.pageNo}-${Math.round(brk.filler)}-${brk.notes?.length ?? 0}-${pag.total}-v${cfg.version ?? 0}`
+          })
+        );
+        for (const marker of pag?.markers ?? []) {
+          if (marker.to > marker.from && marker.to <= state.doc.content.size)
+            decorations.push(Decoration.node(marker.from, marker.to, { class: "poc-pagebreak-marker" }));
+        }
+        for (const lone of computePocLoneRows(state.doc)) {
+          decorations.push(Decoration.node(lone.rowFrom, lone.rowTo, { class: "poc-lone-row" }));
+          decorations.push(Decoration.node(lone.cellFrom, lone.cellTo, { class: "poc-lone-cell" }));
+        }
+        if (!decorations.length)
+          return null;
+        return DecorationSet.create(state.doc, decorations);
+      }
+    }
+  });
+}
+
+export { PocPaginationPlugin as P, sanitizeFootnoteHtml as a, pocPageKey as b, computePocBreaks as c, breaksEqual as d, PAGINATE_META as e, footnoteHtmlToRuns as f, pocChromeFlowHeight as g, buildPocHeaderEl as h, isPocChromeCanvas as i, buildPocFooterEl as j, buildPocNotesEl as k, isPocFlexRow as l, pocNodeHasVisibleContent as m, pocNodePaintsBox as n, computePocLoneRows as o, pocLoneCellIndex as p, footnoteSizePt as q, shouldMoveBreakToHeading as r, sanitizeRichHtml as s };