@meistrari/minuta-nuxt 0.1.0

package/dist/runtime/composables/editorExtensions.d.ts

@@ -0,0 +1,56 @@
+import type { Editor } from '@tiptap/core';
+import { Extension as TiptapExtension, Mark as TiptapMark, Node as TiptapNode } from '@tiptap/core';
+import type { PocPageConfig } from './paginationPlugin.js';
+/**
+ * Extensões Tiptap da PoC do editor de minuta.
+ *
+ * Modelo: doc → minutaBlock+ → (paragraph | heading | styledDiv | htmlIsland | ...)
+ * - minutaBlock: wrapper com proveniência (blockId/título do bloco do template)
+ * - htmlIsland: tabelas/listas/imagens/svg preservados como ilhas não-editáveis (HTML cru)
+ * - variableChip: <span data-variable-id> vira nó atômico — a variável continua "viva"
+ * - inlineStyle/styledDiv/passthrough: preservam o CSS inline do pipeline de render
+ */
+/**
+ * Meta de transação: troca de imagem fria pelo blob recém-baixado (load
+ * progressivo). Não é edição do advogado — fica fora do undo e não pode
+ * marcar o documento como sujo (senão o autosave dispara sozinho no load).
+ */
+export declare const POC_ASSET_SWAP = "pocAssetSwap";
+export declare const PocDocument: TiptapNode<any, any>;
+export declare const PocMinutaBlock: TiptapNode<any, any>;
+export declare const PocHtmlIsland: TiptapNode<any, any>;
+/**
+ * Aviso de imagem faltando — a caixa tracejada que o render emite quando a
+ * variável de imagem não foi preenchida.
+ *
+ * Antes ela chegava aqui como um `styledDiv` comum: apagar exigia selecionar o
+ * texto por dentro, e a moldura sobrava no documento. Como nó próprio ela é
+ * atômica e selecionável (um clique + Backspace resolve), ganha um botão de
+ * remover e um alvo de clique para escolher a imagem ali mesmo.
+ *
+ * Na etapa de edição o DOCUMENTO é a verdade — o checklist fica travado —, então
+ * escolher a imagem insere no texto editado; não mexe na variável do caso.
+ *
+ * O nó guarda só o ID da variável e REDESENHA a caixa a partir dele. Guardar o
+ * `outerHTML` e devolvê-lo a um `innerHTML` faria do corpo da edição — que é
+ * dado persistido, editável por qualquer um do workspace — um vetor de stored
+ * XSS: bastaria uma `div.missing-image-warning` forjada com `onerror` para
+ * rodar script no editor de quem abrisse o caso depois.
+ */
+export declare const PocMissingImage: TiptapNode<any, any>;
+export declare const PocVariableChip: TiptapNode<any, any>;
+/**
+ * Nota de rodapé: o render devolve `<sup data-footnote="texto">n</sup>` e o
+ * export transforma em nota de rodapé DE VERDADE no Word (o pipeline legado faz
+ * o mesmo via footnotes_filter.lua do conversor). Precisa ser um nó do schema —
+ * senão o Tiptap descarta o data-footnote no round-trip e o texto da nota some.
+ */
+export declare const PocFootnoteRef: TiptapNode<any, any>;
+/** re-sequencia a numeração das chamadas de nota na ordem do documento */
+export declare function renumberPocFootnotes(editor: Editor): void;
+export declare const PocStyledDiv: TiptapNode<any, any>;
+export declare const PocInlineStyle: TiptapMark<any, any>;
+export declare const PocUnderline: TiptapMark<any, any>;
+/** Preserva style/class inline nos blocos de texto (o pipeline de render inlina todo o CSS). */
+export declare const PocStylePassthrough: TiptapExtension<any, any>;
+export declare function buildPocExtensions(pageConfig?: PocPageConfig): (TiptapNode<any, any> | TiptapMark<any, any> | TiptapExtension<any, any>)[];

package/dist/runtime/composables/editorExtensions.js

@@ -0,0 +1,466 @@
+import { Extension as TiptapExtension, Mark as TiptapMark, Node as TiptapNode, mergeAttributes } from "@tiptap/core";
+import TiptapStarterKit from "@tiptap/starter-kit";
+import Table from "@tiptap/extension-table";
+import TableCell from "@tiptap/extension-table-cell";
+import TableHeader from "@tiptap/extension-table-header";
+import TableRow from "@tiptap/extension-table-row";
+import { sanitizeRichHtml } from "../utils/sanitizeRichHtml.js";
+import { PocPaginationPlugin } from "./paginationPlugin.js";
+export const POC_ASSET_SWAP = "pocAssetSwap";
+function htmlToDom(html) {
+  const tpl = document.createElement("template");
+  tpl.innerHTML = sanitizeRichHtml(html);
+  return tpl.content.firstElementChild ?? document.createElement("div");
+}
+export const PocDocument = TiptapNode.create({
+  name: "doc",
+  topNode: true,
+  content: "minutaBlock+"
+});
+export const PocMinutaBlock = TiptapNode.create({
+  name: "minutaBlock",
+  group: "block",
+  content: "block+",
+  defining: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      blockId: { default: null },
+      blockTitle: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{
+      tag: "div[data-minuta-block]",
+      priority: 120,
+      getAttrs: (el) => ({
+        blockId: el.getAttribute("data-block-id"),
+        blockTitle: el.getAttribute("data-block-title")
+      })
+    }];
+  },
+  renderHTML({ HTMLAttributes, node }) {
+    return ["div", mergeAttributes(HTMLAttributes, {
+      "data-minuta-block": "",
+      "data-block-id": node.attrs.blockId,
+      "data-block-title": node.attrs.blockTitle,
+      "class": "poc-minuta-block"
+    }), 0];
+  }
+});
+export const PocHtmlIsland = TiptapNode.create({
+  name: "htmlIsland",
+  group: "block",
+  atom: true,
+  selectable: true,
+  // atomos arrastáveis: mover imagens/tabelas pelo documento
+  draggable: true,
+  addAttributes() {
+    return { html: { default: "" } };
+  },
+  parseHTML() {
+    const capture = (el) => ({ html: el.outerHTML });
+    return ["ul", "ol", "img", "figure", "svg"].map((tag) => ({
+      tag,
+      priority: 100,
+      getAttrs: capture
+    }));
+  },
+  renderHTML({ node }) {
+    return htmlToDom(node.attrs.html);
+  },
+  addNodeView() {
+    return ({ node, getPos, editor }) => {
+      const dom = document.createElement("div");
+      dom.className = "poc-island";
+      dom.contentEditable = "false";
+      dom.innerHTML = sanitizeRichHtml(node.attrs.html);
+      const img = dom.children.length === 1 && dom.firstElementChild instanceof HTMLImageElement ? dom.firstElementChild : null;
+      if (img)
+        dom.classList.add("poc-island--img");
+      if (img && editor.isEditable) {
+        const handle = document.createElement("div");
+        handle.className = "poc-img-handle";
+        handle.title = "Arraste para redimensionar";
+        dom.appendChild(handle);
+        let startX = 0;
+        let startWidth = 0;
+        let scale = 1;
+        let maxWidth = Number.POSITIVE_INFINITY;
+        const onMove = (event) => {
+          const width = Math.round(startWidth + (event.clientX - startX) / scale);
+          img.style.width = `${Math.min(maxWidth, Math.max(40, width))}px`;
+          img.style.height = "auto";
+        };
+        const onUp = () => {
+          document.removeEventListener("mousemove", onMove);
+          document.removeEventListener("mouseup", onUp);
+          const pos = typeof getPos === "function" ? getPos() : null;
+          if (typeof pos === "number") {
+            const clone = dom.cloneNode(true);
+            clone.querySelector(".poc-img-handle")?.remove();
+            editor.view.dispatch(
+              editor.state.tr.setNodeMarkup(pos, void 0, { html: clone.innerHTML })
+            );
+          }
+        };
+        handle.addEventListener("mousedown", (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          startX = event.clientX;
+          startWidth = img.offsetWidth;
+          scale = img.offsetWidth ? img.getBoundingClientRect().width / img.offsetWidth : 1;
+          maxWidth = dom.parentElement?.clientWidth || Number.POSITIVE_INFINITY;
+          document.addEventListener("mousemove", onMove);
+          document.addEventListener("mouseup", onUp);
+        });
+      }
+      return { dom };
+    };
+  }
+});
+let missingImageSeq = 0;
+function nextMissingImageUid() {
+  missingImageSeq += 1;
+  return `mi-${missingImageSeq}`;
+}
+const MISSING_IMAGE_BOX_STYLE = "box-sizing: border-box; max-width: 100%; border: 2px dashed rgba(223, 139, 13, 0.43); padding: 16px; margin: 12px 0; border-radius: 8px; background-color: rgba(254, 174, 0, 0.03); color: rgb(119, 54, 19); text-align: center; box-shadow: inset 0 0 8px #e6510011;";
+const MISSING_IMAGE_ROW_STYLE = "display: flex; align-items: center; justify-content: center; gap: 8px;";
+export const PocMissingImage = TiptapNode.create({
+  name: "missingImage",
+  group: "block",
+  atom: true,
+  selectable: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      variableId: { default: null },
+      parentBlockId: { default: null },
+      /**
+       * Identidade do nó DENTRO desta sessão do editor.
+       *
+       * Um fluxo demorado (escolher arquivo + upload) precisa voltar
+       * exatamente ao aviso que foi clicado. Posição não serve: o
+       * documento muda no meio. Tipo + variável também não: o mesmo
+       * aviso pode aparecer várias vezes, e um delete+insert põe outro
+       * igual no mesmo lugar. Com um id por nó, achar é inequívoco —
+       * se ele sumiu, não achamos; se ele andou, achamos onde parou.
+       *
+       * Gerado no parse e NÃO serializado: vale enquanto o editor viver,
+       * que é o tempo de vida do fluxo. Colar um aviso passa pelo parse
+       * de novo e ganha id próprio, então nunca há dois iguais.
+       */
+      uid: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{
+      tag: "div.missing-image-warning",
+      // acima do styledDiv (40), senão a caixa vira container editável de novo
+      priority: 120,
+      getAttrs: (el) => ({
+        variableId: el.getAttribute("data-variable-id"),
+        parentBlockId: el.getAttribute("data-parent-block-id"),
+        uid: nextMissingImageUid()
+      })
+    }];
+  },
+  renderHTML({ node }) {
+    return [
+      "div",
+      {
+        "class": "missing-image-warning",
+        "data-variable-id": node.attrs.variableId ?? "",
+        "data-parent-block-id": node.attrs.parentBlockId ?? "",
+        "style": MISSING_IMAGE_BOX_STYLE
+        // `uid` fica de fora de propósito: é identidade de sessão, não dado
+      },
+      ["span", { style: MISSING_IMAGE_ROW_STYLE }, `A imagem ${node.attrs.variableId ?? ""} est\xE1 faltando`]
+    ];
+  },
+  addNodeView() {
+    return ({ node, getPos, editor }) => {
+      const dom = document.createElement("div");
+      dom.className = "poc-missing-image";
+      dom.contentEditable = "false";
+      const caixa = document.createElement("div");
+      caixa.className = "missing-image-warning";
+      caixa.setAttribute("style", MISSING_IMAGE_BOX_STYLE);
+      const linha = document.createElement("span");
+      linha.setAttribute("style", MISSING_IMAGE_ROW_STYLE);
+      linha.textContent = `\u26A0 A imagem ${node.attrs.variableId ?? ""} est\xE1 faltando`;
+      caixa.appendChild(linha);
+      dom.appendChild(caixa);
+      if (!editor.isEditable)
+        return { dom };
+      caixa.style.position = "relative";
+      caixa.style.cursor = "pointer";
+      caixa.title = "Clique para escolher uma imagem";
+      const remover = document.createElement("button");
+      remover.type = "button";
+      remover.className = "poc-missing-image__remove";
+      remover.title = "Remover este aviso";
+      remover.setAttribute("aria-label", "Remover este aviso");
+      remover.textContent = "\xD7";
+      remover.addEventListener("mousedown", (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        const pos = typeof getPos === "function" ? getPos() : null;
+        if (typeof pos === "number")
+          editor.view.dispatch(editor.state.tr.delete(pos, pos + node.nodeSize));
+      });
+      caixa.appendChild(remover);
+      dom.addEventListener("click", (event) => {
+        if (event.target.closest(".poc-missing-image__remove"))
+          return;
+        event.preventDefault();
+        const pos = typeof getPos === "function" ? getPos() : null;
+        window.dispatchEvent(new CustomEvent("poc:pick-image", {
+          detail: { variableId: node.attrs.variableId, uid: node.attrs.uid, hintPos: pos }
+        }));
+      });
+      return { dom };
+    };
+  }
+});
+export const PocVariableChip = TiptapNode.create({
+  name: "variableChip",
+  inline: true,
+  group: "inline",
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      variableId: { default: null },
+      parentBlockId: { default: null },
+      html: { default: "" },
+      text: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{
+      tag: "span[data-variable-id]",
+      priority: 110,
+      getAttrs: (el) => ({
+        variableId: el.getAttribute("data-variable-id"),
+        parentBlockId: el.getAttribute("data-parent-block-id"),
+        html: el.outerHTML,
+        text: el.textContent ?? ""
+      })
+    }];
+  },
+  renderHTML({ node }) {
+    return htmlToDom(node.attrs.html);
+  },
+  addNodeView() {
+    return ({ node }) => {
+      const dom = document.createElement("span");
+      dom.className = "poc-varchip";
+      dom.contentEditable = "false";
+      dom.innerHTML = sanitizeRichHtml(node.attrs.html);
+      dom.addEventListener("click", (event) => {
+        event.preventDefault();
+        window.dispatchEvent(new CustomEvent("poc:variable-click", {
+          detail: {
+            variableId: node.attrs.variableId,
+            parentBlockId: node.attrs.parentBlockId,
+            text: node.attrs.text
+          }
+        }));
+      });
+      return { dom };
+    };
+  }
+});
+export const PocFootnoteRef = TiptapNode.create({
+  name: "footnoteRef",
+  inline: true,
+  group: "inline",
+  atom: true,
+  selectable: false,
+  addAttributes() {
+    return {
+      number: { default: "" },
+      /** conteúdo da nota em HTML de ênfase (b/i/u/br) */
+      text: { default: "" },
+      /** corpo declarado no template (`font-size: 9pt`), em pontos */
+      size: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{
+      tag: "sup[data-footnote]",
+      priority: 110,
+      getAttrs: (el) => ({
+        number: el.textContent ?? "",
+        text: el.getAttribute("data-footnote") ?? "",
+        size: Number.parseFloat(el.getAttribute("data-footnote-size") ?? "") || null
+      })
+    }];
+  },
+  renderHTML({ node }) {
+    const attrs = { "data-footnote": node.attrs.text, "class": "poc-footnote" };
+    if (node.attrs.size)
+      attrs["data-footnote-size"] = String(node.attrs.size);
+    return ["sup", attrs, node.attrs.number];
+  },
+  addNodeView() {
+    return ({ node, editor, getPos }) => {
+      const dom = document.createElement("sup");
+      dom.className = "poc-footnote";
+      dom.contentEditable = "false";
+      dom.textContent = node.attrs.number;
+      dom.title = node.attrs.text;
+      dom.addEventListener("click", (event) => {
+        if (!editor.isEditable || typeof getPos !== "function")
+          return;
+        event.preventDefault();
+        event.stopPropagation();
+        const pos = getPos();
+        if (pos == null)
+          return;
+        window.dispatchEvent(new CustomEvent("poc:edit-footnote", { detail: { pos } }));
+      });
+      return { dom };
+    };
+  }
+});
+export function renumberPocFootnotes(editor) {
+  if (!editor || editor.isDestroyed)
+    return;
+  const tr = editor.state.tr;
+  let index = 0;
+  let touched = false;
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type.name !== "footnoteRef")
+      return;
+    index++;
+    const number = String(index);
+    if (node.attrs.number !== number) {
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, number });
+      touched = true;
+    }
+  });
+  if (touched)
+    editor.view.dispatch(tr);
+}
+export const PocStyledDiv = TiptapNode.create({
+  name: "styledDiv",
+  group: "block",
+  content: "block+",
+  addAttributes() {
+    const passthrough = (name) => ({
+      default: null,
+      parseHTML: (el) => el.getAttribute(name),
+      renderHTML: (attrs) => attrs[name] != null ? { [name]: attrs[name] } : {}
+    });
+    return {
+      "style": { default: null },
+      "class": { default: null },
+      // alinhamento de colunas do template (usado pelo CSS de centralização de imagens)
+      "data-horizontal-align": passthrough("data-horizontal-align"),
+      "data-vertical-align": passthrough("data-vertical-align"),
+      "data-width": passthrough("data-width")
+    };
+  },
+  parseHTML() {
+    return [{
+      tag: "div",
+      priority: 40,
+      getAttrs: (el) => {
+        if (el.hasAttribute("data-minuta-block"))
+          return false;
+        return { style: el.getAttribute("style"), class: el.getAttribute("class") };
+      }
+    }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes), 0];
+  }
+});
+export const PocInlineStyle = TiptapMark.create({
+  name: "inlineStyle",
+  addAttributes() {
+    return {
+      style: { default: null },
+      class: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{
+      tag: "span",
+      priority: 40,
+      getAttrs: (el) => {
+        if (el.hasAttribute("data-variable-id"))
+          return false;
+        const style = el.getAttribute("style");
+        const cls = el.getAttribute("class");
+        if (!style && !cls)
+          return false;
+        return { style, class: cls };
+      }
+    }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes), 0];
+  }
+});
+export const PocUnderline = TiptapMark.create({
+  name: "underline",
+  parseHTML() {
+    return [
+      { tag: "u" },
+      { style: "text-decoration", consuming: false, getAttrs: (value) => value.includes("underline") ? {} : false }
+    ];
+  },
+  renderHTML() {
+    return ["u", 0];
+  },
+  addCommands() {
+    return {
+      toggleUnderline: () => ({ commands }) => commands.toggleMark("underline")
+    };
+  }
+});
+export const PocStylePassthrough = TiptapExtension.create({
+  name: "pocStylePassthrough",
+  addGlobalAttributes() {
+    const attr = (name) => ({
+      default: null,
+      parseHTML: (el) => el.getAttribute(name),
+      renderHTML: (attrs) => attrs[name] ? { [name]: attrs[name] } : {}
+    });
+    return [{
+      types: ["paragraph", "heading", "blockquote", "table", "tableRow", "tableCell", "tableHeader"],
+      attributes: { style: attr("style"), class: attr("class") }
+    }];
+  }
+});
+export function buildPocExtensions(pageConfig) {
+  const extensions = [
+    PocDocument,
+    TiptapStarterKit.configure({ document: false }),
+    Table.configure({ resizable: true }),
+    TableRow,
+    TableCell,
+    TableHeader,
+    PocMinutaBlock,
+    PocHtmlIsland,
+    PocMissingImage,
+    PocVariableChip,
+    PocFootnoteRef,
+    PocStyledDiv,
+    PocInlineStyle,
+    PocUnderline,
+    PocStylePassthrough
+  ];
+  if (pageConfig) {
+    extensions.push(TiptapExtension.create({
+      name: "pocPagination",
+      addProseMirrorPlugins() {
+        return [PocPaginationPlugin(pageConfig)];
+      }
+    }));
+  }
+  return extensions;
+}

package/dist/runtime/composables/paginationPlugin.d.ts

@@ -0,0 +1,126 @@
+import type { Node as PMNode } from '@tiptap/pm/model';
+import type { EditorView } from '@tiptap/pm/view';
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+/**
+ * Engine de paginação da PoC.
+ *
+ * O documento continua linear no ProseMirror; as "páginas" nascem de widget
+ * decorations ("chrome") inseridas ENTRE os nós internos dos blocos:
+ * cada chrome preenche o resto da área útil da página (filler), desenha o
+ * rodapé (nº da página) dentro da margem inferior, a faixa de separação
+ * entre páginas e o cabeçalho (logo do template) dentro da margem superior
+ * da página seguinte.
+ *
+ * A medição roda fora do plugin (componente agenda via rAF) em coordenadas
+ * de layout (offsetTop/offsetHeight — imunes ao CSS zoom da folha) e
+ * NORMALIZADAS: a altura de todo chrome existente é subtraída, então o
+ * algoritmo sempre enxerga o fluxo "sem paginação" e converge (recomputar
+ * com chrome na tela produz os mesmos breaks → sem loop de layout).
+ *
+ * Regras de quebra:
+ * - quebra somente entre nós (parágrafo/título/ilha) — nó mais alto que a
+ *   página flui e as páginas internas são contadas, sem chrome no meio;
+ * - keep-with-next: título não fica órfão no fim da página (a quebra sobe
+ *   para antes do título).
+ */
+export interface PocPageConfig {
+    pageHeight: number;
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    gap: number;
+    headerLogoUrl?: string | null;
+    headerPosition?: 'left' | 'center' | 'right';
+    /** texto editável do cabeçalho (ao lado do logo) */
+    headerText?: string;
+    /** texto editável do rodapé (lado esquerdo; o nº de página fica à direita) */
+    footerText?: string;
+    /** onde o conteúdo do cabeçalho aparece: todas as páginas ou só a primeira */
+    headerScope?: 'all' | 'first';
+    /** onde o conteúdo custom do rodapé aparece (o nº de página é sempre em todas) */
+    footerScope?: 'all' | 'first';
+    /** numeração "Página N de M" no rodapé — opcional por conjunto de cabeçalho */
+    showPageNumber?: boolean;
+    /** bump força a reconstrução do chrome (muda a key das decorations) */
+    version?: number;
+}
+/** nota de rodapé que cai numa página (o marcador está no corpo dela) */
+export interface PocPageNote {
+    n: number;
+    /** conteúdo em HTML de ênfase (b/i/u/br) — já sanitizado no render */
+    text: string;
+    /** corpo declarado no template, em pontos (default: 8pt, como o Word) */
+    size?: number | null;
+}
+export interface PocPageBreak {
+    pos: number;
+    filler: number;
+    pageNo: number;
+    /** notas cujos marcadores estão nesta página — desenhadas acima do rodapé */
+    notes?: PocPageNote[];
+    /** altura reservada pelas notas (já descontada do filler) */
+    notesH?: number;
+}
+interface PagState {
+    breaks: PocPageBreak[];
+    total: number;
+    /** parágrafos-marcador "PAGEBREAK" (quebra manual do template) */
+    markers: {
+        from: number;
+        to: number;
+    }[];
+}
+export declare const pocPageKey: PluginKey<PagState>;
+export declare const PAGINATE_META = "poc-paginate";
+export declare function pocChromeFlowHeight(cfg: PocPageConfig): number;
+/**
+ * o chrome tem dois formatos: canvas (elementos posicionados, coordenadas no
+ * frame da PÁGINA — vem do editor estilo Word) e flow legado (texto corrido)
+ */
+export declare function isPocChromeCanvas(html: string | undefined | null): boolean;
+export declare function buildPocHeaderEl(cfg: PocPageConfig): HTMLElement;
+export declare function buildPocFooterEl(cfg: PocPageConfig, pageNo: number, total: number): HTMLElement;
+/** área de notas de rodapé: filete + notas, no pé da área útil (como no Word) */
+export declare function buildPocNotesEl(notes: PocPageNote[]): HTMLElement;
+export declare function computePocBreaks(view: EditorView, cfg: PocPageConfig, sheet: HTMLElement): {
+    breaks: PocPageBreak[];
+    total: number;
+    markers: {
+        from: number;
+        to: number;
+    }[];
+    lastNotes: PocPageNote[];
+};
+export declare function isPocFlexRow(node: PMNode): boolean;
+/** conteúdo visível = texto, imagem com src preenchido ou svg (imgs vazias do pipeline não contam) */
+export declare function pocNodeHasVisibleContent(node: PMNode): boolean;
+/**
+ * A célula/linha PINTA alguma coisa (borda ou fundo)?
+ *
+ * Uma coluna sem texto mas com borda não é espaço sobrando: é estrutura. A
+ * folha de rosto da Telefônica desenha uma timeline com `border-right` numa
+ * coluna VAZIA (o eixo central) e `border-bottom` alternando entre as duas —
+ * colapsar a coluna "vazia" apaga o eixo e centraliza o que devia ficar
+ * alternando esquerda/direita.
+ */
+export declare function pocNodePaintsBox(node: PMNode): boolean;
+/**
+ * Índice da única célula com conteúdo da linha, ou null se a linha não pode
+ * ser colapsada. Fonte única da regra: o preview (decorations .poc-lone-row)
+ * e o export DOCX chamam esta função — se divergirem, o Word deixa de bater
+ * com a tela.
+ */
+export declare function pocLoneCellIndex(row: PMNode): number | null;
+export interface PocLoneRow {
+    rowFrom: number;
+    rowTo: number;
+    cellFrom: number;
+    cellTo: number;
+}
+export declare function computePocLoneRows(doc: PMNode): PocLoneRow[];
+export declare function breaksEqual(a: PocPageBreak[], b: PocPageBreak[]): boolean;
+export declare function PocPaginationPlugin(cfg: PocPageConfig): Plugin<PagState>;
+export {};