@inshapardaz/likhari-converters 0.1.12 → 0.1.13-dev.109

package/dist/html/parse.d.ts

@@ -1,4 +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

@@ -1 +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"}
+{"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

@@ -16,14 +16,14 @@ const BLOCK_TAGS = new Set([
     'hr', 'pre', 'img', 'figcaption', 'dl', 'dt', 'dd', ...BLOCK_CONTAINERS,
 ]);
 /** Link hrefs with an executable scheme are dropped on import. */
-function safeUrl(url) {
+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. */
-function safeImageSrc(src) {
+export function safeImageSrc(src) {
     const trimmed = src.trim();
     if (!trimmed)
         return null;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inshapardaz/likhari-converters",
-  "version": "0.1.12",
+  "version": "0.1.13-dev.109",
   "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"
   }
 }