@inshapardaz/likhari-converters 0.1.9 → 0.1.11-dev.102

package/dist/html/index.d.ts

@@ -1,8 +1,8 @@
 import type { FormatConverter } from '../types.js';
 /**
- * Placeholder — HTML import/export is Phase 2 work (lexical-editor-spec.md
- * §13). Registered now so FormatRegistry's shape is stable and callers get a
- * clear error instead of a missing format.
+ * HTML export/import (lexical-editor-spec.md §2.2). Export is pure string
+ * generation over the serialized tree; import needs a DOM parser, which the
+ * browser (and jsdom in tests) provides.
  */
 export declare const htmlConverter: FormatConverter;
 //# sourceMappingURL=index.d.ts.map

package/dist/html/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/html/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,eAQ3B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/html/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIhD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,eAI3B,CAAC"}

package/dist/html/index.js

@@ -1,14 +1,12 @@
+import { serializeHtml } from './serialize.js';
+import { parseHtml } from './parse.js';
 /**
- * Placeholder — HTML import/export is Phase 2 work (lexical-editor-spec.md
- * §13). Registered now so FormatRegistry's shape is stable and callers get a
- * clear error instead of a missing format.
+ * HTML export/import (lexical-editor-spec.md §2.2). Export is pure string
+ * generation over the serialized tree; import needs a DOM parser, which the
+ * browser (and jsdom in tests) provides.
  */
 export const htmlConverter = {
     id: 'html',
-    serialize() {
-        throw new Error('@inshapardaz/likhari-converters: HTML export is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §13).');
-    },
-    parse() {
-        throw new Error('@inshapardaz/likhari-converters: HTML import is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §13).');
-    },
+    serialize: (state, ctx) => serializeHtml(state, ctx),
+    parse: (input, ctx) => parseHtml(input, ctx),
 };

package/dist/html/parse.d.ts

@@ -0,0 +1,4 @@
+import type { SerializedEditorState } from 'lexical';
+import type { ConverterContext } from '../types.js';
+export declare function parseHtml(input: string, _ctx?: ConverterContext): SerializedEditorState;
+//# sourceMappingURL=parse.d.ts.map

package/dist/html/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/html/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AA+TjD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,CAMvF"}

package/dist/html/parse.js

@@ -0,0 +1,324 @@
+import { FORMAT_BOLD, FORMAT_CODE, FORMAT_HIGHLIGHT, FORMAT_ITALIC, FORMAT_STRIKETHROUGH, FORMAT_SUBSCRIPT, FORMAT_SUPERSCRIPT, FORMAT_UNDERLINE, INDENT_PX, elementBase, makeState, paragraph, textNode, } from '../shared/serialized.js';
+const ALIGNMENTS = new Set(['left', 'right', 'center', 'justify', 'start', 'end']);
+const TAG_FORMATS = {
+    b: FORMAT_BOLD, strong: FORMAT_BOLD,
+    i: FORMAT_ITALIC, em: FORMAT_ITALIC,
+    u: FORMAT_UNDERLINE, ins: FORMAT_UNDERLINE,
+    s: FORMAT_STRIKETHROUGH, strike: FORMAT_STRIKETHROUGH, del: FORMAT_STRIKETHROUGH,
+    code: FORMAT_CODE, sub: FORMAT_SUBSCRIPT, sup: FORMAT_SUPERSCRIPT, mark: FORMAT_HIGHLIGHT,
+};
+/** Dropped with their content: never useful in a document. */
+const SKIP_TAGS = new Set(['script', 'style', 'template', 'head', 'title', 'meta', 'link', 'noscript', 'iframe', 'object', 'embed']);
+/** Transparent containers whose children are processed as if in place. */
+const BLOCK_CONTAINERS = new Set(['div', 'section', 'article', 'main', 'header', 'footer', 'aside', 'nav', 'body', 'html', 'figure', 'tbody', 'thead', 'tfoot', 'details', 'summary', 'span-block']);
+const BLOCK_TAGS = new Set([
+    'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'ul', 'ol', 'li', 'table', 'tr', 'td', 'th',
+    'hr', 'pre', 'img', 'figcaption', 'dl', 'dt', 'dd', ...BLOCK_CONTAINERS,
+]);
+/** Link hrefs with an executable scheme are dropped on import. */
+function safeUrl(url) {
+    const trimmed = url.trim();
+    if (/^(javascript|vbscript|data:text\/html)/i.test(trimmed.replace(/[\u0000- ]/g, '')))
+        return null;
+    return trimmed;
+}
+/** Image sources: only http(s), relative and base64 image data URIs. */
+function safeImageSrc(src) {
+    const trimmed = src.trim();
+    if (!trimmed)
+        return null;
+    if (/^data:/i.test(trimmed))
+        return /^data:image\/(png|jpe?g|gif|webp|svg\+xml|avif|bmp);/i.test(trimmed) ? trimmed : null;
+    return safeUrl(trimmed);
+}
+function blockExtras(el) {
+    const extra = {};
+    const dir = el.getAttribute('dir');
+    if (dir === 'rtl' || dir === 'ltr')
+        extra.direction = dir;
+    const align = el.style?.textAlign;
+    if (align && ALIGNMENTS.has(align))
+        extra.format = align;
+    const padding = el.style?.paddingInlineStart || el.style?.paddingLeft || el.style?.paddingRight;
+    const px = padding && /^([\d.]+)px$/.exec(padding);
+    if (px)
+        extra.indent = Math.min(Math.round(Number(px[1]) / INDENT_PX), 10);
+    return extra;
+}
+function inlineStyleOf(el) {
+    // Only carry presentation the editor itself produces (font, size, color).
+    const keep = [];
+    for (const prop of ['font-family', 'font-size', 'color', 'background-color']) {
+        const value = el.style?.getPropertyValue(prop);
+        if (value)
+            keep.push(`${prop}: ${value}`);
+    }
+    return keep.join('; ');
+}
+function formatsFromElement(el, base) {
+    let format = base.format | (TAG_FORMATS[el.tagName.toLowerCase()] ?? 0);
+    const weight = el.style?.fontWeight;
+    if (weight === 'bold' || Number(weight) >= 600)
+        format |= FORMAT_BOLD;
+    if (el.style?.fontStyle === 'italic')
+        format |= FORMAT_ITALIC;
+    const deco = el.style?.textDecoration || el.style?.getPropertyValue('text-decoration-line') || '';
+    if (deco.includes('underline'))
+        format |= FORMAT_UNDERLINE;
+    if (deco.includes('line-through'))
+        format |= FORMAT_STRIKETHROUGH;
+    const own = inlineStyleOf(el);
+    return { format, style: [base.style, own].filter(Boolean).join('; ') };
+}
+/** Collapse HTML whitespace like a browser does inside flowing text. */
+function collapse(text) {
+    return text.replace(/[ \t\r\n\f]+/g, ' ');
+}
+function collectInline(node, state, out, preserveWs) {
+    if (node.nodeType === 3) {
+        const raw = node.nodeValue ?? '';
+        const text = preserveWs ? raw : collapse(raw);
+        if (text)
+            out.push(textNode(text, state.format, state.style));
+        return;
+    }
+    if (node.nodeType !== 1)
+        return;
+    const el = node;
+    const tag = el.tagName.toLowerCase();
+    if (SKIP_TAGS.has(tag))
+        return;
+    if (tag === 'br') {
+        out.push({ type: 'linebreak', version: 1 });
+        return;
+    }
+    if (tag === 'a') {
+        const url = safeUrl(el.getAttribute('href') ?? '');
+        const children = [];
+        el.childNodes.forEach((child) => collectInline(child, formatsFromElement(el, state), children, preserveWs));
+        if (url === null || url === '') {
+            out.push(...children);
+            return;
+        }
+        out.push(elementBase('link', children, {
+            url,
+            rel: el.getAttribute('rel'),
+            target: el.getAttribute('target'),
+            title: el.getAttribute('title'),
+        }));
+        return;
+    }
+    const next = formatsFromElement(el, state);
+    el.childNodes.forEach((child) => collectInline(child, next, out, preserveWs));
+}
+/** Trim the leading/trailing space a block's source whitespace left behind. */
+function trimInline(nodes) {
+    const first = nodes[0];
+    if (first && first.type === 'text')
+        first.text = String(first.text).replace(/^ +/, '');
+    const last = nodes[nodes.length - 1];
+    if (last && last.type === 'text')
+        last.text = String(last.text).replace(/ +$/, '');
+    return nodes.filter((n) => n.type !== 'text' || n.text !== '');
+}
+function inlineChildrenOf(el, preserveWs = false) {
+    const out = [];
+    el.childNodes.forEach((child) => collectInline(child, { format: 0, style: '' }, out, preserveWs));
+    return trimInline(out);
+}
+/**
+ * Children of a "flow" container (body, div, td, li...): runs of inline
+ * content become paragraphs, block children become blocks.
+ */
+function flowBlocks(el) {
+    const blocks = [];
+    let run = [];
+    const flush = () => {
+        if (run.length === 0)
+            return;
+        const out = [];
+        for (const n of run)
+            collectInline(n, { format: 0, style: '' }, out, false);
+        const children = trimInline(out);
+        if (children.length > 0)
+            blocks.push(paragraph(children));
+        run = [];
+    };
+    el.childNodes.forEach((child) => {
+        if (child.nodeType === 1) {
+            const tag = child.tagName.toLowerCase();
+            if (SKIP_TAGS.has(tag))
+                return;
+            if (BLOCK_TAGS.has(tag)) {
+                flush();
+                blocks.push(...convertBlock(child));
+                return;
+            }
+        }
+        run.push(child);
+    });
+    flush();
+    return blocks;
+}
+function convertList(el) {
+    const tag = el.tagName.toLowerCase();
+    const isCheck = el.getAttribute('data-list-type') === 'check';
+    const listType = isCheck ? 'check' : tag === 'ol' ? 'number' : 'bullet';
+    const start = tag === 'ol' ? Number(el.getAttribute('start')) || 1 : 1;
+    const items = [];
+    el.childNodes.forEach((child) => {
+        if (child.nodeType !== 1)
+            return;
+        const li = child;
+        if (li.tagName.toLowerCase() !== 'li')
+            return;
+        items.push(...convertListItem(li, isCheck));
+    });
+    return elementBase('list', items, { listType, start, tag: tag === 'ol' ? 'ol' : 'ul', ...blockExtras(el) });
+}
+/** One <li> may yield several listitems (inline content, then nested lists). */
+function convertListItem(li, isCheck) {
+    const items = [];
+    let run = [];
+    const checked = isCheck ? li.getAttribute('data-checked') === 'true' : undefined;
+    const makeItem = (children) => elementBase('listitem', children, { value: 1, ...(isCheck ? { checked: !!checked } : {}), ...blockExtras(li) });
+    const flush = () => {
+        const out = [];
+        for (const n of run)
+            collectInline(n, { format: 0, style: '' }, out, false);
+        const children = trimInline(out);
+        if (children.length > 0)
+            items.push(makeItem(children));
+        run = [];
+    };
+    li.childNodes.forEach((child) => {
+        if (child.nodeType === 1) {
+            const tag = child.tagName.toLowerCase();
+            if (tag === 'ul' || tag === 'ol') {
+                flush();
+                items.push(makeItem([convertList(child)]));
+                return;
+            }
+            if (tag === 'p') {
+                // <li><p>text</p></li>: treat the paragraph as the item's own text.
+                run.push(...Array.from(child.childNodes));
+                return;
+            }
+        }
+        run.push(child);
+    });
+    flush();
+    return items;
+}
+function convertTable(el) {
+    const rows = [];
+    el.querySelectorAll('tr').forEach((tr) => {
+        // Skip rows of tables nested inside a cell.
+        if (tr.closest('table') !== el)
+            return;
+        const cells = [];
+        Array.from(tr.children).forEach((cell) => {
+            const tag = cell.tagName.toLowerCase();
+            if (tag !== 'td' && tag !== 'th')
+                return;
+            let children = flowBlocks(cell);
+            if (children.length === 0)
+                children = [paragraph()];
+            cells.push(elementBase('tablecell', children, {
+                headerState: tag === 'th' ? 1 : 0,
+                colSpan: Number(cell.getAttribute('colspan')) || 1,
+                rowSpan: Number(cell.getAttribute('rowspan')) || 1,
+                backgroundColor: null,
+                width: null,
+            }));
+        });
+        if (cells.length > 0)
+            rows.push(elementBase('tablerow', cells, { height: null }));
+    });
+    return elementBase('table', rows);
+}
+function convertImage(img, caption) {
+    const src = safeImageSrc(img.getAttribute('src') ?? '');
+    if (!src)
+        return null;
+    const dim = (name) => {
+        const n = Number(img.getAttribute(name));
+        return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
+    };
+    const declared = img.getAttribute('data-link-type');
+    return {
+        type: 'image',
+        version: 1,
+        src,
+        altText: img.getAttribute('alt') ?? '',
+        caption,
+        linkType: declared === 'embedded' || /^data:/i.test(src) ? 'embedded' : 'linked',
+        width: dim('width'),
+        height: dim('height'),
+    };
+}
+function convertBlock(el) {
+    const tag = el.tagName.toLowerCase();
+    switch (tag) {
+        case 'p':
+            return [paragraph(inlineChildrenOf(el), blockExtras(el))];
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6':
+            return [elementBase('heading', inlineChildrenOf(el), { tag, ...blockExtras(el) })];
+        case 'blockquote': {
+            const hasBlocks = Array.from(el.children).some((c) => BLOCK_TAGS.has(c.tagName.toLowerCase()));
+            if (!hasBlocks)
+                return [elementBase('quote', inlineChildrenOf(el), blockExtras(el))];
+            // Quote holds inline content only: flatten block children, one quote each.
+            return flowBlocks(el).map((block) => (block.type === 'paragraph' ? elementBase('quote', block.children ?? [], blockExtras(el)) : block));
+        }
+        case 'pre': {
+            const text = (el.textContent ?? '').replace(/\n$/, '');
+            return [paragraph(text ? [textNode(text, FORMAT_CODE)] : [])];
+        }
+        case 'ul':
+        case 'ol':
+            return [convertList(el)];
+        case 'li':
+            return convertListItem(el, false).length > 0 ? [elementBase('list', convertListItem(el, false), { listType: 'bullet', start: 1, tag: 'ul' })] : [];
+        case 'table':
+            return [convertTable(el)];
+        case 'hr':
+            return [{ type: 'horizontalrule', version: 1 }];
+        case 'img': {
+            const image = convertImage(el, null);
+            return image ? [image] : [];
+        }
+        case 'figure': {
+            const img = el.querySelector('img');
+            const figcaption = el.querySelector('figcaption');
+            if (!img)
+                return flowBlocks(el);
+            const caption = figcaption ? (figcaption.textContent ?? '').trim() || null : null;
+            const image = convertImage(img, caption);
+            return image ? [image] : [];
+        }
+        case 'div':
+            if (el.hasAttribute('data-likhari-page-break'))
+                return [{ type: 'page-break', version: 1 }];
+            return flowBlocks(el);
+        case 'figcaption':
+            return [];
+        case 'dt':
+        case 'dd':
+            return [paragraph(inlineChildrenOf(el), blockExtras(el))];
+        default:
+            return flowBlocks(el);
+    }
+}
+export function parseHtml(input, _ctx) {
+    if (typeof DOMParser === 'undefined') {
+        throw new Error('@inshapardaz/likhari-converters: HTML import needs a DOM (DOMParser); run it in a browser or jsdom.');
+    }
+    const doc = new DOMParser().parseFromString(input, 'text/html');
+    return makeState(flowBlocks(doc.body));
+}

package/dist/html/serialize.d.ts

@@ -0,0 +1,8 @@
+import type { SerializedEditorState } from 'lexical';
+import type { ConverterContext } from '../types.js';
+import { type SNode } from '../shared/serialized.js';
+export declare function escapeHtml(value: string): string;
+export declare function escapeAttr(value: string): string;
+export declare function nodeToHtml(node: SNode, ctx?: ConverterContext): string;
+export declare function serializeHtml(state: SerializedEditorState, ctx?: ConverterContext): string;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/html/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/html/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAE4E,KAAK,KAAK,EAC5F,MAAM,sBAAsB,CAAC;AAE9B,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAgGD,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAuCtE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAE1F"}

package/dist/html/serialize.js

@@ -0,0 +1,143 @@
+import { FORMAT_BOLD, FORMAT_CODE, FORMAT_HIGHLIGHT, FORMAT_ITALIC, FORMAT_STRIKETHROUGH, FORMAT_SUBSCRIPT, FORMAT_SUPERSCRIPT, FORMAT_UNDERLINE, INDENT_PX, rootChildren, } from '../shared/serialized.js';
+export function escapeHtml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function escapeAttr(value) {
+    return escapeHtml(value).replace(/"/g, '&quot;');
+}
+/** Wrapping order matters for round-trips: outermost first. */
+const FORMAT_TAGS = [
+    [FORMAT_CODE, 'code'],
+    [FORMAT_BOLD, 'strong'],
+    [FORMAT_ITALIC, 'em'],
+    [FORMAT_UNDERLINE, 'u'],
+    [FORMAT_STRIKETHROUGH, 's'],
+    [FORMAT_SUBSCRIPT, 'sub'],
+    [FORMAT_SUPERSCRIPT, 'sup'],
+    [FORMAT_HIGHLIGHT, 'mark'],
+];
+const ALIGNMENTS = new Set(['left', 'right', 'center', 'justify', 'start', 'end']);
+function textToHtml(node) {
+    const text = String(node.text ?? '');
+    let out = escapeHtml(text).replace(/\t/g, '&#9;');
+    const format = Number(node.format ?? 0);
+    const style = String(node.style ?? '').trim();
+    if (style)
+        out = `<span style="${escapeAttr(style)}">${out}</span>`;
+    for (const [bit, tag] of FORMAT_TAGS) {
+        if (format & bit)
+            out = `<${tag}>${out}</${tag}>`;
+    }
+    return out;
+}
+function inlineChildren(node, ctx) {
+    return (node.children ?? []).map((child) => nodeToHtml(child, ctx)).join('');
+}
+/** `dir`, `style` (alignment, indent) and any extra attributes for a block. */
+function blockAttrs(node, extra = '') {
+    let attrs = '';
+    if (node.direction === 'rtl' || node.direction === 'ltr')
+        attrs += ` dir="${node.direction}"`;
+    const styles = [];
+    const format = String(node.format ?? '');
+    if (ALIGNMENTS.has(format))
+        styles.push(`text-align: ${format}`);
+    const indent = Number(node.indent ?? 0);
+    if (indent > 0)
+        styles.push(`padding-inline-start: ${indent * INDENT_PX}px`);
+    if (styles.length > 0)
+        attrs += ` style="${styles.join('; ')}"`;
+    return attrs + extra;
+}
+function listToHtml(node, ctx) {
+    const listType = String(node.listType ?? 'bullet');
+    const tag = listType === 'number' ? 'ol' : 'ul';
+    let extra = '';
+    if (tag === 'ol' && Number(node.start) > 1)
+        extra += ` start="${Number(node.start)}"`;
+    if (listType === 'check')
+        extra += ' data-list-type="check"';
+    const items = (node.children ?? []).map((item) => listItemToHtml(item, listType, ctx)).join('');
+    return `<${tag}${blockAttrs(node, extra)}>${items}</${tag}>`;
+}
+function listItemToHtml(item, listType, ctx) {
+    const children = item.children ?? [];
+    // Lexical nests a sublist as a listitem whose only child is the list.
+    if (children.length === 1 && children[0].type === 'list') {
+        return `<li style="list-style-type: none">${listToHtml(children[0], ctx)}</li>`;
+    }
+    const checked = listType === 'check' ? ` data-checked="${item.checked ? 'true' : 'false'}"` : '';
+    return `<li${blockAttrs(item, checked)}>${inlineChildren(item, ctx)}</li>`;
+}
+function tableToHtml(node, ctx) {
+    const rows = (node.children ?? [])
+        .map((row) => {
+        const cells = (row.children ?? [])
+            .map((cell) => {
+            const header = Number(cell.headerState ?? 0) !== 0;
+            const tag = header ? 'th' : 'td';
+            const span = (Number(cell.colSpan) > 1 ? ` colspan="${Number(cell.colSpan)}"` : '') +
+                (Number(cell.rowSpan) > 1 ? ` rowspan="${Number(cell.rowSpan)}"` : '');
+            const content = (cell.children ?? []).map((child) => nodeToHtml(child, ctx)).join('');
+            return `<${tag}${span}>${content}</${tag}>`;
+        })
+            .join('');
+        return `<tr>${cells}</tr>`;
+    })
+        .join('');
+    return `<table><tbody>${rows}</tbody></table>`;
+}
+function imageToHtml(node, ctx) {
+    const rawSrc = String(node.src ?? '');
+    const src = ctx?.resolveImageUrl ? ctx.resolveImageUrl(rawSrc) : rawSrc;
+    let img = `<img src="${escapeAttr(src)}" alt="${escapeAttr(String(node.altText ?? ''))}"`;
+    if (node.width)
+        img += ` width="${Number(node.width)}"`;
+    if (node.height)
+        img += ` height="${Number(node.height)}"`;
+    img += ` data-link-type="${node.linkType === 'embedded' ? 'embedded' : 'linked'}">`;
+    const caption = typeof node.caption === 'string' && node.caption !== '' ? `<figcaption>${escapeHtml(node.caption)}</figcaption>` : '';
+    return `<figure>${img}${caption}</figure>`;
+}
+export function nodeToHtml(node, ctx) {
+    switch (node.type) {
+        case 'text':
+            return textToHtml(node);
+        case 'linebreak':
+            return '<br>';
+        case 'tab':
+            return '&#9;';
+        case 'paragraph':
+            return `<p${blockAttrs(node)}>${inlineChildren(node, ctx)}</p>`;
+        case 'heading': {
+            const tag = /^h[1-6]$/.test(String(node.tag)) ? String(node.tag) : 'h2';
+            return `<${tag}${blockAttrs(node)}>${inlineChildren(node, ctx)}</${tag}>`;
+        }
+        case 'quote':
+            return `<blockquote${blockAttrs(node)}>${inlineChildren(node, ctx)}</blockquote>`;
+        case 'list':
+            return listToHtml(node, ctx);
+        case 'link':
+        case 'autolink': {
+            const attrs = ` href="${escapeAttr(String(node.url ?? ''))}"` +
+                (node.rel ? ` rel="${escapeAttr(String(node.rel))}"` : '') +
+                (node.target ? ` target="${escapeAttr(String(node.target))}"` : '') +
+                (node.title ? ` title="${escapeAttr(String(node.title))}"` : '');
+            return `<a${attrs}>${inlineChildren(node, ctx)}</a>`;
+        }
+        case 'horizontalrule':
+            return '<hr>';
+        case 'page-break':
+            return '<div data-likhari-page-break style="page-break-after: always"></div>';
+        case 'image':
+            return imageToHtml(node, ctx);
+        case 'table':
+            return tableToHtml(node, ctx);
+        default:
+            // Unknown node (e.g. a future feature): keep its content, drop the wrapper.
+            return inlineChildren(node, ctx);
+    }
+}
+export function serializeHtml(state, ctx) {
+    return rootChildren(state).map((node) => nodeToHtml(node, ctx)).join('\n');
+}

package/dist/shared/serialized.d.ts

@@ -0,0 +1,31 @@
+import type { SerializedEditorState } from 'lexical';
+/**
+ * Loose structural view of Lexical's serialized nodes. Converters work on
+ * plain JSON so they stay free of the editor, the DOM-bound node classes and
+ * React (architecture doc §1).
+ */
+export interface SNode {
+    type: string;
+    version?: number;
+    children?: SNode[];
+    [key: string]: unknown;
+}
+export declare const FORMAT_BOLD = 1;
+export declare const FORMAT_ITALIC = 2;
+export declare const FORMAT_STRIKETHROUGH = 4;
+export declare const FORMAT_UNDERLINE = 8;
+export declare const FORMAT_CODE = 16;
+export declare const FORMAT_SUBSCRIPT = 32;
+export declare const FORMAT_SUPERSCRIPT = 64;
+export declare const FORMAT_HIGHLIGHT = 128;
+/** Pixels Lexical's own DOM export uses per indent level. */
+export declare const INDENT_PX = 40;
+export type Direction = 'ltr' | 'rtl' | null;
+export declare function rootChildren(state: SerializedEditorState): SNode[];
+export declare function textNode(text: string, format?: number, style?: string): SNode;
+export declare function elementBase(type: string, children: SNode[], extra?: Record<string, unknown>): SNode;
+export declare function paragraph(children?: SNode[], extra?: Record<string, unknown>): SNode;
+export declare function makeState(blocks: SNode[]): SerializedEditorState;
+/** Inline node types: everything else is a block. */
+export declare function isInlineNode(node: SNode): boolean;
+//# sourceMappingURL=serialized.d.ts.map

package/dist/shared/serialized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized.d.ts","sourceRoot":"","sources":["../../src/shared/serialized.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,WAAW,KAAK,CAAC;AAC9B,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,6DAA6D;AAC7D,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;AAE7C,wBAAgB,YAAY,CAAC,KAAK,EAAE,qBAAqB,GAAG,KAAK,EAAE,CAElE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAI,EAAE,KAAK,SAAK,GAAG,KAAK,CAEpE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,KAAK,CAEvG;AAED,wBAAgB,SAAS,CAAC,QAAQ,GAAE,KAAK,EAAO,EAAE,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,KAAK,CAE5F;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,qBAAqB,CAKhE;AAED,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAEjD"}

package/dist/shared/serialized.js

@@ -0,0 +1,32 @@
+export const FORMAT_BOLD = 1;
+export const FORMAT_ITALIC = 2;
+export const FORMAT_STRIKETHROUGH = 4;
+export const FORMAT_UNDERLINE = 8;
+export const FORMAT_CODE = 16;
+export const FORMAT_SUBSCRIPT = 32;
+export const FORMAT_SUPERSCRIPT = 64;
+export const FORMAT_HIGHLIGHT = 128;
+/** Pixels Lexical's own DOM export uses per indent level. */
+export const INDENT_PX = 40;
+export function rootChildren(state) {
+    return (state.root.children ?? []);
+}
+export function textNode(text, format = 0, style = '') {
+    return { type: 'text', text, detail: 0, format, mode: 'normal', style, version: 1 };
+}
+export function elementBase(type, children, extra = {}) {
+    return { type, children, direction: null, format: '', indent: 0, version: 1, ...extra };
+}
+export function paragraph(children = [], extra = {}) {
+    return elementBase('paragraph', children, { textFormat: 0, textStyle: '', ...extra });
+}
+export function makeState(blocks) {
+    const children = blocks.length > 0 ? blocks : [paragraph()];
+    return {
+        root: { type: 'root', children, direction: null, format: '', indent: 0, version: 1 },
+    };
+}
+/** Inline node types: everything else is a block. */
+export function isInlineNode(node) {
+    return node.type === 'text' || node.type === 'linebreak' || node.type === 'tab' || node.type === 'link' || node.type === 'autolink';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inshapardaz/likhari-converters",
-  "version": "0.1.9",
+  "version": "0.1.11-dev.102",
   "description": "Format transformers (Markdown/HTML/plain-text/Lexical JSON) against the canonical Lexical EditorState, isolated from UI.",
   "license": "MIT",
   "repository": {