@inshapardaz/likhari-converters 0.1.10 → 0.1.11-dev.105

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,8 @@
+import type { SerializedEditorState } from 'lexical';
+import type { ConverterContext } from '../types.js';
+/** Link hrefs with an executable scheme are dropped on import. */
+export declare function safeUrl(url: string): string | null;
+/** Image sources: only http(s), relative and base64 image data URIs. */
+export declare function safeImageSrc(src: string): string | null;
+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;AAiCjD,kEAAkE;AAClE,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIlD;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKvD;AAiRD,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. */
+export 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. */
+export 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/markdown/index.d.ts

@@ -1,9 +1,8 @@
 import type { FormatConverter } from '../types.js';
 /**
- * Placeholder — the extended Markdown dialect (lexical-editor-spec.md §2.1)
- * is Phase 2 work (§13) and needs its own spec doc + sign-off before the
- * converter is built against it. Registered now so FormatRegistry's shape
- * is stable and callers get a clear error instead of a missing format.
+ * Extended Markdown (docs/markdown-dialect.md, ADR-0001): GFM plus a small
+ * set of directives, built on unified/remark so the same mdast tree can be
+ * rendered elsewhere.
  */
 export declare const markdownConverter: FormatConverter;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAY/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAI/B,CAAC"}

package/dist/markdown/index.js

@@ -1,15 +1,12 @@
+import { serializeMarkdown } from './serialize.js';
+import { parseMarkdown } from './parse.js';
 /**
- * Placeholder — the extended Markdown dialect (lexical-editor-spec.md §2.1)
- * is Phase 2 work (§13) and needs its own spec doc + sign-off before the
- * converter is built against it. Registered now so FormatRegistry's shape
- * is stable and callers get a clear error instead of a missing format.
+ * Extended Markdown (docs/markdown-dialect.md, ADR-0001): GFM plus a small
+ * set of directives, built on unified/remark so the same mdast tree can be
+ * rendered elsewhere.
  */
 export const markdownConverter = {
     id: 'markdown',
-    serialize() {
-        throw new Error('@inshapardaz/likhari-converters: the extended Markdown dialect is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §2.1 and §13).');
-    },
-    parse() {
-        throw new Error('@inshapardaz/likhari-converters: the extended Markdown dialect is not implemented yet (Phase 2, see docs/lexical-editor-spec.md §2.1 and §13).');
-    },
+    serialize: (state, ctx) => serializeMarkdown(state, ctx),
+    parse: (input, ctx) => parseMarkdown(input, ctx),
 };

package/dist/markdown/mdast.d.ts

@@ -0,0 +1,22 @@
+/** Minimal structural view of an mdast node: the dialect's tree is composed of
+ * several plugin-defined node types, so a loose type is more honest than a union. */
+export interface MdNode {
+    type: string;
+    children?: MdNode[];
+    value?: string;
+    depth?: number;
+    ordered?: boolean;
+    start?: number | null;
+    spread?: boolean;
+    checked?: boolean | null;
+    url?: string;
+    title?: string | null;
+    alt?: string | null;
+    lang?: string | null;
+    name?: string;
+    attributes?: Record<string, string | null | undefined> | null;
+    align?: Array<'left' | 'right' | 'center' | null> | null;
+}
+export type Attrs = Record<string, string>;
+export declare function directive(type: 'textDirective' | 'leafDirective' | 'containerDirective', name: string, attributes: Attrs, children?: MdNode[]): MdNode;
+//# sourceMappingURL=mdast.d.ts.map

package/dist/markdown/mdast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdast.d.ts","sourceRoot":"","sources":["../../src/markdown/mdast.ts"],"names":[],"mappings":"AAAA;qFACqF;AACrF,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC;IAC9D,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;CAC1D;AAED,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE3C,wBAAgB,SAAS,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,GAAG,oBAAoB,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,GAAE,MAAM,EAAO,GAAG,MAAM,CAE1J"}

package/dist/markdown/mdast.js

@@ -0,0 +1,3 @@
+export function directive(type, name, attributes, children = []) {
+    return { type, name, attributes, children };
+}

package/dist/markdown/parse.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/markdown/parse.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAoRjD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,CAI3F"}

package/dist/markdown/parse.js

@@ -0,0 +1,283 @@
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkDirective from 'remark-directive';
+import { FORMAT_BOLD, FORMAT_CODE, FORMAT_HIGHLIGHT, FORMAT_ITALIC, FORMAT_STRIKETHROUGH, FORMAT_SUBSCRIPT, FORMAT_SUPERSCRIPT, FORMAT_UNDERLINE, elementBase, makeState, paragraph, textNode, } from '../shared/serialized.js';
+import { safeImageSrc, safeUrl } from '../html/parse.js';
+const processor = unified().use(remarkParse).use(remarkGfm).use(remarkDirective);
+const ALIGNMENTS = new Set(['left', 'right', 'center', 'justify', 'start', 'end']);
+const DIRECTIVE_FORMATS = {
+    u: FORMAT_UNDERLINE,
+    sup: FORMAT_SUPERSCRIPT,
+    sub: FORMAT_SUBSCRIPT,
+    mark: FORMAT_HIGHLIGHT,
+};
+/** Inverse of the serializer's `styleToAttrs`. */
+function attrsToStyle(attrs) {
+    const parts = [];
+    const map = [['font', 'font-family'], ['size', 'font-size'], ['color', 'color'], ['bg', 'background-color']];
+    for (const [attr, prop] of map) {
+        const value = attrs[attr];
+        // A value that could break out of the declaration is dropped.
+        if (value && !/[;{}<>]/.test(value))
+            parts.push(`${prop}: ${value}`);
+    }
+    if (attrs.style && !/[{}<>]/.test(attrs.style))
+        parts.push(attrs.style);
+    return parts.join('; ');
+}
+function inline(nodes, state, out) {
+    for (const node of nodes) {
+        switch (node.type) {
+            case 'text':
+                if (node.value)
+                    out.push(textNode(node.value, state.format, state.style));
+                break;
+            case 'strong':
+                inline(node.children ?? [], { ...state, format: state.format | FORMAT_BOLD }, out);
+                break;
+            case 'emphasis':
+                inline(node.children ?? [], { ...state, format: state.format | FORMAT_ITALIC }, out);
+                break;
+            case 'delete':
+                inline(node.children ?? [], { ...state, format: state.format | FORMAT_STRIKETHROUGH }, out);
+                break;
+            case 'inlineCode':
+                if (node.value)
+                    out.push(textNode(node.value, state.format | FORMAT_CODE, state.style));
+                break;
+            case 'break':
+                out.push({ type: 'linebreak', version: 1 });
+                break;
+            case 'html':
+                // A literal <br> (how the serializer writes a line break inside a table cell).
+                if (/^<br\s*\/?>$/i.test((node.value ?? '').trim()))
+                    out.push({ type: 'linebreak', version: 1 });
+                break;
+            case 'link': {
+                const url = safeUrl(node.url ?? '');
+                const children = [];
+                inline(node.children ?? [], state, children);
+                if (!url)
+                    out.push(...children);
+                else
+                    out.push(elementBase('link', children, { url, rel: null, target: null, title: node.title ?? null }));
+                break;
+            }
+            case 'textDirective': {
+                const name = node.name ?? '';
+                if (name === 'span') {
+                    const style = attrsToStyle(node.attributes ?? {});
+                    inline(node.children ?? [], { ...state, style: [state.style, style].filter(Boolean).join('; ') }, out);
+                }
+                else {
+                    inline(node.children ?? [], { ...state, format: state.format | (DIRECTIVE_FORMATS[name] ?? 0) }, out);
+                }
+                break;
+            }
+            default:
+                // Images inside a text run are lifted out by the caller; references
+                // and unknown inline nodes keep their text.
+                if (node.children)
+                    inline(node.children, state, out);
+                else if (node.value)
+                    out.push(textNode(node.value, state.format, state.style));
+        }
+    }
+}
+function inlineOf(nodes) {
+    const out = [];
+    inline(nodes, { format: 0, style: '' }, out);
+    // Merge neighbours that ended up with identical formatting (e.g. around a restored ":30").
+    return out.reduce((acc, n) => {
+        const prev = acc[acc.length - 1];
+        if (prev && prev.type === 'text' && n.type === 'text' && prev.format === n.format && prev.style === n.style)
+            prev.text = String(prev.text) + String(n.text);
+        else
+            acc.push(n);
+        return acc;
+    }, []);
+}
+function imageBlock(node) {
+    const src = safeImageSrc(node.url ?? '');
+    if (!src)
+        return null;
+    return {
+        type: 'image', version: 1, src, altText: node.alt ?? '', caption: null,
+        linkType: /^data:/i.test(src) ? 'embedded' : 'linked', width: null, height: null,
+    };
+}
+/** A paragraph's images become block images; text between them stays paragraphs. */
+function paragraphBlocks(node, extra) {
+    const blocks = [];
+    let run = [];
+    const flush = () => {
+        const children = inlineOf(run);
+        if (children.length > 0)
+            blocks.push(paragraph(children, extra));
+        run = [];
+    };
+    for (const child of node.children ?? []) {
+        if (child.type === 'image') {
+            flush();
+            const image = imageBlock(child);
+            if (image)
+                blocks.push(image);
+        }
+        else
+            run.push(child);
+    }
+    flush();
+    return blocks;
+}
+function listBlock(node, extra) {
+    const isCheck = (node.children ?? []).some((item) => typeof item.checked === 'boolean');
+    const listType = isCheck ? 'check' : node.ordered ? 'number' : 'bullet';
+    const items = [];
+    for (const item of node.children ?? []) {
+        const textParts = [];
+        const flush = () => {
+            if (textParts.length === 0)
+                return;
+            const children = [];
+            textParts.forEach((p, i) => {
+                if (i > 0)
+                    children.push({ type: 'linebreak', version: 1 });
+                children.push(...inlineOf(p.children ?? []));
+            });
+            items.push(elementBase('listitem', children, { value: 1, ...(isCheck ? { checked: item.checked === true } : {}) }));
+            textParts.length = 0;
+        };
+        for (const child of item.children ?? []) {
+            if (child.type === 'list') {
+                flush();
+                items.push(elementBase('listitem', [listBlock(child, {})], { value: 1 }));
+            }
+            else if (child.type === 'paragraph')
+                textParts.push(child);
+            else if (child.children)
+                textParts.push({ type: 'paragraph', children: child.children });
+        }
+        flush();
+    }
+    return elementBase('list', items, { listType, start: node.ordered ? node.start ?? 1 : 1, tag: node.ordered ? 'ol' : 'ul', ...extra });
+}
+function tableBlock(node) {
+    const rows = (node.children ?? []).map((row, rowIndex) => elementBase('tablerow', (row.children ?? []).map((cell) => elementBase('tablecell', [paragraph(inlineOf(cell.children ?? []))], {
+        headerState: rowIndex === 0 ? 1 : 0, colSpan: 1, rowSpan: 1, backgroundColor: null, width: null,
+    })), { height: null }));
+    return elementBase('table', rows);
+}
+function blockExtras(attrs) {
+    const extra = {};
+    if (attrs.align && ALIGNMENTS.has(attrs.align))
+        extra.format = attrs.align;
+    if (attrs.dir === 'rtl' || attrs.dir === 'ltr')
+        extra.direction = attrs.dir;
+    const indent = Number(attrs.indent);
+    if (Number.isInteger(indent) && indent > 0)
+        extra.indent = Math.min(indent, 10);
+    return extra;
+}
+function dim(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
+}
+function blocks(nodes, extra = {}) {
+    const out = [];
+    for (const node of nodes) {
+        switch (node.type) {
+            case 'paragraph':
+                out.push(...paragraphBlocks(node, extra));
+                break;
+            case 'heading':
+                out.push(elementBase('heading', inlineOf(node.children ?? []), { tag: `h${Math.min(6, Math.max(1, node.depth ?? 2))}`, ...extra }));
+                break;
+            case 'blockquote':
+                for (const child of node.children ?? []) {
+                    if (child.type === 'paragraph')
+                        out.push(elementBase('quote', inlineOf(child.children ?? []), extra));
+                    else
+                        out.push(...blocks([child]));
+                }
+                break;
+            case 'list':
+                out.push(listBlock(node, extra));
+                break;
+            case 'code': {
+                const lines = (node.value ?? '').split('\n');
+                const children = [];
+                lines.forEach((line, i) => {
+                    if (i > 0)
+                        children.push({ type: 'linebreak', version: 1 });
+                    if (line)
+                        children.push(textNode(line, FORMAT_CODE));
+                });
+                out.push(paragraph(children, extra));
+                break;
+            }
+            case 'thematicBreak':
+                out.push({ type: 'horizontalrule', version: 1 });
+                break;
+            case 'table':
+                out.push(tableBlock(node));
+                break;
+            case 'containerDirective':
+                // Unknown containers are transparent: their content is kept.
+                out.push(...blocks(node.children ?? [], node.name === 'para' ? blockExtras(node.attributes ?? {}) : extra));
+                break;
+            case 'leafDirective': {
+                if (node.name === 'pagebreak')
+                    out.push({ type: 'page-break', version: 1 });
+                else if (node.name === 'figure') {
+                    const attrs = node.attributes ?? {};
+                    const src = safeImageSrc(attrs.src ?? '');
+                    if (src) {
+                        const caption = inlineOf(node.children ?? []).map((n) => String(n.text ?? '')).join('');
+                        out.push({
+                            type: 'image', version: 1, src, altText: attrs.alt ?? '', caption: caption || null,
+                            linkType: /^data:/i.test(src) ? 'embedded' : 'linked', width: dim(attrs.width), height: dim(attrs.height),
+                        });
+                    }
+                }
+                break;
+            }
+            case 'html':
+            case 'definition':
+            case 'yaml':
+                break; // raw HTML, link definitions and front matter carry no editable content
+            default:
+                if (node.children)
+                    out.push(...blocks(node.children, extra));
+                else if (node.value)
+                    out.push(paragraph([textNode(node.value)], extra));
+        }
+    }
+    return out;
+}
+const KNOWN_TEXT_DIRECTIVES = new Set(['span', ...Object.keys(DIRECTIVE_FORMATS)]);
+/**
+ * `remark-directive` reads any `:word` as a directive ("10:30", "a:b"), which
+ * would silently eat ordinary prose. Directives the dialect doesn't define
+ * are turned back into the literal source text.
+ */
+function restoreUnknownDirectives(node, source) {
+    if (!node.children)
+        return;
+    node.children = node.children.map((child) => {
+        const c = child;
+        const unknownText = c.type === 'textDirective' && !KNOWN_TEXT_DIRECTIVES.has(c.name ?? '');
+        const unknownLeaf = c.type === 'leafDirective' && c.name !== 'pagebreak' && c.name !== 'figure';
+        if ((unknownText || unknownLeaf) && c.position?.start.offset !== undefined && c.position.end.offset !== undefined) {
+            const raw = source.slice(c.position.start.offset, c.position.end.offset);
+            return unknownLeaf ? { type: 'paragraph', children: [{ type: 'text', value: raw }] } : { type: 'text', value: raw };
+        }
+        restoreUnknownDirectives(c, source);
+        return c;
+    });
+}
+export function parseMarkdown(input, _ctx) {
+    const tree = processor.parse(input);
+    restoreUnknownDirectives(tree, input);
+    return makeState(blocks(tree.children ?? []));
+}

package/dist/markdown/serialize.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedEditorState } from 'lexical';
+import type { ConverterContext } from '../types.js';
+import { type Attrs } from './mdast.js';
+/** Known presentation properties become readable attributes; anything else is kept verbatim in `style`. */
+export declare function styleToAttrs(style: string): Attrs;
+/** First strong character decides the direction a reader would infer without a hint. */
+export declare function autoDirection(text: string): 'ltr' | 'rtl' | null;
+export declare function serializeMarkdown(state: SerializedEditorState, ctx?: ConverterContext): string;
+//# sourceMappingURL=serialize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/markdown/serialize.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAKjD,OAAO,EAAa,KAAK,KAAK,EAAe,MAAM,SAAS,CAAC;AAyC7D,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAUjD;AAiHD,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,CAMhE;AA4GD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAI9F"}

package/dist/markdown/serialize.js

@@ -0,0 +1,289 @@
+import { unified } from 'unified';
+import remarkStringify from 'remark-stringify';
+import remarkGfm from 'remark-gfm';
+import remarkDirective from 'remark-directive';
+import { FORMAT_BOLD, FORMAT_CODE, FORMAT_HIGHLIGHT, FORMAT_ITALIC, FORMAT_STRIKETHROUGH, FORMAT_SUBSCRIPT, FORMAT_SUPERSCRIPT, FORMAT_UNDERLINE, rootChildren, } from '../shared/serialized.js';
+import { directive } from './mdast.js';
+const processor = unified()
+    .use(remarkGfm)
+    .use(remarkDirective)
+    .use(remarkStringify, { bullet: '-', emphasis: '*', strong: '*', rule: '-', fences: true, listItemIndent: 'one', incrementListMarker: true });
+const FORMAT_WRAPPERS = [
+    [FORMAT_BOLD, { key: 'strong', wrap: (c) => ({ type: 'strong', children: c }) }],
+    [FORMAT_ITALIC, { key: 'emphasis', wrap: (c) => ({ type: 'emphasis', children: c }) }],
+    [FORMAT_STRIKETHROUGH, { key: 'delete', wrap: (c) => ({ type: 'delete', children: c }) }],
+    [FORMAT_UNDERLINE, { key: 'u', wrap: (c) => directive('textDirective', 'u', {}, c) }],
+    [FORMAT_SUPERSCRIPT, { key: 'sup', wrap: (c) => directive('textDirective', 'sup', {}, c) }],
+    [FORMAT_SUBSCRIPT, { key: 'sub', wrap: (c) => directive('textDirective', 'sub', {}, c) }],
+    [FORMAT_HIGHLIGHT, { key: 'mark', wrap: (c) => directive('textDirective', 'mark', {}, c) }],
+];
+const STYLE_ATTRS = [
+    ['font-family', 'font'],
+    ['font-size', 'size'],
+    ['color', 'color'],
+    ['background-color', 'bg'],
+];
+function parseStyle(style) {
+    return style
+        .split(';')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const i = part.indexOf(':');
+        return [part.slice(0, i).trim().toLowerCase(), part.slice(i + 1).trim()];
+    })
+        .filter(([k, v]) => k && v);
+}
+/** Known presentation properties become readable attributes; anything else is kept verbatim in `style`. */
+export function styleToAttrs(style) {
+    const attrs = {};
+    const rest = [];
+    for (const [prop, value] of parseStyle(style)) {
+        const mapped = STYLE_ATTRS.find(([p]) => p === prop);
+        if (mapped)
+            attrs[mapped[1]] = value;
+        else
+            rest.push(`${prop}: ${value}`);
+    }
+    if (rest.length > 0)
+        attrs.style = rest.join('; ');
+    return attrs;
+}
+function runFor(node) {
+    const format = Number(node.format ?? 0);
+    const text = String(node.text ?? '');
+    const wrappers = [];
+    const attrs = styleToAttrs(String(node.style ?? ''));
+    if (Object.keys(attrs).length > 0) {
+        wrappers.push({ key: `span:${JSON.stringify(attrs)}`, wrap: (c) => directive('textDirective', 'span', attrs, c) });
+    }
+    for (const [bit, wrapper] of FORMAT_WRAPPERS)
+        if (format & bit)
+            wrappers.push(wrapper);
+    const leaf = format & FORMAT_CODE && text.trim() !== '' ? { type: 'inlineCode', value: text } : { type: 'text', value: text };
+    return { wrappers, leaf };
+}
+const WRAPPER_TYPES = new Set(['strong', 'emphasis', 'delete', 'textDirective']);
+/**
+ * Markdown emphasis must hug its text (`**bold** x`, never `** bold**`), so
+ * whitespace at a wrapper's edges is moved outside it. A wrapper holding only
+ * whitespace dissolves into plain text.
+ */
+function hoistWhitespace(nodes) {
+    const out = [];
+    for (const node of nodes) {
+        if (!WRAPPER_TYPES.has(node.type) || !node.children) {
+            out.push(node);
+            continue;
+        }
+        const children = hoistWhitespace(node.children);
+        let lead = '';
+        let trail = '';
+        const first = children[0];
+        if (first?.type === 'text') {
+            lead = /^\s*/.exec(first.value ?? '')[0];
+            first.value = (first.value ?? '').slice(lead.length);
+        }
+        const last = children[children.length - 1];
+        if (last?.type === 'text') {
+            trail = /\s*$/.exec(last.value ?? '')[0];
+            last.value = (last.value ?? '').slice(0, (last.value ?? '').length - trail.length);
+        }
+        const kept = children.filter((c) => c.type !== 'text' || c.value !== '');
+        if (lead)
+            out.push({ type: 'text', value: lead });
+        if (kept.length > 0)
+            out.push({ ...node, children: kept });
+        if (trail)
+            out.push({ type: 'text', value: trail });
+    }
+    return out;
+}
+/** Nests consecutive runs sharing outer wrappers: `**a *b***`, not `**a****b**`. */
+function buildInline(runs, depth = 0) {
+    const out = [];
+    let i = 0;
+    while (i < runs.length) {
+        const wrapper = runs[i].wrappers[depth];
+        if (!wrapper) {
+            out.push(runs[i].leaf);
+            i += 1;
+            continue;
+        }
+        let j = i;
+        while (j < runs.length && runs[j].wrappers[depth]?.key === wrapper.key)
+            j += 1;
+        out.push(wrapper.wrap(buildInline(runs.slice(i, j), depth + 1)));
+        i = j;
+    }
+    return out;
+}
+function mergeText(nodes) {
+    const out = [];
+    for (const node of nodes) {
+        const prev = out[out.length - 1];
+        if (node.type === 'text' && prev?.type === 'text')
+            prev.value = (prev.value ?? '') + (node.value ?? '');
+        else
+            out.push(node);
+    }
+    return out;
+}
+function inlineNodes(children, ctx) {
+    const out = [];
+    let pending = [];
+    const flush = () => {
+        if (pending.length > 0)
+            out.push(...mergeText(hoistWhitespace(buildInline(pending))));
+        pending = [];
+    };
+    for (const child of children) {
+        if (child.type === 'text') {
+            pending.push(runFor(child));
+        }
+        else if (child.type === 'tab') {
+            pending.push({ wrappers: [], leaf: { type: 'text', value: '\t' } });
+        }
+        else if (child.type === 'linebreak') {
+            flush();
+            out.push({ type: 'break' });
+        }
+        else if (child.type === 'link' || child.type === 'autolink') {
+            flush();
+            out.push({ type: 'link', url: String(child.url ?? ''), title: child.title ? String(child.title) : null, children: inlineNodes(child.children ?? [], ctx) });
+        }
+        else if (child.children) {
+            flush();
+            out.push(...inlineNodes(child.children, ctx));
+        }
+    }
+    flush();
+    return out;
+}
+// ---------------------------------------------------------------- blocks
+/** First strong character decides the direction a reader would infer without a hint. */
+export function autoDirection(text) {
+    for (const ch of text) {
+        if (/[֐-ࣿיִ-﷿ﹰ-]/.test(ch))
+            return 'rtl';
+        if (/[A-Za-zÀ-ɏ]/.test(ch))
+            return 'ltr';
+    }
+    return null;
+}
+function plainText(node) {
+    if (typeof node.text === 'string')
+        return node.text;
+    return (node.children ?? []).map(plainText).join('');
+}
+/** `:::para{align=… dir=… indent=…}` — only emitted for what the reader could not infer. */
+function withBlockAttrs(node, block) {
+    const attrs = {};
+    const format = String(node.format ?? '');
+    if (format)
+        attrs.align = format;
+    const indent = Number(node.indent ?? 0);
+    if (indent > 0)
+        attrs.indent = String(indent);
+    const dir = node.direction === 'rtl' || node.direction === 'ltr' ? node.direction : null;
+    if (dir && dir !== (autoDirection(plainText(node)) ?? dir))
+        attrs.dir = dir;
+    if (Object.keys(attrs).length === 0)
+        return block;
+    return directive('containerDirective', 'para', attrs, [block]);
+}
+function paragraphOf(children, ctx) {
+    return { type: 'paragraph', children: inlineNodes(children, ctx) };
+}
+function listToMd(node, ctx) {
+    const listType = String(node.listType ?? 'bullet');
+    const items = [];
+    for (const item of node.children ?? []) {
+        const kids = item.children ?? [];
+        const nested = kids.length === 1 && kids[0].type === 'list';
+        if (nested) {
+            const sub = listToMd(kids[0], ctx);
+            const prev = items[items.length - 1];
+            if (prev)
+                prev.children.push(sub);
+            else
+                items.push({ type: 'listItem', spread: false, checked: null, children: [sub] });
+            continue;
+        }
+        items.push({
+            type: 'listItem',
+            spread: false,
+            checked: listType === 'check' ? !!item.checked : null,
+            children: [paragraphOf(kids, ctx)],
+        });
+    }
+    return { type: 'list', ordered: listType === 'number', start: listType === 'number' ? Number(node.start ?? 1) : null, spread: false, children: items };
+}
+function imageToMd(node, ctx) {
+    const raw = String(node.src ?? '');
+    const url = ctx?.resolveImageUrl ? ctx.resolveImageUrl(raw) : raw;
+    const alt = String(node.altText ?? '');
+    const caption = typeof node.caption === 'string' && node.caption !== '' ? node.caption : null;
+    if (caption === null && !node.width && !node.height) {
+        return { type: 'paragraph', children: [{ type: 'image', url, alt, title: null }] };
+    }
+    const attrs = { src: url };
+    if (alt)
+        attrs.alt = alt;
+    if (node.width)
+        attrs.width = String(node.width);
+    if (node.height)
+        attrs.height = String(node.height);
+    return directive('leafDirective', 'figure', attrs, caption ? [{ type: 'text', value: caption }] : []);
+}
+function tableToMd(node, ctx) {
+    const rows = (node.children ?? []).map((row) => ({
+        type: 'tableRow',
+        children: (row.children ?? []).map((cell) => {
+            // A cell's blocks are flattened into one inline run separated by line breaks.
+            const parts = [];
+            (cell.children ?? []).forEach((block, i) => {
+                if (i > 0)
+                    parts.push({ type: 'html', value: '<br>' });
+                parts.push(...inlineNodes(block.children ?? [], ctx));
+            });
+            return { type: 'tableCell', children: parts };
+        }),
+    }));
+    const columns = Math.max(0, ...rows.map((r) => r.children.length));
+    return { type: 'table', align: Array.from({ length: columns }, () => null), children: rows };
+}
+function blockToMd(node, ctx) {
+    switch (node.type) {
+        case 'paragraph': {
+            const children = node.children ?? [];
+            if (children.length === 0)
+                return [];
+            return [withBlockAttrs(node, paragraphOf(children, ctx))];
+        }
+        case 'heading': {
+            const depth = Math.min(6, Math.max(1, Number(String(node.tag).slice(1)) || 2));
+            return [withBlockAttrs(node, { type: 'heading', depth, children: inlineNodes(node.children ?? [], ctx) })];
+        }
+        case 'quote':
+            return [withBlockAttrs(node, { type: 'blockquote', children: [paragraphOf(node.children ?? [], ctx)] })];
+        case 'list':
+            return [withBlockAttrs(node, listToMd(node, ctx))];
+        case 'horizontalrule':
+            return [{ type: 'thematicBreak' }];
+        case 'page-break':
+            return [directive('leafDirective', 'pagebreak', {})];
+        case 'image':
+            return [imageToMd(node, ctx)];
+        case 'table':
+            return [tableToMd(node, ctx)];
+        default:
+            // Fallback rule (dialect spec §6): unknown blocks keep their text as paragraphs.
+            return (node.children ?? []).flatMap((child) => blockToMd(child, ctx));
+    }
+}
+export function serializeMarkdown(state, ctx) {
+    const tree = { type: 'root', children: rootChildren(state).flatMap((n) => blockToMd(n, ctx)) };
+    // remark-stringify consumes mdast; our MdNode is a structural subset of it.
+    return String(processor.stringify(tree)).replace(/\n+$/, '\n').replace(/^\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.10",
+  "version": "0.1.11-dev.105",
   "description": "Format transformers (Markdown/HTML/plain-text/Lexical JSON) against the canonical Lexical EditorState, isolated from UI.",
   "license": "MIT",
   "repository": {
@@ -30,6 +30,11 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "lexical": "^0.20.0"
+    "lexical": "^0.20.0",
+    "remark-directive": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "unified": "^11.0.5"
   }
 }