@meistrari/minuta-nuxt 0.1.0

package/dist/runtime/composables/paginationPlugin.js

@@ -0,0 +1,421 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { sanitizeRichHtml } from "../utils/sanitizeRichHtml.js";
+import { sanitizeFootnoteHtml } from "../utils/footnoteHtml.js";
+import { shouldMoveBreakToHeading } from "../utils/pocKeepWithNext.js";
+export const pocPageKey = new PluginKey("pocPagination");
+export const PAGINATE_META = "poc-paginate";
+export 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 } }));
+  };
+}
+export 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;
+}
+export 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 = " ";
+  header.appendChild(content);
+  return header;
+}
+export 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;
+}
+export 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"]);
+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();
+    }
+  };
+}
+export 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) => {
+        if (inner.type.name === "footnoteRef" && inner.attrs.text) {
+          noteCounter += 1;
+          notes.push({ n: noteCounter, text: String(inner.attrs.text), size: inner.attrs.size ?? null });
+        }
+        return true;
+      });
+      items.push({
+        pos,
+        size: child.nodeSize,
+        top,
+        height: dom.offsetHeight,
+        notes,
+        // 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) => {
+    const height = notesH(pageNotes);
+    breaks.push({ pos, filler: Math.max(0, filler - height), pageNo, notes: pageNotes, notesH: height });
+    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) {
+      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();
+}
+export 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;
+}
+export 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);
+}
+export 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)));
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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);
+      }
+    }
+  });
+}

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

@@ -0,0 +1,112 @@
+export interface MinutaFile {
+    name: string;
+    url: string;
+}
+/** cabeçalho/rodapé da folha, editados no canvas (mesmo formato do case) */
+export interface MinutaChrome {
+    header?: string;
+    footer?: string;
+    headerScope?: 'all' | 'first';
+    footerScope?: 'all' | 'first';
+    showPageNumber?: boolean;
+}
+export interface Minuta {
+    id: string;
+    name: string;
+    status: 'PROCESSING' | 'READY' | 'ERROR';
+    files: MinutaFile[];
+    context?: string | null;
+    agentId?: string | null;
+    analysis?: MinutaAnalysis | null;
+    chrome?: MinutaChrome | null;
+    contentHtml?: string | null;
+    error?: string | null;
+    createdByEmail?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MinutaVersion {
+    id: string;
+    versionNumber: number;
+    versionType: 'initial' | 'auto' | 'manual';
+    comment?: string | null;
+    createdByEmail?: string | null;
+    createdAt: string;
+}
+/**
+ * Estado de âncora compartilhado pelas anotações: `trecho` é o recorte
+ * verbatim que ancora o item na minuta; quando o usuário edita esse recorte,
+ * a anotação vira `manual` (o trecho é atualizado pro texto editado e o
+ * original fica em `trechoOriginal` — se ele voltar, a anotação se restaura).
+ */
+export interface AnnotationAnchorState {
+    trecho?: string;
+    manual?: boolean;
+    trechoOriginal?: string;
+}
+export interface MinutaAnalysis {
+    resumo?: string;
+    teses?: Array<{
+        titulo: string;
+        fundamento?: string;
+        onde?: string;
+    } & AnnotationAnchorState>;
+    jurisprudencias?: Array<{
+        referencia: string;
+        orgao?: string;
+        tese?: string;
+        onde?: string;
+        fonte?: string;
+    } & AnnotationAnchorState>;
+    citacoes?: Array<{
+        tipo?: string;
+        referencia: string;
+        onde?: string;
+        como?: string;
+    } & AnnotationAnchorState>;
+    documentos?: Array<{
+        arquivo: string;
+        uso?: string;
+        partes?: string[];
+    }>;
+    fatos?: Array<{
+        dado: string;
+        documento?: string;
+        pagina?: number;
+        onde?: string;
+    } & AnnotationAnchorState>;
+    /** trechos verbatim de texto ADICIONADO pelo usuário (highlight cinza persistente) */
+    edicoesManuais?: string[];
+}
+/**
+ * Cliente das minutas avulsas via o proxy Nitro do módulo (`/api/minuta/*`).
+ * A autenticação acontece no proxy (JWT do usuário do host) — nada de
+ * segredos no browser.
+ */
+export declare function useMinutaApi(): {
+    fetchMinutas: () => Promise<Minuta[]>;
+    fetchMinutaById: (id: string) => Promise<Minuta>;
+    createMinuta: (input: {
+        name: string;
+        files: MinutaFile[];
+        context?: string;
+        agentId?: string;
+    }) => Promise<Minuta>;
+    updateMinuta: (id: string, patch: {
+        name?: string;
+        contentHtml?: string;
+        analysis?: MinutaAnalysis;
+        chrome?: MinutaChrome;
+    }) => Promise<Minuta>;
+    deleteMinuta: (id: string) => Promise<{
+        id: string;
+    }>;
+    uploadMinutaFile: (file: File) => Promise<MinutaFile>;
+    getDownloadUrl: (vaultUrl: string) => Promise<string>;
+    fetchVersions: (id: string) => Promise<MinutaVersion[]>;
+    fetchVersion: (id: string, versionNumber: number) => Promise<MinutaVersion & {
+        contentHtml: string;
+    }>;
+    createVersion: (id: string, comment?: string) => Promise<MinutaVersion>;
+    restoreVersion: (id: string, versionNumber: number) => Promise<Minuta>;
+};

package/dist/runtime/composables/useMinutaApi.js

@@ -0,0 +1,68 @@
+import { $fetch } from "ofetch";
+export function useMinutaApi() {
+  const base = "/api/minuta";
+  function fetchMinutas() {
+    return $fetch(base);
+  }
+  function fetchMinutaById(id) {
+    return $fetch(`${base}/${encodeURIComponent(id)}`);
+  }
+  function createMinuta(input) {
+    return $fetch(base, { method: "POST", body: input });
+  }
+  function updateMinuta(id, patch) {
+    return $fetch(`${base}/${encodeURIComponent(id)}`, { method: "PATCH", body: patch });
+  }
+  function deleteMinuta(id) {
+    return $fetch(`${base}/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+  async function uploadMinutaFile(file) {
+    const { uploadUrl, vaultUrl } = await $fetch(
+      `${base}/upload-url`,
+      { method: "POST", body: { fileName: file.name } }
+    );
+    const response = await fetch(uploadUrl, {
+      method: "PUT",
+      body: file,
+      headers: { "Content-Type": file.type || "application/octet-stream" }
+    });
+    if (!response.ok)
+      throw new Error(`Falha no upload de ${file.name}`);
+    return { name: file.name, url: vaultUrl };
+  }
+  async function getDownloadUrl(vaultUrl) {
+    const { downloadUrl } = await $fetch(`${base}/download-url`, {
+      method: "POST",
+      body: { vaultUrl }
+    });
+    return downloadUrl;
+  }
+  function fetchVersions(id) {
+    return $fetch(`${base}/${encodeURIComponent(id)}/versions`);
+  }
+  function fetchVersion(id, versionNumber) {
+    return $fetch(`${base}/${encodeURIComponent(id)}/versions/${versionNumber}`);
+  }
+  function createVersion(id, comment) {
+    return $fetch(`${base}/${encodeURIComponent(id)}/versions`, {
+      method: "POST",
+      body: comment?.trim() ? { comment: comment.trim() } : {}
+    });
+  }
+  function restoreVersion(id, versionNumber) {
+    return $fetch(`${base}/${encodeURIComponent(id)}/versions/${versionNumber}/restore`, { method: "POST" });
+  }
+  return {
+    fetchMinutas,
+    fetchMinutaById,
+    createMinuta,
+    updateMinuta,
+    deleteMinuta,
+    uploadMinutaFile,
+    getDownloadUrl,
+    fetchVersions,
+    fetchVersion,
+    createVersion,
+    restoreVersion
+  };
+}

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

@@ -0,0 +1,12 @@
+import type { Editor } from '@tiptap/core';
+/** mesmo escape do lazy-vault-images pro valor do atributo */
+export declare function escapeVaultAttr(value: string): string;
+export declare function decodeVaultAttr(value: string): string;
+/** tag de imagem que o editor insere após o upload */
+export declare function vaultImageHtml(src: string, vaultUrl: string): string;
+/**
+ * Re-resolve todas as imagens vault:// do documento (o src presignado salvo
+ * pode ter expirado). Transação fora do histórico de undo e marcada como
+ * programática (não vira "texto adicionado" no rastro manual).
+ */
+export declare function refreshVaultImages(editor: Editor, resolveUrl: (vaultUrl: string) => Promise<string>): Promise<number>;

package/dist/runtime/composables/vaultImages.js

@@ -0,0 +1,85 @@
+import { PROGRAMMATIC_META } from "./annotationAnchors.js";
+function escapeAttr(value) {
+  return value.replace(/&/g, "&").replace(/"/g, """);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function escapeVaultAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export function decodeVaultAttr(value) {
+  return value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+export function vaultImageHtml(src, vaultUrl) {
+  return `<img src="${escapeAttr(src)}" data-vault-src="${escapeVaultAttr(vaultUrl)}" style="width: 420px; height: auto; max-width: 100%;">`;
+}
+function swapSrcKeepRef(html, attrValue, freshUrl) {
+  const needle = `data-vault-src="${attrValue}"`;
+  if (!html.includes(needle))
+    return html;
+  const tagRe = new RegExp(`<img\\b[^>]*?${escapeRegExp(needle)}[^>]*?>`, "g");
+  return html.replace(tagRe, (tag) => tag.replace(/\ssrc="[^"]*"/, ` src="${escapeAttr(freshUrl)}"`));
+}
+export async function refreshVaultImages(editor, resolveUrl) {
+  if (!editor || editor.isDestroyed)
+    return 0;
+  const targets = [];
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type.name !== "htmlIsland")
+      return;
+    const html = String(node.attrs.html ?? "");
+    const refs = [...html.matchAll(/data-vault-src="([^"]+)"/g)].map((m) => m[1]);
+    if (refs.length)
+      targets.push({ pos, html, refs });
+  });
+  if (!targets.length)
+    return 0;
+  const unique = [...new Set(targets.flatMap((t) => t.refs))];
+  const resolved = /* @__PURE__ */ new Map();
+  await Promise.all(unique.map(async (attrValue) => {
+    try {
+      const fresh = await resolveUrl(decodeVaultAttr(attrValue));
+      if (!fresh)
+        return;
+      await new Promise((done) => {
+        const img = new Image();
+        const finish = () => done();
+        img.onload = finish;
+        img.onerror = finish;
+        setTimeout(finish, 4e3);
+        img.src = fresh;
+      });
+      resolved.set(attrValue, fresh);
+    } catch (error) {
+      console.error("minuta: falha ao resolver imagem do vault", attrValue, error);
+    }
+  }));
+  if (!resolved.size || editor.isDestroyed)
+    return 0;
+  const tr = editor.state.tr;
+  let touched = 0;
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type.name !== "htmlIsland")
+      return;
+    let html = String(node.attrs.html ?? "");
+    let changed = false;
+    for (const [attrValue, freshUrl] of resolved) {
+      const next = swapSrcKeepRef(html, attrValue, freshUrl);
+      if (next !== html) {
+        html = next;
+        changed = true;
+      }
+    }
+    if (changed) {
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, html });
+      touched++;
+    }
+  });
+  if (!touched)
+    return 0;
+  tr.setMeta("addToHistory", false);
+  tr.setMeta(PROGRAMMATIC_META, true);
+  editor.view.dispatch(tr);
+  return touched;
+}