@prolibu-suite/cobalt-core 0.10.4 → 0.11.0

package/dist/cjs/{index-2kMmd5-a.js → pagination-DV43TRj9.js}

@@ -1,7 +1,6 @@
 'use strict';
 
 var purify_es = require('./purify.es-DX41ZWS2.js');
-var toolbarConfig = require('./toolbar-config-CYACt9hh.js');
 
 // ::- Persistent data structure representing an ordered mapping from
 // strings to values, with some convenient update methods.
@@ -2657,7 +2656,7 @@ A DOM parser represents a strategy for parsing DOM content into a
 ProseMirror document conforming to a given schema. Its behavior is
 defined by an array of [rules](https://prosemirror.net/docs/ref/#model.ParseRule).
 */
-class DOMParser {
+let DOMParser$1 = class DOMParser {
     /**
     Create a parser that targets the given schema, using the given
     parsing rules.
@@ -2808,7 +2807,7 @@ class DOMParser {
         return schema.cached.domParser ||
             (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
     }
-}
+};
 const blockTags = {
     address: true, article: true, aside: true, blockquote: true, canvas: true,
     dd: true, div: true, dl: true, fieldset: true, figcaption: true, figure: true,
@@ -10007,7 +10006,7 @@ function skipIgnoredNodesBefore(view) {
                     break;
             }
         }
-        else if (isBlockNode(node)) {
+        else if (isBlockNode$1(node)) {
             break;
         }
         else {
@@ -10055,7 +10054,7 @@ function skipIgnoredNodesAfter(view) {
             else
                 break;
         }
-        else if (isBlockNode(node)) {
+        else if (isBlockNode$1(node)) {
             break;
         }
         else {
@@ -10081,7 +10080,7 @@ function skipIgnoredNodesAfter(view) {
     if (moveNode)
         setSelFocus(view, moveNode, moveOffset);
 }
-function isBlockNode(dom) {
+function isBlockNode$1(dom) {
     let desc = dom.pmViewDesc;
     return desc && desc.node && desc.node.isBlock;
 }
@@ -10361,7 +10360,7 @@ function parseFromClipboard(view, text, html, plainText, $context) {
             dom = child;
         }
     if (!slice) {
-        let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
+        let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser$1.fromSchema(view.state.schema);
         slice = parser.parseSlice(dom, {
             preserveWhitespace: !!(asText || sliceData),
             context: $context,
@@ -12462,7 +12461,7 @@ function parseBetween(view, from_, to_) {
         }
     }
     let startDoc = view.state.doc;
-    let parser = view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
+    let parser = view.someProp("domParser") || DOMParser$1.fromSchema(view.state.schema);
     let $from = startDoc.resolve(from);
     let sel = null, doc = parser.parse(parent, {
         topNode: $from.parent,
@@ -14324,12 +14323,12 @@ function createNodeFromContent(content, schema, options) {
         })
       });
       if (options.slice) {
-        DOMParser.fromSchema(contentCheckSchema).parseSlice(
+        DOMParser$1.fromSchema(contentCheckSchema).parseSlice(
           elementFromString(content),
           options.parseOptions
         );
       } else {
-        DOMParser.fromSchema(contentCheckSchema).parse(
+        DOMParser$1.fromSchema(contentCheckSchema).parse(
           elementFromString(content),
           options.parseOptions
         );
@@ -14340,7 +14339,7 @@ function createNodeFromContent(content, schema, options) {
         });
       }
     }
-    const parser = DOMParser.fromSchema(schema);
+    const parser = DOMParser$1.fromSchema(schema);
     if (options.slice) {
       return parser.parseSlice(elementFromString(content), options.parseOptions).content;
     }
@@ -34996,6 +34995,799 @@ var Subscript = Mark.create({
   }
 });
 
+function sanitizeFieldName(raw) {
+    return String(raw ?? '')
+        .trim()
+        .replace(/\s+/g, '_')
+        .replace(/[^\p{L}\p{N}_.]/gu, '_');
+}
+/** Admite un grupo `[…]` al final del contenido (enum en JSON). Nueva instancia por llamada (flag g). */
+function fieldTokenRegex() {
+    return /\[\[\s*([^[\]]+?(?:\[[^[\]]*\])?)\s*\]\]/g;
+}
+function parseFieldToken(inner) {
+    const parts = String(inner ?? '').split('|').map((p) => p.trim());
+    let raw = parts[0] ?? '';
+    const required = raw.endsWith('*');
+    if (required)
+        raw = raw.slice(0, -1);
+    const name = sanitizeFieldName(raw);
+    if (!name)
+        return null;
+    const type = parts[1] || 'string';
+    let values = null;
+    if (parts[2]?.startsWith('enum:')) {
+        const rawEnum = parts[2].slice(5).trim();
+        try {
+            const parsed = JSON.parse(rawEnum);
+            values = Array.isArray(parsed) ? parsed.map(String) : null;
+        }
+        catch {
+            values = rawEnum.split(',').map((v) => v.trim()).filter(Boolean);
+        }
+    }
+    return { name, required, type, enum: values };
+}
+
+/** Meta de las transacciones que escribe el HOST (valores): no son edición del usuario. */
+const FIELD_SYNC_META = 'coFieldSync';
+function parseEnumAttr(raw) {
+    if (!raw)
+        return null;
+    try {
+        const v = JSON.parse(raw);
+        return Array.isArray(v) ? v.map(String) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Lista de campos en orden de primera aparición (sin repetidos). Acepta un doc de ProseMirror o su JSON. */
+function collectFields(doc, into = []) {
+    const index = new Map(into.map((f, i) => [f.name, i]));
+    const visit = (attrs) => {
+        const name = attrs?.name;
+        if (!name)
+            return;
+        const at = index.get(name);
+        if (at === undefined) {
+            index.set(name, into.length);
+            into.push({ name, required: !!attrs.required, type: attrs.type || 'string', enum: attrs.enum ?? null });
+        }
+        else if (attrs.required) {
+            into[at].required = true;
+        }
+    };
+    if (typeof doc.descendants === 'function') {
+        doc.descendants((node) => {
+            if (node.type.name === 'mergeField') {
+                visit(node.attrs);
+                return false;
+            }
+            return true;
+        });
+    }
+    else {
+        const walk = (node) => {
+            if (!node)
+                return;
+            if (node.type === 'mergeField')
+                visit(node.attrs ?? {});
+            node.content?.forEach(walk);
+        };
+        walk(doc);
+    }
+    return into;
+}
+/** Textblocks tocados por las transacciones (para no recorrer todo el doc por tecla). */
+function touchedTextblocks(transactions, state) {
+    let ranges = [];
+    transactions.forEach((tr) => {
+        // Lo tocado por transacciones anteriores se lleva a las posiciones de ésta.
+        ranges = ranges.map(([a, b]) => [tr.mapping.map(a, -1), tr.mapping.map(b, 1)]);
+        if (!tr.docChanged)
+            return;
+        tr.mapping.maps.forEach((map, i) => {
+            map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+                const rest = tr.mapping.slice(i + 1);
+                ranges.push([rest.map(newStart, -1), rest.map(newEnd, 1)]);
+            });
+        });
+    });
+    const out = new Set();
+    const size = state.doc.content.size;
+    ranges.forEach(([from, to]) => {
+        state.doc.nodesBetween(Math.max(0, from), Math.min(size, to), (node, pos) => {
+            if (node.isTextblock) {
+                out.add(pos);
+                return false;
+            }
+            return true;
+        });
+    });
+    return Array.from(out);
+}
+const MergeField = Node3.create({
+    name: 'mergeField',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    addOptions() {
+        return { renameLabel: 'Field name' };
+    },
+    addAttributes() {
+        return {
+            name: { default: '', parseHTML: (el) => el.getAttribute('data-variable') || '', rendered: false },
+            value: { default: '', parseHTML: (el) => el.getAttribute('data-value') ?? '', rendered: false },
+            required: { default: false, parseHTML: (el) => el.getAttribute('data-required') === 'true', rendered: false },
+            type: { default: 'string', parseHTML: (el) => el.getAttribute('data-type') || 'string', rendered: false },
+            enum: { default: null, parseHTML: (el) => parseEnumAttr(el.getAttribute('data-enum')), rendered: false },
+        };
+    },
+    // Prioridad 100: gana a las marcas `span[style]` (color/tamaño), como en V1.
+    parseHTML() {
+        return [{ tag: 'span[data-variable]', priority: 100 }];
+    },
+    // Forma canónica (spec §3.4): SIN estilos (D9), atributos en orden fijo.
+    renderHTML({ node }) {
+        const { name, value, type, required } = node.attrs;
+        const attrs = {
+            class: 'variable-node',
+            'data-variable': name,
+            'data-value': value ?? '',
+            'data-type': type || 'string',
+            'data-required': required ? 'true' : 'false',
+        };
+        if (node.attrs.enum)
+            attrs['data-enum'] = JSON.stringify(node.attrs.enum);
+        attrs.contenteditable = 'false';
+        return ['span', attrs, value || `[[${name}]]`];
+    },
+    renderText({ node }) {
+        return node.attrs.value || `[[${node.attrs.name}]]`;
+    },
+    addNodeView() {
+        const renameLabel = this.options.renameLabel;
+        return ({ node, getPos, editor }) => {
+            const dom = document.createElement('span');
+            dom.className = 'co-doc-field';
+            dom.contentEditable = 'false';
+            let current = node;
+            let editing = false;
+            const paint = (n) => {
+                dom.textContent = n.attrs.value || `[[${n.attrs.name}]]`;
+                dom.classList.toggle('co-doc-field--empty', !n.attrs.value);
+                dom.classList.toggle('co-doc-field--required', !!n.attrs.required);
+                dom.setAttribute('data-variable', n.attrs.name);
+            };
+            const startRename = () => {
+                if (editing || !editor.isEditable)
+                    return;
+                editing = true;
+                const input = document.createElement('input');
+                input.className = 'co-doc-field__input';
+                input.value = current.attrs.name;
+                input.setAttribute('aria-label', renameLabel);
+                dom.textContent = '';
+                dom.appendChild(input);
+                input.focus();
+                input.select();
+                let done = false;
+                const finish = (commit) => {
+                    if (done)
+                        return;
+                    done = true;
+                    editing = false;
+                    const next = sanitizeFieldName(input.value);
+                    const pos = typeof getPos === 'function' ? getPos() : undefined;
+                    if (commit && next && next !== current.attrs.name && typeof pos === 'number') {
+                        // Como V1: el campo renombrado arranca vacío (solo ESTE nodo).
+                        editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, undefined, { ...current.attrs, name: next, value: '' }));
+                    }
+                    else {
+                        paint(current);
+                    }
+                };
+                input.addEventListener('keydown', (ev) => {
+                    ev.stopPropagation(); // Esc no debe cerrar el overlay del host
+                    if (ev.key === 'Enter') {
+                        ev.preventDefault();
+                        finish(true);
+                    }
+                    else if (ev.key === 'Escape') {
+                        ev.preventDefault();
+                        finish(false);
+                    }
+                });
+                input.addEventListener('blur', () => finish(false));
+            };
+            dom.addEventListener('dblclick', (ev) => {
+                ev.preventDefault();
+                startRename();
+            });
+            paint(node);
+            return {
+                dom,
+                update(next) {
+                    if (next.type.name !== 'mergeField')
+                        return false;
+                    current = next;
+                    if (!editing)
+                        paint(next);
+                    return true;
+                },
+                stopEvent: (ev) => ev.target instanceof HTMLInputElement,
+                ignoreMutation: () => true,
+            };
+        };
+    },
+    addCommands() {
+        return {
+            insertField: (name, opts = {}) => ({ commands }) => {
+                const clean = sanitizeFieldName(name);
+                if (!clean)
+                    return false;
+                return commands.insertContent({
+                    type: this.name,
+                    attrs: {
+                        name: clean,
+                        value: opts.value ?? '',
+                        required: !!opts.required,
+                        type: opts.type || 'string',
+                        enum: opts.enum ?? null,
+                    },
+                });
+            },
+            setFieldValues: (values) => ({ tr, state, dispatch }) => {
+                let changed = false;
+                state.doc.descendants((node, pos) => {
+                    if (node.type.name !== this.name)
+                        return true;
+                    if (!Object.prototype.hasOwnProperty.call(values, node.attrs.name))
+                        return false;
+                    const next = String(values[node.attrs.name] ?? '');
+                    if (next !== node.attrs.value) {
+                        changed = true;
+                        if (dispatch)
+                            tr.setNodeMarkup(pos, undefined, { ...node.attrs, value: next });
+                    }
+                    return false;
+                });
+                if (!changed)
+                    return false;
+                if (dispatch) {
+                    tr.setMeta(FIELD_SYNC_META, true);
+                    tr.setMeta('addToHistory', false);
+                }
+                return true;
+            },
+            renameField: (from, to) => ({ tr, state, dispatch }) => {
+                const clean = sanitizeFieldName(to);
+                if (!clean || clean === from)
+                    return false; // renombrar a sí mismo borraría los valores
+                let changed = false;
+                state.doc.descendants((node, pos) => {
+                    if (node.type.name !== this.name)
+                        return true;
+                    if (node.attrs.name === from) {
+                        changed = true;
+                        if (dispatch)
+                            tr.setNodeMarkup(pos, undefined, { ...node.attrs, name: clean, value: '' });
+                    }
+                    return false;
+                });
+                return changed;
+            },
+        };
+    },
+    addProseMirrorPlugins() {
+        const type = this.type;
+        return [
+            new Plugin({
+                key: new PluginKey('coMergeFieldTokens'),
+                // Convierte `[[…]]` escritos o pegados en campos, solo en los textblocks tocados.
+                appendTransaction: (transactions, _old, state) => {
+                    if (!transactions.some((t) => t.docChanged && !t.getMeta(FIELD_SYNC_META)))
+                        return null;
+                    const blocks = touchedTextblocks(transactions, state);
+                    if (!blocks.length)
+                        return null;
+                    const hits = [];
+                    blocks.forEach((blockPos) => {
+                        const block = state.doc.nodeAt(blockPos);
+                        if (!block || block.type.spec.code)
+                            return;
+                        block.forEach((child, offset) => {
+                            if (!child.isText || !child.text || !child.text.includes('[['))
+                                return;
+                            const re = fieldTokenRegex();
+                            let m;
+                            while ((m = re.exec(child.text)) !== null) {
+                                const def = parseFieldToken(m[1]);
+                                if (!def)
+                                    continue;
+                                const from = blockPos + 1 + offset + m.index;
+                                hits.push({ from, to: from + m[0].length, def });
+                            }
+                        });
+                    });
+                    if (!hits.length)
+                        return null;
+                    const tr = state.tr;
+                    hits
+                        .sort((a, b) => b.from - a.from)
+                        .forEach(({ from, to, def }) => {
+                        tr.replaceWith(from, to, type.create({ ...def, value: '' }));
+                    });
+                    return tr;
+                },
+            }),
+        ];
+    },
+});
+
+/**
+ * Marcador de firma `⟦sig:N⟧`. La forma canónica es la de V1
+ * (tiptap-editor-html/utils/normalizeSignatureSlots.js) byte a byte: pdf.js lee
+ * el token transparente de la capa de texto del PDF y deriva la posición.
+ * Con font-size:1px Chromium colapsaba glifos: el token va a 8px y transparente.
+ *
+ * ⚠️ `editor.getHTML()` NO es la forma canónica: el DOMSerializer de ProseMirror
+ * escribe `style` por CSSOM (`top:0` → `top: 0px;`). La forma exacta sale de
+ * `signatureSlotHtml()` o de un serializador que escriba `style` con `setAttribute`
+ * (`serializePrintHtml`).
+ */
+const signatureToken = (n) => `⟦sig:${n}⟧`;
+const SIGNATURE_TOKEN_STYLE = 'position:absolute;top:0;left:0;color:transparent;font-size:8px;line-height:1;white-space:nowrap;pointer-events:none;user-select:none';
+const signatureBoxStyle = (w, h) => `display:inline-block;position:relative;width:${w}px;height:${h}px;vertical-align:top`;
+const SIGNATURE_DEFAULT_W = 150;
+const SIGNATURE_DEFAULT_H = 50;
+function nextFreeSlot(used = []) {
+    const taken = new Set(used);
+    let n = 1;
+    while (taken.has(n))
+        n += 1;
+    return n;
+}
+/** Spec de la forma canónica (orden de atributos = el de V1). Lo usa `renderHTML`. */
+function signatureSlotSpec({ slot, w, h }) {
+    return [
+        'span',
+        {
+            'data-sig-slot': String(slot),
+            'data-w': String(w),
+            'data-h': String(h),
+            contenteditable: 'false',
+            style: signatureBoxStyle(w, h),
+        },
+        ['span', { style: SIGNATURE_TOKEN_STYLE }, signatureToken(slot)],
+    ];
+}
+/**
+ * La forma canónica como string, armada del MISMO spec que `renderHTML` y sin pasar
+ * por CSSOM. Los valores son números y constantes propias: no hay nada que escapar.
+ */
+function signatureSlotHtml(attrs) {
+    const [tag, boxAttrs, [innerTag, innerAttrs, text]] = signatureSlotSpec(attrs);
+    const attrsOf = (a) => Object.entries(a)
+        .map(([k, v]) => ` ${k}="${v}"`)
+        .join('');
+    return `<${tag}${attrsOf(boxAttrs)}><${innerTag}${attrsOf(innerAttrs)}>${text}</${innerTag}></${tag}>`;
+}
+const toInt = (v, fallback) => {
+    const n = parseInt(v ?? '', 10);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+const SignatureSlot = Node3.create({
+    name: 'signatureSlot',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    addOptions() {
+        return { label: (slot) => `Signature ${slot}` };
+    },
+    addAttributes() {
+        return {
+            slot: { default: 1, parseHTML: (el) => toInt(el.getAttribute('data-sig-slot'), 1), rendered: false },
+            w: { default: SIGNATURE_DEFAULT_W, parseHTML: (el) => toInt(el.getAttribute('data-w'), SIGNATURE_DEFAULT_W), rendered: false },
+            h: { default: SIGNATURE_DEFAULT_H, parseHTML: (el) => toInt(el.getAttribute('data-h'), SIGNATURE_DEFAULT_H), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span[data-sig-slot]', priority: 100 }];
+    },
+    renderHTML({ node }) {
+        return signatureSlotSpec(node.attrs);
+    },
+    renderText({ node }) {
+        return signatureToken(node.attrs.slot);
+    },
+    addNodeView() {
+        const label = this.options.label;
+        return ({ node }) => {
+            const dom = document.createElement('span');
+            dom.className = 'co-doc-signature';
+            dom.contentEditable = 'false';
+            const paint = (n) => {
+                dom.style.width = `${n.attrs.w}px`;
+                dom.style.height = `${n.attrs.h}px`;
+                dom.textContent = label(n.attrs.slot);
+                dom.setAttribute('data-sig-slot', String(n.attrs.slot));
+            };
+            paint(node);
+            return {
+                dom,
+                update(next) {
+                    if (next.type.name !== 'signatureSlot')
+                        return false;
+                    paint(next);
+                    return true;
+                },
+                ignoreMutation: () => true,
+            };
+        };
+    },
+    addCommands() {
+        return {
+            insertSignatureSlot: (size = {}) => ({ state, commands }) => {
+                const used = [];
+                state.doc.descendants((n) => {
+                    if (n.type.name === this.name)
+                        used.push(n.attrs.slot);
+                });
+                return commands.insertContent({
+                    type: this.name,
+                    attrs: { slot: nextFreeSlot(used), w: size.w ?? SIGNATURE_DEFAULT_W, h: size.h ?? SIGNATURE_DEFAULT_H },
+                });
+            },
+        };
+    },
+});
+
+/** Tamaño base del cuerpo de impresión (SharedContractUtils: 14px/1.5). */
+const BASE_FONT_PX = 14;
+/** Valor crudo de una propiedad del atributo style (conserva `#hex`; `el.style.color` lo pasaría a rgb). */
+function rawStyleValue(el, prop) {
+    const style = el.getAttribute('style') || '';
+    for (const decl of style.split(';')) {
+        const i = decl.indexOf(':');
+        if (i <= 0)
+            continue;
+        if (decl.slice(0, i).trim().toLowerCase() === prop) {
+            const v = decl.slice(i + 1).trim();
+            return v || null;
+        }
+    }
+    return null;
+}
+/** V1 pasaba mal las unidades (12pt → 12px, 1.5em → 1px). Acá se convierten a px de verdad. */
+function normalizeFontSizePx(v) {
+    if (v == null)
+        return null;
+    const m = /^\s*(\d+(?:\.\d+)?)\s*(px|pt|em|rem|%)?\s*$/i.exec(String(v));
+    if (!m)
+        return null;
+    const n = parseFloat(m[1]);
+    const unit = (m[2] || 'px').toLowerCase();
+    const px = unit === 'px' ? n : unit === 'pt' ? (n * 4) / 3 : unit === '%' ? (n / 100) * BASE_FONT_PX : n * BASE_FONT_PX;
+    const r = Math.round(px);
+    return r >= 1 && r <= 400 ? `${r}px` : null;
+}
+/**
+ * Color de texto en la forma de V1: `<span class="editor-text-style" style="color: X">`,
+ * SIEMPRE por fuera del tamaño (un span con color + tamaño pierde el color en V1).
+ * Se llama `textStyle` para que la barra lea `getAttributes('textStyle').color`.
+ * Prioridad alta = marca más externa (link 1003 > color 1002 > tamaño 1001 > resto 100).
+ *
+ * La regla de parse queda con la prioridad por defecto (50): la firma
+ * (`span[data-sig-slot]`) y el campo (`span[data-variable]`) van a 100 y le ganan
+ * aunque lleven `style` inline.
+ */
+const PrintTextColor = Mark.create({
+    name: 'textStyle',
+    priority: 1002,
+    addAttributes() {
+        return {
+            color: { default: null, parseHTML: (el) => rawStyleValue(el, 'color'), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span', consuming: false, getAttrs: (el) => (rawStyleValue(el, 'color') ? {} : false) }];
+    },
+    renderHTML({ mark }) {
+        return ['span', { class: 'editor-text-style', style: `color: ${mark.attrs.color}` }, 0];
+    },
+    addCommands() {
+        return {
+            setColor: (color) => ({ commands }) => commands.setMark(this.name, { color }),
+            unsetColor: () => ({ commands }) => commands.unsetMark(this.name),
+        };
+    },
+});
+/** Tamaño en px como marca APARTE, anidada dentro del color: `<span style="font-size: Npx">`. */
+const PrintFontSize = Mark.create({
+    name: 'printFontSize',
+    priority: 1001,
+    addAttributes() {
+        return {
+            size: { default: null, parseHTML: (el) => normalizeFontSizePx(rawStyleValue(el, 'font-size')), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'span', consuming: false, getAttrs: (el) => (normalizeFontSizePx(rawStyleValue(el, 'font-size')) ? {} : false) }];
+    },
+    renderHTML({ mark }) {
+        return ['span', { style: `font-size: ${mark.attrs.size}` }, 0];
+    },
+    addCommands() {
+        return {
+            setFontSize: (size) => ({ commands }) => {
+                const px = normalizeFontSizePx(size);
+                return px ? commands.setMark(this.name, { size: px }) : false;
+            },
+            unsetFontSize: () => ({ commands }) => commands.unsetMark(this.name),
+        };
+    },
+});
+
+const IMAGE_LAYOUT_MODES = ['inline', 'wrap-left', 'wrap-right', 'break'];
+const MODE_PROPS = new Set(['float', 'clear', 'display', 'padding-left', 'padding-right']);
+const MODE_STYLES = {
+    inline: { wrapper: ['display: inline-block'], container: ['display: inline-block'] },
+    'wrap-left': { wrapper: ['display: inline-block', 'float: left'], container: ['display: inline-block', 'float: left', 'padding-right: 8px'] },
+    'wrap-right': { wrapper: ['display: inline-block', 'float: right'], container: ['display: inline-block', 'float: right', 'padding-left: 8px'] },
+    break: { wrapper: ['display: block'], container: ['display: block'] },
+};
+/** Una imagen nueva nace en línea (ruling del ledger); al leer una de V1 manda su wrapperstyle. */
+const DEFAULT_WRAPPER_STYLE = 'display: inline-block;';
+const DEFAULT_CONTAINER_STYLE = 'height: auto; cursor: pointer; display: inline-block;';
+function stripModeProps(style) {
+    return String(style || '')
+        .split(';')
+        .map((d) => d.trim())
+        .filter((d) => d.includes(':'))
+        .filter((d) => !MODE_PROPS.has(d.slice(0, d.indexOf(':')).trim().toLowerCase()));
+}
+function applyImageLayoutMode(mode, { wrapperStyle = '', containerStyle = '' } = {}) {
+    const preset = MODE_STYLES[mode];
+    if (!preset)
+        return { wrapperStyle: wrapperStyle || '', containerStyle: containerStyle || '' };
+    const join = (mods, rest) => [...mods, ...rest].join('; ').replace(/;?\s*$/, ';');
+    return {
+        wrapperStyle: join(preset.wrapper, stripModeProps(wrapperStyle || '')),
+        containerStyle: join(preset.container, stripModeProps(containerStyle || '')),
+    };
+}
+function getImageLayoutMode({ wrapperStyle = '', containerStyle = '' } = {}) {
+    const style = `${containerStyle || ''};${wrapperStyle || ''}`.toLowerCase();
+    if (/float:\s*left/.test(style))
+        return 'wrap-left';
+    if (/float:\s*right/.test(style))
+        return 'wrap-right';
+    if (/display:\s*block\b/.test(style))
+        return 'break';
+    return 'inline';
+}
+const HEADER_IMG_MAX = { w: 400, h: 40 };
+/** Ancho que entra en la banda del encabezado (port de headerContainerStyle de V1). */
+function headerImageWidth(dims, max = HEADER_IMG_MAX) {
+    if (!dims || !dims.w || !dims.h)
+        return null;
+    const scale = Math.min(1, max.h / dims.h, max.w / dims.w);
+    return Math.max(1, Math.round(dims.w * scale));
+}
+/**
+ * `width:` anclado a inicio de declaración: sin el ancla, `min-width`/`max-width` también
+ * matchean y se leía (y se pisaba) el ancho equivocado de un `containerstyle` de V1.
+ */
+const WIDTH_DECL = /(^|;)(\s*)width:\s*([0-9.]+)px/i;
+function withWidth(style, width) {
+    if (!width)
+        return style;
+    const decl = `width: ${width}px`;
+    return WIDTH_DECL.test(style)
+        ? style.replace(WIDTH_DECL, (_m, sep, ws) => `${sep}${ws}${decl}`)
+        : `${decl}; ${style}`.trim();
+}
+function parseWidth(el) {
+    const attr = parseInt(el.getAttribute('width') || '', 10);
+    if (attr > 0)
+        return attr;
+    const m = WIDTH_DECL.exec(el.getAttribute('containerstyle') || el.getAttribute('style') || '');
+    return m ? Math.round(parseFloat(m[3])) : null;
+}
+/**
+ * H10: el node view de resize de Tiptap solo copia los atributos RENDERIZADOS, y
+ * `wrapperStyle`/`containerStyle` no lo son → en el editor toda imagen se veía en línea.
+ * Se lleva el modo al contenedor (`[data-resize-container]`) para que la hoja pagine
+ * como el PDF. `inline-flex`/`flex` (no `inline-block`/`block`): el contenedor de
+ * resize los necesita para ubicar las manijas.
+ */
+function syncImageModeToContainer(container, node) {
+    const mode = getImageLayoutMode(node.attrs);
+    container.dataset.imageLayout = mode;
+    container.style.float = mode === 'wrap-left' ? 'left' : mode === 'wrap-right' ? 'right' : '';
+    container.style.paddingLeft = mode === 'wrap-right' ? '8px' : '';
+    container.style.paddingRight = mode === 'wrap-left' ? '8px' : '';
+    container.style.display = mode === 'break' ? 'flex' : 'inline-flex';
+}
+const PrintImage = Image.extend({
+    name: 'image',
+    addOptions() {
+        return { ...this.parent?.(), header: false };
+    },
+    addAttributes() {
+        return {
+            ...this.parent?.(),
+            width: { default: null, parseHTML: (el) => parseWidth(el), rendered: false },
+            dataFileId: { default: null, parseHTML: (el) => el.getAttribute('data-file-id'), rendered: false },
+            containerStyle: { default: null, parseHTML: (el) => el.getAttribute('containerstyle'), rendered: false },
+            wrapperStyle: { default: null, parseHTML: (el) => el.getAttribute('wrapperstyle'), rendered: false },
+        };
+    },
+    parseHTML() {
+        return [{ tag: this.options.allowBase64 ? 'img[src]' : 'img[src]:not([src^="data:"])', priority: 100 }];
+    },
+    renderHTML({ node }) {
+        const a = node.attrs;
+        const width = a.width ? Math.round(Number(a.width)) : null;
+        const wrapper = a.wrapperStyle || DEFAULT_WRAPPER_STYLE;
+        const container = withWidth(a.containerStyle || DEFAULT_CONTAINER_STYLE, width);
+        const img = { src: a.src };
+        if (a.alt)
+            img.alt = a.alt;
+        if (a.title)
+            img.title = a.title;
+        if (a.dataFileId)
+            img['data-file-id'] = String(a.dataFileId);
+        if (width) {
+            img.width = String(width);
+            img.style = this.options.header ? `width: ${width}px; height: auto;` : `width: ${width}px;`;
+        }
+        img.containerstyle = container;
+        img.wrapperstyle = wrapper;
+        return ['span', { style: wrapper }, ['img', img]];
+    },
+    addNodeView() {
+        const parent = this.parent?.();
+        if (!parent)
+            return null;
+        return (props) => {
+            const view = parent(props);
+            const container = view.dom;
+            syncImageModeToContainer(container, props.node);
+            const update = view.update?.bind(view);
+            view.update = (node, decorations, inner) => {
+                const ok = update ? update(node, decorations, inner) : node.type === props.node.type;
+                if (ok)
+                    syncImageModeToContainer(container, node);
+                return ok;
+            };
+            return view;
+        };
+    },
+    addCommands() {
+        return {
+            ...this.parent?.(),
+            setImageLayoutMode: (mode) => ({ state, tr, dispatch }) => {
+                const sel = state.selection;
+                if (!(sel instanceof NodeSelection) || sel.node.type.name !== this.name)
+                    return false;
+                if (dispatch) {
+                    const next = applyImageLayoutMode(mode, {
+                        wrapperStyle: sel.node.attrs.wrapperStyle || DEFAULT_WRAPPER_STYLE,
+                        containerStyle: withWidth(sel.node.attrs.containerStyle || DEFAULT_CONTAINER_STYLE, sel.node.attrs.width),
+                    });
+                    tr.setNodeMarkup(sel.from, undefined, { ...sel.node.attrs, ...next });
+                    // H7: la NodeSelection no sobrevive al reemplazo de la hoja; sin esto la barra de imagen se cierra.
+                    tr.setSelection(NodeSelection.create(tr.doc, sel.from));
+                }
+                return true;
+            },
+        };
+    },
+});
+
+/** Validación de V1 (tiptap-editor-html/extensions/index.js): exige un `.`, rechaza `/` y `./`. */
+const printLinkAllowed = (url, ctx) => ctx.defaultValidate(url) && !url.startsWith('./') && !url.startsWith('/') && url.includes('.');
+/** Autolink APAGADO: generaba `<a>` dentro de `{{ }}` y rompía Handlebars. Prioridad 1003 = marca más externa. */
+const PrintLink = Link.extend({ inclusive: () => false, priority: 1003 }).configure({
+    autolink: false,
+    openOnClick: false,
+    defaultProtocol: 'https',
+    protocols: ['mailto', { scheme: 'tel', optionalSlashes: true }],
+    HTMLAttributes: { target: '_blank', rel: 'noopener noreferrer', class: 'editor-link' },
+    isAllowedUri: printLinkAllowed,
+});
+
+/** Resalta `{{ … }}` con una DECORACIÓN: no toca el documento ni se serializa. */
+const HB_RE = /\{\{[^}]*\}\}/g;
+function build(doc) {
+    const decos = [];
+    doc.descendants((node, pos) => {
+        if (!node.isText || !node.text)
+            return true;
+        HB_RE.lastIndex = 0;
+        let m;
+        while ((m = HB_RE.exec(node.text)) !== null) {
+            decos.push(Decoration.inline(pos + m.index, pos + m.index + m[0].length, { class: 'co-doc-hb' }));
+        }
+        return true;
+    });
+    return DecorationSet.create(doc, decos);
+}
+const HandlebarsHighlight = Extension.create({
+    name: 'handlebarsHighlight',
+    addProseMirrorPlugins() {
+        const key = new PluginKey('coHandlebarsHighlight');
+        return [
+            new Plugin({
+                key,
+                state: {
+                    init: (_config, { doc }) => build(doc),
+                    apply: (tr, old) => (tr.docChanged ? build(tr.doc) : old),
+                },
+                props: {
+                    decorations(state) {
+                        return key.getState(state);
+                    },
+                },
+            }),
+        ];
+    },
+});
+
+/**
+ * Presets `print` (cuerpo) y `print-header` (banda). Paridad ESTRICTA de
+ * funciones de V1 (spec §3.5/§3.6, D7): sin subrayado, familia, peso,
+ * interlineado, espaciado ni sangría; autolink apagado; sin nodo `variable`
+ * (comparte selector `span[data-variable]` con el campo). `trailingNode` apagado:
+ * V1 no lo tenía y una tabla al final sumaría una línea vacía al PDF.
+ * Las etiquetas (`labels`) las localiza el host; sin ellas quedan en inglés.
+ */
+function getPrintExtensions(preset, opts = {}) {
+    const header = preset === 'print-header';
+    const { features = {}, labels = {} } = opts;
+    const starter = { underline: false, link: false, trailingNode: false };
+    if (header) {
+        Object.assign(starter, {
+            heading: false, bulletList: false, orderedList: false, listItem: false, listKeymap: false,
+            blockquote: false, codeBlock: false, horizontalRule: false,
+        });
+    }
+    else {
+        starter.heading = { levels: [1, 2, 3, 4] };
+    }
+    const exts = [
+        StarterKit.configure(starter),
+        PrintTextColor,
+        PrintFontSize,
+        Highlight.configure({ multicolor: true }),
+        TextAlign.configure({ types: header ? ['paragraph'] : ['heading', 'paragraph'] }),
+        HandlebarsHighlight,
+    ];
+    if (!header) {
+        exts.push(PrintLink, Table.configure({ resizable: true, renderWrapper: true }), TableRow, TableHeader, TableCell);
+    }
+    exts.push(PrintImage.configure({
+        inline: true,
+        allowBase64: true,
+        header,
+        resize: header
+            ? false
+            : { enabled: true, directions: ['left', 'right', 'bottom-left', 'bottom-right'], minWidth: 50, minHeight: 20, alwaysPreserveAspectRatio: true },
+    }));
+    if (features.fields !== false) {
+        exts.push(MergeField.configure({ renameLabel: labels.fieldName ?? 'Field name' }));
+    }
+    if (!header && features.signatureSlots !== false) {
+        exts.push(labels.signature ? SignatureSlot.configure({ label: labels.signature }) : SignatureSlot);
+    }
+    return exts;
+}
+
 /** Shared link configuration — never auto-opens inside the editor, safe rel. */
 const LINK_CONFIG = {
     openOnClick: false,
@@ -35074,6 +35866,8 @@ const PRESET_TOOLBAR = {
     email: 'full',
     document: 'full',
     'block-email': 'basic',
+    print: 'document',
+    'print-header': 'document',
 };
 /** Suggested max length per preset (null = no limit). */
 const PRESET_MAXLENGTH = {
@@ -35083,10 +35877,22 @@ const PRESET_MAXLENGTH = {
     email: null,
     document: null,
     'block-email': null,
+    print: null,
+    'print-header': null,
 };
 /** Build the ordered extension array for a preset. */
 function getExtensions(preset = 'task', options = {}) {
-    const { placeholder, maxLength, features = {}, includeUiExtensions = true } = options;
+    const { placeholder, maxLength, features = {}, includeUiExtensions = true, labels } = options;
+    // Presets de impresión: schema propio (spec contracts-v2-contract-editor §3.5/§3.6).
+    if (preset === 'print' || preset === 'print-header') {
+        const exts = getPrintExtensions(preset, {
+            features: { fields: features.fields, signatureSlots: features.signatureSlots },
+            labels,
+        });
+        if (includeUiExtensions && placeholder)
+            exts.push(Placeholder.configure({ placeholder }));
+        return exts;
+    }
     const config = STARTERKIT_CONFIG[preset] ?? STARTERKIT_CONFIG.task;
     const exts = [StarterKit.configure(config), CobaltLink];
     // Color requires TextStyle to be registered first. Only presets that keep
@@ -35184,7 +35990,573 @@ function defaultToolbarForPreset(preset = 'task') {
 function maxLengthForPreset(preset = 'task') {
     return PRESET_MAXLENGTH[preset] ?? null;
 }
-const PRESETS = ['comment', 'task', 'notes', 'email', 'document', 'block-email'];
+const PRESETS = ['comment', 'task', 'notes', 'email', 'document', 'block-email', 'print', 'print-header'];
+
+// src/generateHTML.ts
+function getHTMLFromFragment(doc, schema, options) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "getHTMLFromFragment can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
+    );
+  }
+  const wrap = window.document.createElement("div");
+  DOMSerializer.fromSchema(schema).serializeFragment(
+    doc.content,
+    {
+      document: window.document
+    },
+    wrap
+  );
+  return wrap.innerHTML;
+}
+
+// src/generateHTML.ts
+function generateHTML(doc, extensions) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "generateHTML can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
+    );
+  }
+  const schema = getSchema(extensions);
+  const contentNode = Node$1.fromJSON(schema, doc);
+  return getHTMLFromFragment(contentNode, schema);
+}
+function generateJSON(html, extensions, options) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "generateJSON can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
+    );
+  }
+  const schema = getSchema(extensions);
+  const doc = new window.DOMParser().parseFromString(html, "text/html");
+  if (!doc) {
+    throw new Error("Failed to parse HTML string");
+  }
+  return DOMParser$1.fromSchema(schema).parse(doc.body, options).toJSON();
+}
+
+const BASE_INLINE = ['p', 'br', 'strong', 'em', 'a', 'span'];
+const BASE_ATTR = ['href', 'target', 'rel', 'data-mention-id', 'data-mention-label'];
+const SANITIZE_CONFIGS = {
+    // Más ancho que su schema A PROPÓSITO (única excepción al lock-step): el
+    // editor `comment` no puede autorar listas ni headings (STARTERKIT_CONFIG los
+    // apaga y ProseMirror descarta esos nodos al parsear el paste), pero el
+    // VIEWER tiene que pintarlos cuando el HTML entra por API — una nota de
+    // enriquecimiento (Apollo.io) trae <ul>/<li>/<h4> y con KEEP_CONTENT el
+    // texto se hoisteaba al padre: lista corrida, heading fundido en el cuerpo.
+    // Espejo inline en core/co-rich-text-viewer.tsx (ALLOWED_TAGS.comment).
+    comment: {
+        ALLOWED_TAGS: [...BASE_INLINE, 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4'],
+        ALLOWED_ATTR: [...BASE_ATTR],
+        ALLOW_DATA_ATTR: false,
+    },
+    task: {
+        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'input', 'label'],
+        ALLOWED_ATTR: [...BASE_ATTR, 'type', 'checked', 'disabled', 'data-type', 'data-checked', 'data-variant'],
+        ALLOW_DATA_ATTR: false,
+    },
+    // Lock-step con getExtensions('notes'): task sin checklists + TextStyle/Color
+    // (`style` capado a STYLE_ALLOWED_PROPS) + Highlight multicolor (`mark` con
+    // `data-color`).
+    notes: {
+        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'mark'],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-color'],
+        ALLOW_DATA_ATTR: false,
+    },
+    email: {
+        ALLOWED_TAGS: [
+            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
+            'h2', 'h3', 'div', 'img',
+        ],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout'],
+        ALLOW_DATA_ATTR: false,
+    },
+    document: {
+        ALLOWED_TAGS: [
+            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
+            'h1', 'h2', 'h3', 'h4', 'hr', 'div', 'mark', 'img',
+            'table', 'thead', 'tbody', 'tr', 'th', 'td',
+            'input', 'label', 'iframe',
+        ],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'colspan', 'rowspan', 'src', 'alt', 'width', 'height', 'type', 'checked', 'disabled', 'allowfullscreen', 'frameborder', 'allow', 'loading'],
+        ALLOW_DATA_ATTR: true,
+    },
+    'block-email': {
+        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'h2', 'h3', 'div', 'img'],
+        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout', 'data-type', 'data-label', 'data-href', 'data-bg', 'data-color', 'data-height'],
+        ALLOW_DATA_ATTR: false,
+    },
+    // Espejo de getPrintExtensions('print'): cuerpo del documento de impresión.
+    // `class` y data-* son parte de la forma que V1 re-parsea (editor-text-style,
+    // variable-node, editor-link, tableWrapper, trailingBreak, data-variable…).
+    print: {
+        ALLOWED_TAGS: [
+            'p', 'br', 'strong', 'em', 's', 'code', 'a', 'span', 'mark',
+            'h1', 'h2', 'h3', 'h4', 'ul', 'ol', 'li', 'blockquote', 'pre', 'hr', 'img', 'div',
+            'table', 'colgroup', 'col', 'thead', 'tbody', 'tr', 'th', 'td',
+        ],
+        ALLOWED_ATTR: [
+            'href', 'target', 'rel', 'class', 'style', 'src', 'alt', 'title', 'width', 'height',
+            'colspan', 'rowspan', 'colwidth', 'start', 'contenteditable', 'containerstyle', 'wrapperstyle',
+        ],
+        ALLOW_DATA_ATTR: true,
+        ADD_URI_SAFE_ATTR: ['containerstyle', 'wrapperstyle'],
+    },
+    // Espejo de getPrintExtensions('print-header'): la banda del encabezado.
+    'print-header': {
+        ALLOWED_TAGS: ['p', 'br', 'strong', 'em', 's', 'code', 'span', 'mark', 'img'],
+        ALLOWED_ATTR: ['class', 'style', 'src', 'alt', 'title', 'width', 'height', 'contenteditable', 'containerstyle', 'wrapperstyle'],
+        ALLOW_DATA_ATTR: true,
+        ADD_URI_SAFE_ATTR: ['containerstyle', 'wrapperstyle'],
+    },
+};
+/**
+ * `<iframe>`s are permitted only with an `https:` source (blocks javascript:,
+ * data:, and plain http: embeds). This is what makes allowing iframes safe-ish
+ * for a trusted-author document; YouTube embeds satisfy it too.
+ */
+const SAFE_IFRAME_SRC_RE = /^https:\/\/[^\s"'<>]+$/i;
+/** Tags forbidden in every preset, regardless of the allow-list. */
+const FORBID_TAGS = ['script', 'object', 'embed', 'form', 'textarea', 'style'];
+/** Attributes forbidden in every preset (event handlers handled by DOMPurify itself). */
+const FORBID_ATTR = ['onerror', 'onload', 'onclick'];
+/**
+ * Resolve the effective config for a preset + feature overrides. Features can
+ * only ADD capabilities (mirroring `getExtensions`, where they register extra
+ * nodes); they never narrow a preset's base whitelist.
+ */
+function configFor(preset, features) {
+    const cfg = SANITIZE_CONFIGS[preset] ?? SANITIZE_CONFIGS.task;
+    if (!features)
+        return cfg;
+    const tags = new Set(cfg.ALLOWED_TAGS);
+    const attr = new Set(cfg.ALLOWED_ATTR);
+    if (features.image) {
+        tags.add('img');
+        ['src', 'alt', 'width', 'height'].forEach((a) => attr.add(a));
+    }
+    if (features.variables)
+        attr.add('data-variable');
+    if (features.mentions) {
+        // data-mention-id/label ya están en BASE_ATTR. Los attrs del markup V1
+        // (quill-mention) se suman porque el BACKEND los parsea para notificar —
+        // re-editar una nota no debe destruirlos.
+        // Espejo inline en core/co-rich-text-viewer.tsx (el viewer no importa este módulo para no cargar el engine) — si cambias esta lista, cambia la del viewer.
+        ['data-id', 'data-value', 'data-denotation-char', 'data-index'].forEach((a) => attr.add(a));
+    }
+    return { ...cfg, ALLOWED_TAGS: [...tags], ALLOWED_ATTR: [...attr] };
+}
+/**
+ * `style` is only allowed in notes/email/document, and even there we cap it to
+ * the properties our extensions actually emit (TextStyle/Color/TextAlign,
+ * ListStyleExtension's `list-style-type`). Everything else — position,
+ * background-image url(), etc. — is UI-redressing/tracking surface.
+ */
+const STYLE_ALLOWED_PROPS = new Set(['color', 'background-color', 'text-align', 'list-style-type']);
+const UNSAFE_STYLE_VALUE = /url\s*\(|expression\s*\(/i;
+const DEFAULT_STYLE_POLICY = {
+    attrs: new Set(['style']),
+    allows: (prop) => STYLE_ALLOWED_PROPS.has(prop),
+    keepOriginalWhenClean: false,
+};
+const COLOR_VALUE = /^(#[0-9a-f]{3,8}|rgba?\([\d.\s,%]+\)|hsla?\([\d.\s,%deg]+\)|[a-z]+)$/i;
+const LENGTH_TOKEN = /^(-?\d+(\.\d+)?(px|pt|em|rem|%|mm|cm|in)?|auto)$/i;
+const lengths = (v) => v.split(/\s+/).every((t) => LENGTH_TOKEN.test(t));
+const oneOf = (re) => (v) => re.test(v);
+/** Lo que emiten las extensiones del preset print y la firma canónica (spec §3.4, §4.1). */
+const PRINT_STYLE_RULES = {
+    color: oneOf(COLOR_VALUE),
+    'background-color': oneOf(COLOR_VALUE),
+    'text-align': oneOf(/^(left|center|right|justify)$/i),
+    'font-size': oneOf(/^\d+(\.\d+)?(px|pt|em|rem|%)$/i),
+    width: lengths,
+    height: lengths,
+    'min-width': lengths,
+    'max-width': lengths,
+    display: oneOf(/^(inline-block|inline|block|flex|inline-flex)$/i),
+    float: oneOf(/^(left|right|none)$/i),
+    margin: lengths,
+    'margin-top': lengths,
+    'margin-right': lengths,
+    'margin-bottom': lengths,
+    'margin-left': lengths,
+    padding: lengths,
+    'padding-top': lengths,
+    'padding-right': lengths,
+    'padding-bottom': lengths,
+    'padding-left': lengths,
+    'vertical-align': oneOf(/^(top|middle|bottom|baseline|text-top|text-bottom)$/i),
+    position: oneOf(/^(relative|absolute)$/i),
+    top: lengths,
+    left: lengths,
+    'line-height': oneOf(/^\d+(\.\d+)?(px)?$/i),
+    'white-space': oneOf(/^(nowrap|normal|pre-wrap)$/i),
+    'pointer-events': oneOf(/^none$/i),
+    'user-select': oneOf(/^none$/i),
+    cursor: oneOf(/^(pointer|default)$/i),
+};
+const PRINT_STYLE_POLICY = {
+    // containerstyle/wrapperstyle son CSS que V1 aplica inline a la imagen (H2).
+    attrs: new Set(['style', 'containerstyle', 'wrapperstyle']),
+    allows: (prop, value) => Object.prototype.hasOwnProperty.call(PRINT_STYLE_RULES, prop) && PRINT_STYLE_RULES[prop](value),
+    keepOriginalWhenClean: true,
+};
+const STYLE_POLICIES = {
+    print: PRINT_STYLE_POLICY,
+    'print-header': PRINT_STYLE_POLICY,
+};
+/**
+ * Sanitize an HTML string for the given preset (+ feature overrides — pass the
+ * same `features` you gave `getExtensions`/`createEditor` so the whitelist
+ * stays in lock-step with the schema). Always strips script/object/embed/style/
+ * form/event-handlers and `javascript:` URLs (DOMPurify default). `<iframe>` is
+ * allowed ONLY for the document preset and ONLY with an `https:` source
+ * (YouTube, Vimeo, Loom, Slides, … survive save/render; unsafe embeds are
+ * dropped). `style` is capped to color/background-color/text-align.
+ */
+function sanitize(html, preset = 'task', features) {
+    if (!html)
+        return '';
+    const cfg = configFor(preset, features);
+    purify_es.purify.addHook('uponSanitizeElement', (node, data) => {
+        // Only allow <input type="checkbox"> (task list checkboxes); strip others.
+        if (data.tagName === 'input' && node.type !== 'checkbox') {
+            node.parentNode?.removeChild(node);
+        }
+        // Allow only https iframes (YouTube and other embeds); drop anything else.
+        if (data.tagName === 'iframe') {
+            const src = node.getAttribute('src') || '';
+            if (!SAFE_IFRAME_SRC_RE.test(src))
+                node.parentNode?.removeChild(node);
+        }
+    });
+    // Cap `style` (and, in print, the image's containerstyle/wrapperstyle) to
+    // the properties the preset's extensions actually emit; strip the rest
+    // (position:fixed, background-image url(), expression(), …). Drop the attr
+    // entirely when nothing survives. The default policy is the pre-print rule
+    // verbatim (guarded by sanitizer.presets.snapshot.test.ts).
+    const policy = STYLE_POLICIES[preset] ?? DEFAULT_STYLE_POLICY;
+    purify_es.purify.addHook('uponSanitizeAttribute', (_node, data) => {
+        if (!policy.attrs.has(data.attrName))
+            return;
+        const decls = data.attrValue.split(';').map((d) => d.trim()).filter(Boolean);
+        const safe = decls.filter((d) => {
+            const colon = d.indexOf(':');
+            if (colon <= 0)
+                return false;
+            const prop = d.slice(0, colon).trim().toLowerCase();
+            const value = d.slice(colon + 1).trim();
+            return !UNSAFE_STYLE_VALUE.test(d) && policy.allows(prop, value);
+        });
+        if (policy.keepOriginalWhenClean && safe.length === decls.length && safe.length > 0)
+            return;
+        data.attrValue = safe.join('; ');
+        if (!data.attrValue)
+            data.keepAttr = false;
+    });
+    try {
+        const clean = purify_es.purify.sanitize(html, {
+            ALLOWED_TAGS: cfg.ALLOWED_TAGS,
+            ALLOWED_ATTR: cfg.ALLOWED_ATTR,
+            ALLOW_DATA_ATTR: cfg.ALLOW_DATA_ATTR ?? false,
+            FORBID_TAGS,
+            FORBID_ATTR,
+            ADD_ATTR: ['target', 'allowfullscreen', 'frameborder', 'allow'],
+            ...(cfg.ADD_URI_SAFE_ATTR ? { ADD_URI_SAFE_ATTR: cfg.ADD_URI_SAFE_ATTR } : {}),
+        });
+        return clean;
+    }
+    finally {
+        purify_es.purify.removeHook('uponSanitizeElement');
+        purify_es.purify.removeHook('uponSanitizeAttribute');
+    }
+}
+
+/**
+ * Lector tolerante del HTML de impresión (spec contracts-v2-contract-editor §3.3).
+ * Entrada: lo que guardó V1 (documento completo con CSS, fragmento que dejó
+ * cheerio en el backend, cuerpo compilado de generateFromDeal) o lo que escribe
+ * el serializador canónico. Salida: SOLO el cuerpo, sin restos de edición.
+ * No usa schema: el parse lo hace readPrintHtml (print/io.ts).
+ */
+const EDITING_CLASSES = ['ProseMirror-selectednode', 'variable-node--editing', 'selectedCell'];
+const BLOCK_TAGS = new Set(['P', 'DIV', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'UL', 'OL', 'LI', 'TABLE', 'BLOCKQUOTE', 'PRE', 'HR']);
+const INLINE_CONTENT_TAGS = new Set(['P', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6']);
+const HEAD_ONLY = 'style, script, meta, title, link, base';
+function normalizePrintHtml(html) {
+    if (!html || !html.trim())
+        return '';
+    const doc = new DOMParser().parseFromString(html, 'text/html');
+    const root = doc.querySelector('.tiptap.ProseMirror, .ProseMirror') ?? doc.body;
+    root.querySelectorAll('#document-metadata').forEach((el) => el.remove());
+    root.querySelectorAll(HEAD_ONLY).forEach((el) => el.remove());
+    // prosemirror-model convierte estos br en saltos REALES al re-parsear: fuera todos.
+    root.querySelectorAll('br.ProseMirror-trailingBreak, img.ProseMirror-separator').forEach((el) => el.remove());
+    // V1 serializa por error la decoración de {{ }}.
+    root.querySelectorAll('span.hb-token').forEach(unwrap);
+    Array.from(root.querySelectorAll('*')).forEach(cleanEditingResidue);
+    cleanCellStyles(root);
+    rebuildSplitImages(root);
+    // Tras desenvolver hb-token y quitar breaks quedan textos adyacentes: un token repartido entre ellos no matchearía.
+    root.normalize();
+    tokensToFieldSpans(root);
+    return root.innerHTML;
+}
+function unwrap(el) {
+    el.replaceWith(...Array.from(el.childNodes));
+}
+function cleanEditingResidue(el) {
+    Array.from(el.attributes).forEach((a) => {
+        if (a.name.startsWith('data-v-') || a.name === 'data-node-view-wrapper')
+            el.removeAttribute(a.name);
+    });
+    EDITING_CLASSES.forEach((c) => el.classList.remove(c));
+    if (el.getAttribute('class') === '')
+        el.removeAttribute('class');
+}
+function cleanCellStyles(root) {
+    root.querySelectorAll('td[style], th[style]').forEach((cell) => {
+        const kept = (cell.getAttribute('style') || '')
+            .split(';')
+            .map((d) => d.trim())
+            .filter((d) => {
+            const i = d.indexOf(':');
+            if (i <= 0)
+                return false;
+            const v = d.slice(i + 1).trim().toLowerCase();
+            return v !== '' && v !== 'null' && v !== 'undefined';
+        });
+        if (kept.length)
+            cell.setAttribute('style', kept.join('; '));
+        else
+            cell.removeAttribute('style');
+    });
+}
+const isBlockNode = (n) => n.nodeType === 1 && BLOCK_TAGS.has(n.tagName);
+const isBlankText = (n) => n.nodeType === 3 && !(n.textContent ?? '').trim();
+/**
+ * V1 guarda la imagen como `<div wrapper><div container><img></div></div>`
+ * DENTRO del `<p>`; el parser HTML5 parte el párrafo en `<p>antes</p><div>…</div>después<p></p>`.
+ * Se vuelve a juntar en un solo párrafo, con los estilos del wrapper y del
+ * container copiados al `<img>` (así los lee el nodo image del preset print).
+ */
+function rebuildSplitImages(root) {
+    const doc = root.ownerDocument;
+    Array.from(root.querySelectorAll('img')).forEach((img) => {
+        const container = img.parentElement;
+        // `container !== root`: un <img> suelto al tope del cuerpo no es una imagen partida.
+        if (!container || container === root || container.tagName !== 'DIV' || container.firstElementChild !== img)
+            return;
+        const parent = container.parentElement;
+        const wrapper = parent && parent.tagName === 'DIV' && parent.firstElementChild === container && parent !== root ? parent : null;
+        const containerCss = container.getAttribute('style');
+        if (containerCss && !img.hasAttribute('containerstyle'))
+            img.setAttribute('containerstyle', containerCss);
+        const wrapperCss = wrapper?.getAttribute('style');
+        if (wrapperCss && !img.hasAttribute('wrapperstyle'))
+            img.setAttribute('wrapperstyle', wrapperCss);
+        const outer = wrapper ?? container;
+        // El parser HTML5 solo parte <p>: dentro de un título (o de un <p> que no se
+        // partió) la imagen queda en su lugar, sin recomponer hermanos ni crear <p>.
+        if (outer.parentElement && INLINE_CONTENT_TAGS.has(outer.parentElement.tagName)) {
+            outer.replaceWith(img);
+            return;
+        }
+        const before = [];
+        let prev = outer.previousSibling;
+        while (prev && !isBlockNode(prev)) {
+            before.unshift(prev);
+            prev = prev.previousSibling;
+        }
+        const after = [];
+        let next = outer.nextSibling;
+        while (next && !isBlockNode(next)) {
+            after.push(next);
+            next = next.nextSibling;
+        }
+        // El `</p>` original quedó huérfano: el parser lo convierte en un <p></p> vacío.
+        if (next && next.nodeName === 'P' && !next.hasChildNodes())
+            next.remove();
+        let target;
+        if (before.every(isBlankText) && prev && prev.nodeName === 'P') {
+            before.forEach((n) => n.parentNode?.removeChild(n));
+            target = prev;
+        }
+        else {
+            target = doc.createElement('p');
+            outer.before(target);
+            before.forEach((n) => target.appendChild(n));
+        }
+        target.appendChild(img);
+        after.forEach((n) => target.appendChild(n));
+        outer.remove();
+    });
+}
+function tokensToFieldSpans(root) {
+    const doc = root.ownerDocument;
+    const walker = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const targets = [];
+    let n;
+    while ((n = walker.nextNode())) {
+        const t = n;
+        if (!t.data.includes('[['))
+            continue;
+        if (t.parentElement?.closest('[data-variable], [data-sig-slot], pre, code'))
+            continue;
+        targets.push(t);
+    }
+    targets.forEach((t) => {
+        const text = t.data;
+        const re = fieldTokenRegex();
+        const frag = doc.createDocumentFragment();
+        let last = 0;
+        let any = false;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const def = parseFieldToken(m[1]);
+            if (!def)
+                continue;
+            any = true;
+            if (m.index > last)
+                frag.appendChild(doc.createTextNode(text.slice(last, m.index)));
+            const span = doc.createElement('span');
+            span.setAttribute('data-variable', def.name);
+            span.setAttribute('data-value', '');
+            span.setAttribute('data-type', def.type);
+            span.setAttribute('data-required', def.required ? 'true' : 'false');
+            if (def.enum)
+                span.setAttribute('data-enum', JSON.stringify(def.enum));
+            span.textContent = `[[${def.name}]]`;
+            frag.appendChild(span);
+            last = m.index + m[0].length;
+        }
+        if (!any)
+            return;
+        if (last < text.length)
+            frag.appendChild(doc.createTextNode(text.slice(last)));
+        t.replaceWith(frag);
+    });
+}
+
+/**
+ * Serializador canónico del preset print (spec contracts-v2-contract-editor §3.4).
+ * Escribe desde el DOCUMENTO (renderHTML del schema), nunca desde el DOM de
+ * pantalla: así no se cuelan NodeViews, decoraciones ni los hacks de
+ * prosemirror-view que V1 guardaba con innerHTML.
+ *
+ * H1: `DOMSerializer` escribe `style` por CSSOM (`dom.style.cssText = …`), que
+ * normaliza el string (`#ff0000` → `rgb(255, 0, 0)`, `top:0` → `top: 0px;`) y
+ * rompe la forma byte a byte de V1 (firma, color, tamaño, imagen). Por eso se
+ * serializa con un `document` sustituto cuyos elementos no exponen `style`:
+ * ProseMirror cae a `setAttribute` y conserva el string crudo. `editor.getHTML()`
+ * NO es la forma canónica.
+ */
+const TRAILING_BREAK_CLASS = 'ProseMirror-trailingBreak';
+const TRAILING_MARKER = 'data-co-trailing-break';
+/**
+ * Como prosemirror-view, el trailingBreak se decide por el NODO: textblock vacío o
+ * cuyo último hijo es un hardBreak (aunque el <br> quede dentro de un mark).
+ */
+function needsTrailingBreak(node) {
+    if (!node.isTextblock)
+        return false;
+    return node.childCount === 0 || node.lastChild.type.name === 'hardBreak';
+}
+/**
+ * Marca el elemento de bloque (spec `[tag, attrs?, 0]`, hueco directo en el
+ * elemento: p/h*) para que el <br> vaya como su ÚLTIMO hijo, fuera de los marks.
+ */
+function withTrailingMarker(spec) {
+    if (!Array.isArray(spec) || spec[spec.length - 1] !== 0)
+        return spec;
+    const attrs = spec[1];
+    if (attrs && typeof attrs === 'object' && !Array.isArray(attrs) && !('nodeType' in attrs)) {
+        return [spec[0], { ...attrs, [TRAILING_MARKER]: '' }, ...spec.slice(2)];
+    }
+    return [spec[0], { [TRAILING_MARKER]: '' }, ...spec.slice(1)];
+}
+function rawStyleDocument(real) {
+    return {
+        createElement: (tag) => {
+            const el = real.createElement(tag);
+            Object.defineProperty(el, 'style', { value: null });
+            return el;
+        },
+        createElementNS: (ns, tag) => {
+            const el = real.createElementNS(ns, tag);
+            Object.defineProperty(el, 'style', { value: null });
+            return el;
+        },
+        createTextNode: real.createTextNode.bind(real),
+        createDocumentFragment: real.createDocumentFragment.bind(real),
+    };
+}
+function printSerializer(schema) {
+    const base = DOMSerializer.fromSchema(schema);
+    const nodes = {};
+    Object.entries(base.nodes).forEach(([name, render]) => {
+        nodes[name] = (node) => {
+            const spec = render(node);
+            return needsTrailingBreak(node) ? withTrailingMarker(spec) : spec;
+        };
+    });
+    return new DOMSerializer(nodes, base.marks);
+}
+function serializePrintHtml(doc) {
+    const container = document.createElement('div');
+    const fragment = printSerializer(doc.type.schema).serializeFragment(doc.content, {
+        document: rawStyleDocument(document),
+    });
+    container.appendChild(fragment);
+    // Sin el trailingBreak la línea vacía o final no ocupa alto en el PDF
+    // (.tiptap p{margin:0}). El lector lo quita al volver.
+    container.querySelectorAll(`[${TRAILING_MARKER}]`).forEach((el) => {
+        el.removeAttribute(TRAILING_MARKER);
+        const br = document.createElement('br');
+        br.className = TRAILING_BREAK_CLASS;
+        el.appendChild(br);
+    });
+    return container.innerHTML;
+}
+
+function isPrintPreset(p) {
+    return p === 'print' || p === 'print-header';
+}
+function schemaExtensions(preset, features) {
+    return getExtensions(preset, { includeUiExtensions: false, features });
+}
+/** HTML de impresión (el de V1 incluido) → JSON: lector tolerante → limpieza del preset → parse. */
+function readPrintHtml(html, preset = 'print', features) {
+    const clean = sanitize(normalizePrintHtml(html ?? ''), preset, features);
+    return generateJSON(clean, schemaExtensions(preset, features));
+}
+/**
+ * Documento → forma canónica (spec §3.4), pasada por la limpieza del preset.
+ * Es la ÚNICA forma canónica: `editor.getHTML()` de Tiptap normaliza los `style`
+ * (H1) y no sirve para guardar.
+ */
+function writePrintHtml(doc, preset = 'print', features) {
+    if (!doc)
+        return '';
+    const node = doc instanceof Node$1
+        ? doc
+        : Node$1.fromJSON(getSchema(schemaExtensions(preset, features)), doc);
+    return sanitize(serializePrintHtml(node), preset, features);
+}
+/** Aplica valores a los campos de un HTML sin montar un editor (encabezado fuera de edición). */
+function setFieldValuesInHtml(html, values, preset = 'print-header', features) {
+    if (!html)
+        return '';
+    const json = readPrintHtml(html, preset, features);
+    const apply = (n) => {
+        if (n.type === 'mergeField' && n.attrs && Object.prototype.hasOwnProperty.call(values, n.attrs.name)) {
+            n.attrs = { ...n.attrs, value: String(values[n.attrs.name] ?? '') };
+        }
+        n.content?.forEach(apply);
+    };
+    apply(json);
+    return writePrintHtml(json, preset, features);
+}
 
 /**
  * ProseMirror editorProps that insert pasted/dropped images optimistically
@@ -35310,6 +36682,11 @@ function autolinkTrailing(editor) {
         editor.view.dispatch(tr);
     return changed;
 }
+/** El autolink al perder foco solo corre si el link del schema lo tiene activo (print lo apaga). */
+function autolinkEnabled(editor) {
+    const link = editor.extensionManager.extensions.find((ext) => ext.name === 'link');
+    return !!(link && link.options.autolink);
+}
 /**
  * Create a configured Tiptap v3 editor for a Cobalt preset.
  *
@@ -35318,9 +36695,9 @@ function autolinkTrailing(editor) {
  * always false — Cobalt owns every style.
  */
 function createEditor(options = {}) {
-    const { preset = 'task', element = null, content = null, editable = true, placeholder, maxLength, features, customExtensions = [], bubbleMenuElement, imageUpload, onUpdate, onSelectionUpdate, onFocus, onBlur, onCreate, onDestroy, onContentError, } = options;
+    const { preset = 'task', element = null, content = null, editable = true, placeholder, maxLength, features, labels, customExtensions = [], bubbleMenuElement, imageUpload, onUpdate, onSelectionUpdate, onFocus, onBlur, onCreate, onDestroy, onContentError, } = options;
     const extensions = [
-        ...getExtensions(preset, { placeholder, maxLength, features }),
+        ...getExtensions(preset, { placeholder, maxLength, features, labels }),
         ...customExtensions,
     ];
     let editor;
@@ -35377,11 +36754,13 @@ function createEditor(options = {}) {
             },
         }));
     }
+    // En print, un string es HTML de impresión (quizá de V1): pasa por el lector tolerante.
+    const initialContent = isPrintPreset(preset) && typeof content === 'string' ? readPrintHtml(content, preset, features) : content;
     editor = new Editor({
         ...(element ? { element } : {}),
         ...(imageUpload ? { editorProps: imageDropPaste(imageUpload) } : {}),
         extensions,
-        content: content ?? '',
+        content: initialContent ?? '',
         editable,
         injectCSS: false,
         // `enableContentCheck: true` makes tiptap THROW on invalid content from
@@ -35396,304 +36775,408 @@ function createEditor(options = {}) {
         onUpdate: ({ editor: e }) => onUpdate?.(e),
         onSelectionUpdate: ({ editor: e }) => onSelectionUpdate?.(e),
         onFocus: ({ editor: e }) => onFocus?.(e),
-        onBlur: ({ editor: e }) => { autolinkTrailing(e); onBlur?.(e); },
+        onBlur: ({ editor: e }) => { if (autolinkEnabled(e))
+            autolinkTrailing(e); onBlur?.(e); },
         onDestroy: () => onDestroy?.(),
     });
     return editor;
 }
 
-// src/generateHTML.ts
-function getHTMLFromFragment(doc, schema, options) {
-  if (typeof window === "undefined") {
-    throw new Error(
-      "getHTMLFromFragment can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
-    );
-  }
-  const wrap = window.document.createElement("div");
-  DOMSerializer.fromSchema(schema).serializeFragment(
-    doc.content,
-    {
-      document: window.document
-    },
-    wrap
-  );
-  return wrap.innerHTML;
-}
-
-// src/generateHTML.ts
-function generateHTML(doc, extensions) {
-  if (typeof window === "undefined") {
-    throw new Error(
-      "generateHTML can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
-    );
-  }
-  const schema = getSchema(extensions);
-  const contentNode = Node$1.fromJSON(schema, doc);
-  return getHTMLFromFragment(contentNode, schema);
-}
-function generateJSON(html, extensions, options) {
-  if (typeof window === "undefined") {
-    throw new Error(
-      "generateJSON can only be used in a browser environment\nIf you want to use this in a Node environment, use the `@tiptap/html/server` import instead."
-    );
-  }
-  const schema = getSchema(extensions);
-  const doc = new window.DOMParser().parseFromString(html, "text/html");
-  if (!doc) {
-    throw new Error("Failed to parse HTML string");
-  }
-  return DOMParser.fromSchema(schema).parse(doc.body, options).toJSON();
-}
-
-const BASE_INLINE = ['p', 'br', 'strong', 'em', 'a', 'span'];
-const BASE_ATTR = ['href', 'target', 'rel', 'data-mention-id', 'data-mention-label'];
-const SANITIZE_CONFIGS = {
-    // Más ancho que su schema A PROPÓSITO (única excepción al lock-step): el
-    // editor `comment` no puede autorar listas ni headings (STARTERKIT_CONFIG los
-    // apaga y ProseMirror descarta esos nodos al parsear el paste), pero el
-    // VIEWER tiene que pintarlos cuando el HTML entra por API — una nota de
-    // enriquecimiento (Apollo.io) trae <ul>/<li>/<h4> y con KEEP_CONTENT el
-    // texto se hoisteaba al padre: lista corrida, heading fundido en el cuerpo.
-    // Espejo inline en core/co-rich-text-viewer.tsx (ALLOWED_TAGS.comment).
-    comment: {
-        ALLOWED_TAGS: [...BASE_INLINE, 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4'],
-        ALLOWED_ATTR: [...BASE_ATTR],
-        ALLOW_DATA_ATTR: false,
-    },
-    task: {
-        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'input', 'label'],
-        ALLOWED_ATTR: [...BASE_ATTR, 'type', 'checked', 'disabled', 'data-type', 'data-checked', 'data-variant'],
-        ALLOW_DATA_ATTR: false,
-    },
-    // Lock-step con getExtensions('notes'): task sin checklists + TextStyle/Color
-    // (`style` capado a STYLE_ALLOWED_PROPS) + Highlight multicolor (`mark` con
-    // `data-color`).
-    notes: {
-        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'mark'],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-color'],
-        ALLOW_DATA_ATTR: false,
-    },
-    email: {
-        ALLOWED_TAGS: [
-            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
-            'h2', 'h3', 'div', 'img',
-        ],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout'],
-        ALLOW_DATA_ATTR: false,
-    },
-    document: {
-        ALLOWED_TAGS: [
-            ...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote',
-            'h1', 'h2', 'h3', 'h4', 'hr', 'div', 'mark', 'img',
-            'table', 'thead', 'tbody', 'tr', 'th', 'td',
-            'input', 'label', 'iframe',
-        ],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'colspan', 'rowspan', 'src', 'alt', 'width', 'height', 'type', 'checked', 'disabled', 'allowfullscreen', 'frameborder', 'allow', 'loading'],
-        ALLOW_DATA_ATTR: true,
-    },
-    'block-email': {
-        ALLOWED_TAGS: [...BASE_INLINE, 'u', 's', 'code', 'ul', 'ol', 'li', 'blockquote', 'h2', 'h3', 'div', 'img'],
-        ALLOWED_ATTR: [...BASE_ATTR, 'style', 'data-variable', 'data-transform', 'data-fallback', 'src', 'alt', 'width', 'height', 'data-file-id', 'data-image-layout', 'data-type', 'data-label', 'data-href', 'data-bg', 'data-color', 'data-height'],
-        ALLOW_DATA_ATTR: false,
-    },
-};
-/**
- * `<iframe>`s are permitted only with an `https:` source (blocks javascript:,
- * data:, and plain http: embeds). This is what makes allowing iframes safe-ish
- * for a trusted-author document; YouTube embeds satisfy it too.
- */
-const SAFE_IFRAME_SRC_RE = /^https:\/\/[^\s"'<>]+$/i;
-/** Tags forbidden in every preset, regardless of the allow-list. */
-const FORBID_TAGS = ['script', 'object', 'embed', 'form', 'textarea', 'style'];
-/** Attributes forbidden in every preset (event handlers handled by DOMPurify itself). */
-const FORBID_ATTR = ['onerror', 'onload', 'onclick'];
-/**
- * Resolve the effective config for a preset + feature overrides. Features can
- * only ADD capabilities (mirroring `getExtensions`, where they register extra
- * nodes); they never narrow a preset's base whitelist.
- */
-function configFor(preset, features) {
-    const cfg = SANITIZE_CONFIGS[preset] ?? SANITIZE_CONFIGS.task;
-    if (!features)
-        return cfg;
-    const tags = new Set(cfg.ALLOWED_TAGS);
-    const attr = new Set(cfg.ALLOWED_ATTR);
-    if (features.image) {
-        tags.add('img');
-        ['src', 'alt', 'width', 'height'].forEach((a) => attr.add(a));
-    }
-    if (features.variables)
-        attr.add('data-variable');
-    if (features.mentions) {
-        // data-mention-id/label ya están en BASE_ATTR. Los attrs del markup V1
-        // (quill-mention) se suman porque el BACKEND los parsea para notificar —
-        // re-editar una nota no debe destruirlos.
-        // Espejo inline en core/co-rich-text-viewer.tsx (el viewer no importa este módulo para no cargar el engine) — si cambias esta lista, cambia la del viewer.
-        ['data-id', 'data-value', 'data-denotation-char', 'data-index'].forEach((a) => attr.add(a));
+function computePageBreaks(atoms, pageContentHeight) {
+    const breaks = [];
+    if (!atoms.length || !(pageContentHeight > 0))
+        return { breaks, pageCount: 1 };
+    let page = 1;
+    let start = 0;
+    let pageTop = atoms[0].top;
+    let i = 0;
+    while (i < atoms.length) {
+        const atom = atoms[i];
+        const bottom = atom.top + atom.height;
+        if (bottom - pageTop <= pageContentHeight) {
+            i += 1;
+            continue;
+        }
+        if (i === start) {
+            // Más alto que una hoja: ocupa las que necesite; no hay frontera adentro.
+            const extra = Math.ceil((bottom - pageTop) / pageContentHeight) - 1;
+            page += extra;
+            pageTop += extra * pageContentHeight;
+            i += 1;
+            continue;
+        }
+        let b = i;
+        while (b - 1 > start && atoms[b - 1].keepWithNext)
+            b -= 1;
+        page += 1;
+        breaks.push({ pos: atoms[b].pos, page });
+        start = b;
+        pageTop = atoms[b].top;
+        i = b;
     }
-    return { ...cfg, ALLOWED_TAGS: [...tags], ALLOWED_ATTR: [...attr] };
+    return { breaks, pageCount: page };
 }
 /**
- * `style` is only allowed in notes/email/document, and even there we cap it to
- * the properties our extensions actually emit (TextStyle/Color/TextAlign,
- * ListStyleExtension's `list-style-type`). Everything else — position,
- * background-image url(), etc. — is UI-redressing/tracking surface.
+ * Resta a cada átomo la altura de las bandas de salto que ya están dibujadas
+ * por encima (V1 medía con las bandas viejas en el flujo y cortaba antes).
  */
-const STYLE_ALLOWED_PROPS = new Set(['color', 'background-color', 'text-align', 'list-style-type']);
-/**
- * Sanitize an HTML string for the given preset (+ feature overrides — pass the
- * same `features` you gave `getExtensions`/`createEditor` so the whitelist
- * stays in lock-step with the schema). Always strips script/object/embed/style/
- * form/event-handlers and `javascript:` URLs (DOMPurify default). `<iframe>` is
- * allowed ONLY for the document preset and ONLY with an `https:` source
- * (YouTube, Vimeo, Loom, Slides, … survive save/render; unsafe embeds are
- * dropped). `style` is capped to color/background-color/text-align.
- */
-function sanitize(html, preset = 'task', features) {
-    if (!html)
-        return '';
-    const cfg = configFor(preset, features);
-    purify_es.purify.addHook('uponSanitizeElement', (node, data) => {
-        // Only allow <input type="checkbox"> (task list checkboxes); strip others.
-        if (data.tagName === 'input' && node.type !== 'checkbox') {
-            node.parentNode?.removeChild(node);
-        }
-        // Allow only https iframes (YouTube and other embeds); drop anything else.
-        if (data.tagName === 'iframe') {
-            const src = node.getAttribute('src') || '';
-            if (!SAFE_IFRAME_SRC_RE.test(src))
-                node.parentNode?.removeChild(node);
+function stripBandOffsets(atoms, bands) {
+    if (!bands.length)
+        return atoms;
+    const sorted = [...bands].sort((a, b) => a.top - b.top);
+    return atoms.map((atom) => {
+        let shift = 0;
+        for (const band of sorted) {
+            if (band.top < atom.top)
+                shift += band.height;
+            else
+                break;
         }
+        return shift ? { ...atom, top: atom.top - shift } : atom;
     });
-    // Cap `style` to the properties our extensions actually emit; strip the rest
-    // (position, background-image url(), expression(), …). Drop the attr entirely
-    // when nothing survives.
-    purify_es.purify.addHook('uponSanitizeAttribute', (_node, data) => {
-        if (data.attrName !== 'style')
-            return;
-        const safe = data.attrValue
-            .split(';')
-            .map((d) => d.trim())
-            .filter((d) => {
-            const colon = d.indexOf(':');
-            if (colon <= 0)
-                return false;
-            const prop = d.slice(0, colon).trim().toLowerCase();
-            return STYLE_ALLOWED_PROPS.has(prop) && !/url\s*\(|expression\s*\(/i.test(d);
-        });
-        data.attrValue = safe.join('; ');
-        if (!data.attrValue)
-            data.keepAttr = false;
+}
+const ATOM_TYPES = new Set(['listItem', 'tableRow']);
+const CONTAINER_TYPES = new Set(['bulletList', 'orderedList', 'table']);
+function classifyPaginationNode(node) {
+    const name = node?.type?.name;
+    if (!name || name === 'doc')
+        return 'skip';
+    if (CONTAINER_TYPES.has(name))
+        return 'container';
+    if (ATOM_TYPES.has(name))
+        return 'atom';
+    if (node?.isBlock)
+        return 'atom';
+    return 'skip';
+}
+function isKeepWithNext(node) {
+    return node.type.name === 'heading' && Number(node.attrs?.level) >= 2;
+}
+/** Columnas de una tabla = suma de colspan de su primera fila (banda-fila que cruza la tabla). */
+function tableColumnCount(tableNode) {
+    const firstRow = tableNode && typeof tableNode.child === 'function' ? tableNode.child(0) : null;
+    if (!firstRow || typeof firstRow.forEach !== 'function')
+        return 1;
+    let cols = 0;
+    firstRow.forEach((cell) => {
+        cols += cell?.attrs?.colspan || 1;
     });
-    try {
-        const clean = purify_es.purify.sanitize(html, {
-            ALLOWED_TAGS: cfg.ALLOWED_TAGS,
-            ALLOWED_ATTR: cfg.ALLOWED_ATTR,
-            ALLOW_DATA_ATTR: cfg.ALLOW_DATA_ATTR ?? false,
-            FORBID_TAGS,
-            FORBID_ATTR,
-            ADD_ATTR: ['target', 'allowfullscreen', 'frameborder', 'allow'],
-        });
-        return clean;
-    }
-    finally {
-        purify_es.purify.removeHook('uponSanitizeElement');
-        purify_es.purify.removeHook('uponSanitizeAttribute');
-    }
+    return cols || 1;
 }
 
-/** Schema-affecting extensions only (no Placeholder/CharacterCount). */
-function schemaExtensions(preset, features) {
-    return getExtensions(preset, { includeUiExtensions: false, features });
-}
-function isEmptyDoc(doc) {
-    if (!doc)
-        return true;
-    const content = doc.content;
-    if (!Array.isArray(content) || content.length === 0)
-        return true;
-    // A single empty paragraph counts as empty.
-    return content.every((n) => n?.type === 'paragraph' && (!n.content || n.content.length === 0));
-}
-/** ProseMirror JSON → sanitized HTML for the given preset (+ feature overrides). */
-function jsonToHtml(doc, preset = 'task', features) {
-    if (isEmptyDoc(doc))
-        return '';
-    const html = generateHTML(doc, schemaExtensions(preset, features));
-    return sanitize(html, preset, features);
-}
-/** HTML string → ProseMirror JSON (tolerant; unknown nodes are dropped by the schema). */
-function htmlToJson(html, preset = 'task', features) {
-    const safe = sanitize(html ?? '', preset, features);
-    return generateJSON(safe, schemaExtensions(preset, features));
+/** px a 96 dpi. */
+const PAGE_SIZES = {
+    letter: { width: 816, height: 1056 },
+    a4: { width: 794, height: 1123 },
+    legal: { width: 816, height: 1344 },
+};
+/** Separación visual entre hojas (no existe en el PDF). */
+const PAGE_GAP_PX = 24;
+const PAGINATION_META = 'coPagination';
+function resolvePageSize(page) {
+    if (!page)
+        return PAGE_SIZES.letter;
+    if (typeof page === 'string')
+        return PAGE_SIZES[page] ?? PAGE_SIZES.letter;
+    return { width: Number(page.width), height: Number(page.height) };
+}
+function pageContentHeight(o) {
+    return o.page.height - o.margins.top - o.margins.bottom - o.header.height - o.footer.height;
 }
 /**
- * ProseMirror JSON → plain text. Walks the document directly (no engine), so
- * it stays cheap and dependency-light. Block nodes are separated by newlines.
+ * Top relativo a `root` sumando `offsetTop` por la cadena de offsetParent.
+ * `root` tiene que ser posicionado (la extensión le pone `position: relative`).
+ * Son px de LAYOUT: un `transform: scale()` de zoom no los altera.
  */
-function jsonToText(doc) {
-    if (!doc)
-        return '';
-    const BLOCK = new Set([
-        'paragraph', 'heading', 'blockquote', 'listItem', 'bulletList',
-        'orderedList', 'codeBlock', 'horizontalRule',
-    ]);
-    const out = [];
-    const walk = (node) => {
-        if (!node)
-            return;
-        if (node.type === 'text' && typeof node.text === 'string') {
-            out.push(node.text);
-            return;
-        }
-        if (node.type === 'variable') {
-            out.push(`{{${node.attrs?.name ?? ''}}}`);
-            return;
-        }
-        if (node.type === 'mention') {
-            out.push(`@${node.attrs?.label ?? ''}`);
-            return;
-        }
-        if (node.type === 'hardBreak') {
-            out.push('\n');
-            return;
-        }
-        if (Array.isArray(node.content))
-            node.content.forEach(walk);
-        if (BLOCK.has(node.type))
-            out.push('\n');
+function layoutBox(el, root) {
+    let top = 0;
+    let node = el;
+    while (node && node !== root) {
+        top += node.offsetTop;
+        node = node.offsetParent;
+    }
+    return { top, height: el.offsetHeight };
+}
+const defaultSchedule = (cb) => {
+    if (typeof requestAnimationFrame === 'function')
+        requestAnimationFrame(() => cb());
+    else
+        setTimeout(cb, 16);
+};
+function toLayoutOptions(o) {
+    return {
+        page: resolvePageSize(o.page),
+        margins: { ...o.margins },
+        header: { height: o.header?.height ?? 0 },
+        footer: { height: o.footer?.height ?? 0 },
+        gap: o.gap ?? PAGE_GAP_PX,
     };
-    walk(doc);
-    return out.join('').replace(/\n{3,}/g, '\n\n').trim();
-}
-
-var RichText = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  COLOR_PALETTE: toolbarConfig.COLOR_PALETTE,
-  CalloutNode: CalloutNode,
-  CobaltTaskItem: CobaltTaskItem,
-  CobaltTaskList: CobaltTaskList,
-  FontFamilyExtension: FontFamilyExtension,
-  FontSizeExtension: FontSizeExtension,
-  FontWeightExtension: FontWeightExtension,
-  IndentExtension: IndentExtension,
-  LetterSpacingExtension: LetterSpacingExtension,
-  LineHeightExtension: LineHeightExtension,
-  ListStyleExtension: ListStyleExtension,
-  MentionNode: MentionNode,
-  PRESETS: PRESETS,
-  SANITIZE_CONFIGS: SANITIZE_CONFIGS,
-  TABLE_CONTEXT_ITEMS: toolbarConfig.TABLE_CONTEXT_ITEMS,
-  VariableNode: VariableNode,
-  createEditor: createEditor,
-  defaultToolbarForPreset: defaultToolbarForPreset,
-  getExtensions: getExtensions,
-  htmlToJson: htmlToJson,
-  jsonToHtml: jsonToHtml,
-  jsonToText: jsonToText,
-  maxLengthForPreset: maxLengthForPreset,
-  sanitize: sanitize,
-  toolbarItems: toolbarConfig.toolbarItems
+}
+/**
+ * Banda de salto: margen inferior (+ pie) de la hoja que termina, separación
+ * entre hojas y margen superior (+ encabezado) de la que empieza. Dentro de una
+ * tabla va envuelta en una fila con el colspan de la tabla (un div entre `tr`
+ * lo expulsaría el navegador).
+ */
+function buildPageGap(page, pageCount, o, header, cols = 0) {
+    const foot = o.margins.bottom + o.footer.height;
+    const head = o.margins.top + o.header.height;
+    const band = document.createElement('div');
+    band.className = 'co-doc-page-gap';
+    band.setAttribute('contenteditable', 'false');
+    band.style.height = `${foot + o.gap + head}px`;
+    const bottom = document.createElement('div');
+    bottom.className = 'co-doc-page-gap__foot';
+    bottom.style.height = `${foot}px`;
+    const between = document.createElement('div');
+    between.className = 'co-doc-page-gap__between';
+    between.style.height = `${o.gap}px`;
+    const top = document.createElement('div');
+    top.className = 'co-doc-page-gap__head';
+    top.style.height = `${head}px`;
+    top.style.paddingTop = `${o.margins.top}px`;
+    top.style.boxSizing = 'border-box';
+    if (header)
+        top.appendChild(header);
+    band.append(bottom, between, top);
+    band.setAttribute('data-page', String(page));
+    band.setAttribute('data-page-count', String(pageCount));
+    if (!cols) {
+        band.setAttribute('data-co-page-gap', String(page));
+        return band;
+    }
+    const tr = document.createElement('tr');
+    tr.className = 'co-doc-page-gap-row';
+    tr.setAttribute('contenteditable', 'false');
+    tr.setAttribute('data-co-page-gap', String(page));
+    const td = document.createElement('td');
+    td.setAttribute('colspan', String(cols));
+    td.appendChild(band);
+    tr.appendChild(td);
+    return tr;
+}
+function measureLayout(view, opts, measure) {
+    const root = view.dom;
+    const atoms = [];
+    view.state.doc.descendants((node, pos) => {
+        const kind = classifyPaginationNode(node);
+        if (kind === 'container')
+            return true;
+        if (kind === 'skip')
+            return false;
+        const dom = view.nodeDOM(pos);
+        if (!(dom instanceof HTMLElement))
+            return false;
+        const box = measure(dom, root);
+        if (box.height > 0)
+            atoms.push({ pos, top: box.top, height: box.height, keepWithNext: isKeepWithNext(node) });
+        return false;
+    });
+    const bands = Array.from(root.querySelectorAll('[data-co-page-gap]')).map((el) => measure(el, root));
+    return computePageBreaks(stripBandOffsets(atoms, bands), pageContentHeight(opts));
+}
+const paginationKey = new PluginKey('coPagination');
+const Pagination = Extension.create({
+    name: 'pagination',
+    addOptions() {
+        return {
+            page: 'letter',
+            margins: { top: 38, right: 38, bottom: 38, left: 38 },
+            header: { height: 0 },
+            footer: { height: 0 },
+            gap: PAGE_GAP_PX,
+            renderHeader: null,
+            onPagesChange: null,
+            measure: layoutBox,
+            schedule: defaultSchedule,
+        };
+    },
+    addStorage() {
+        return { pageCount: 1 };
+    },
+    addCommands() {
+        return {
+            setPaginationOptions: (patch) => ({ tr, dispatch }) => {
+                if (dispatch)
+                    tr.setMeta(PAGINATION_META, { patch });
+                return true;
+            },
+            remeasurePages: () => ({ tr, dispatch }) => {
+                if (dispatch)
+                    tr.setMeta(PAGINATION_META, { remeasure: true });
+                return true;
+            },
+        };
+    },
+    addProseMirrorPlugins() {
+        const options = this.options;
+        const storage = this.storage;
+        let lastEmitted = 0;
+        const decorationsFor = (state, st) => {
+            const decos = [];
+            for (const br of st.layout.breaks) {
+                if (br.pos < 0 || br.pos > state.doc.content.size)
+                    continue;
+                // Nunca un widget de bloque dentro de contenido inline.
+                if (state.doc.resolve(br.pos).parent.inlineContent)
+                    continue;
+                const node = state.doc.nodeAt(br.pos);
+                const cols = node?.type.name === 'tableRow' ? tableColumnCount(state.doc.resolve(br.pos).parent) : 0;
+                decos.push(Decoration.widget(br.pos, () => buildPageGap(br.page, st.layout.pageCount, st.opts, options.renderHeader?.(br.page, st.layout.pageCount) ?? null, cols), { side: -1, key: `co-pg-${br.page}-${st.layout.pageCount}-v${st.version}-c${cols}` }));
+            }
+            return DecorationSet.create(state.doc, decos);
+        };
+        return [
+            new Plugin({
+                key: paginationKey,
+                state: {
+                    init: () => ({ layout: { breaks: [], pageCount: 1 }, opts: toLayoutOptions(options), version: 0, dirty: true }),
+                    apply(tr, prev) {
+                        const meta = tr.getMeta(PAGINATION_META);
+                        let next = prev;
+                        if (tr.docChanged) {
+                            next = {
+                                ...next,
+                                dirty: true,
+                                // Un salto cuya frontera se borró (p. ej. unir párrafos en el borde de una hoja)
+                                // se descarta: mapearlo lo dejaría dentro de un textblock. La medición siguiente
+                                // lo recalcula.
+                                layout: {
+                                    ...next.layout,
+                                    breaks: next.layout.breaks.flatMap((b) => {
+                                        const r = tr.mapping.mapResult(b.pos);
+                                        return r.deleted ? [] : [{ ...b, pos: r.pos }];
+                                    }),
+                                },
+                            };
+                        }
+                        if (meta?.patch) {
+                            const merged = toLayoutOptions({ ...next.opts, ...meta.patch, page: meta.patch.page ?? next.opts.page });
+                            next = { ...next, opts: merged, version: next.version + 1, dirty: true };
+                        }
+                        if (meta?.remeasure)
+                            next = { ...next, dirty: true };
+                        if (meta?.layout)
+                            next = { ...next, layout: meta.layout, dirty: false };
+                        return next;
+                    },
+                },
+                props: {
+                    decorations(state) {
+                        const st = paginationKey.getState(state);
+                        return st ? decorationsFor(state, st) : DecorationSet.empty;
+                    },
+                },
+                view(view) {
+                    const root = view.dom;
+                    if (!root.style.position)
+                        root.style.position = 'relative';
+                    let scheduled = false;
+                    let alive = true;
+                    const run = () => {
+                        scheduled = false;
+                        if (!alive || view.isDestroyed)
+                            return;
+                        const st = paginationKey.getState(view.state);
+                        if (!st)
+                            return;
+                        const layout = measureLayout(view, st.opts, options.measure);
+                        storage.pageCount = layout.pageCount;
+                        view.dispatch(view.state.tr.setMeta(PAGINATION_META, { layout }));
+                        if (layout.pageCount !== lastEmitted) {
+                            lastEmitted = layout.pageCount;
+                            options.onPagesChange?.(layout.pageCount);
+                        }
+                    };
+                    const maybeSchedule = () => {
+                        const st = paginationKey.getState(view.state);
+                        if (!st?.dirty || scheduled)
+                            return;
+                        scheduled = true;
+                        options.schedule(run);
+                    };
+                    const remeasure = () => {
+                        if (alive && !view.isDestroyed) {
+                            view.dispatch(view.state.tr.setMeta(PAGINATION_META, { remeasure: true }));
+                        }
+                    };
+                    // Imágenes que cargan tarde cambian alturas (las de las bandas no: tienen alto fijo).
+                    const onLoad = (e) => {
+                        const t = e.target;
+                        if (!t || t.tagName !== 'IMG' || t.closest('[data-co-page-gap]'))
+                            return;
+                        remeasure();
+                    };
+                    root.addEventListener('load', onLoad, true);
+                    const fonts = document.fonts;
+                    fonts?.ready?.then(remeasure).catch(() => { });
+                    // Fuentes que cargan después (un peso o familia aplicado por primera vez).
+                    fonts?.addEventListener?.('loadingdone', remeasure);
+                    maybeSchedule();
+                    return {
+                        update: () => maybeSchedule(),
+                        destroy: () => {
+                            alive = false;
+                            root.removeEventListener('load', onLoad, true);
+                            fonts?.removeEventListener?.('loadingdone', remeasure);
+                        },
+                    };
+                },
+            }),
+        ];
+    },
 });
 
-exports.RichText = RichText;
+exports.CalloutNode = CalloutNode;
+exports.CobaltTaskItem = CobaltTaskItem;
+exports.CobaltTaskList = CobaltTaskList;
+exports.FIELD_SYNC_META = FIELD_SYNC_META;
+exports.FontFamilyExtension = FontFamilyExtension;
+exports.FontSizeExtension = FontSizeExtension;
+exports.FontWeightExtension = FontWeightExtension;
+exports.IMAGE_LAYOUT_MODES = IMAGE_LAYOUT_MODES;
+exports.IndentExtension = IndentExtension;
+exports.LetterSpacingExtension = LetterSpacingExtension;
+exports.LineHeightExtension = LineHeightExtension;
+exports.ListStyleExtension = ListStyleExtension;
+exports.MentionNode = MentionNode;
+exports.MergeField = MergeField;
+exports.PAGE_GAP_PX = PAGE_GAP_PX;
+exports.PAGE_SIZES = PAGE_SIZES;
+exports.PAGINATION_META = PAGINATION_META;
+exports.PRESETS = PRESETS;
+exports.Pagination = Pagination;
+exports.SANITIZE_CONFIGS = SANITIZE_CONFIGS;
+exports.SIGNATURE_TOKEN_STYLE = SIGNATURE_TOKEN_STYLE;
+exports.SignatureSlot = SignatureSlot;
+exports.TRAILING_BREAK_CLASS = TRAILING_BREAK_CLASS;
+exports.VariableNode = VariableNode;
+exports.applyImageLayoutMode = applyImageLayoutMode;
+exports.collectFields = collectFields;
+exports.computePageBreaks = computePageBreaks;
+exports.createEditor = createEditor;
+exports.defaultToolbarForPreset = defaultToolbarForPreset;
+exports.generateHTML = generateHTML;
+exports.generateJSON = generateJSON;
+exports.getExtensions = getExtensions;
+exports.getImageLayoutMode = getImageLayoutMode;
+exports.getPrintExtensions = getPrintExtensions;
+exports.headerImageWidth = headerImageWidth;
+exports.isPrintPreset = isPrintPreset;
+exports.layoutBox = layoutBox;
+exports.maxLengthForPreset = maxLengthForPreset;
+exports.nextFreeSlot = nextFreeSlot;
+exports.normalizePrintHtml = normalizePrintHtml;
+exports.pageContentHeight = pageContentHeight;
+exports.parseFieldToken = parseFieldToken;
+exports.readPrintHtml = readPrintHtml;
+exports.resolvePageSize = resolvePageSize;
+exports.sanitize = sanitize;
+exports.sanitizeFieldName = sanitizeFieldName;
+exports.serializePrintHtml = serializePrintHtml;
+exports.setFieldValuesInHtml = setFieldValuesInHtml;
+exports.signatureBoxStyle = signatureBoxStyle;
+exports.signatureSlotHtml = signatureSlotHtml;
+exports.signatureToken = signatureToken;
+exports.stripBandOffsets = stripBandOffsets;
+exports.writePrintHtml = writePrintHtml;