@inshapardaz/likhari-converters 0.1.45-dev.337 → 0.1.45-dev.339

package/dist/convert/clean.d.ts

@@ -0,0 +1,10 @@
+import type { SerializedEditorState } from 'lexical';
+/**
+ * Tidies a document in place, the way the editor's "clean up text" does and a little further:
+ * Unicode NFC (Arabic-script text can store the same letters in different code points), runs of
+ * spaces or tabs collapsed to one, text runs with the same formatting merged, empty runs removed,
+ * and stray spaces at the start and end of each block trimmed. Text with the code format is left
+ * exactly as written. Structure, empty paragraphs and everything that is not text are untouched.
+ */
+export declare function cleanState(state: SerializedEditorState): SerializedEditorState;
+//# sourceMappingURL=clean.d.ts.map

package/dist/convert/clean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../src/convert/clean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAyFrD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,qBAAqB,GAAG,qBAAqB,CAG9E"}

package/dist/convert/clean.js

@@ -0,0 +1,104 @@
+import { FORMAT_CODE, rootChildren } from '../shared/serialized.js';
+/** Runs of two or more spaces or tabs: the same rule as the editor's own text cleanup. */
+const REPEATED_SPACE = /[ \t]{2,}/g;
+const isText = (node) => node.type === 'text';
+const isCode = (node) => (Number(node.format ?? 0) & FORMAT_CODE) !== 0;
+/** Two text runs that look the same, so can be one run. */
+function sameLook(a, b) {
+    return isText(a) && isText(b) && a.format === b.format && a.style === b.style && a.mode === b.mode && a.detail === b.detail;
+}
+/** Drops spaces from the end of the last kept text run (not code), removing the run if nothing is left. */
+function trimEnd(tidy) {
+    const last = tidy[tidy.length - 1];
+    if (!last || !isText(last) || isCode(last))
+        return;
+    last.text = String(last.text).replace(/[ \t]+$/, '');
+    if (last.text === '')
+        tidy.pop();
+}
+/** The text a run of nodes ends with, looking into a trailing link. */
+function endsWithSpace(nodes) {
+    const last = nodes[nodes.length - 1];
+    if (!last)
+        return false;
+    if (last.children && !last.children.some((c) => c.children))
+        return endsWithSpace(last.children);
+    return isText(last) && !isCode(last) && /[ \t]$/.test(String(last.text ?? ''));
+}
+/**
+ * Cleans the inline content of one element: merge look-alike runs, tidy spaces, drop empty runs.
+ * `trimEdges` trims the start and end of a block; `afterSpace` says the text before these children
+ * already ended in a space, so a space they start with is a double one.
+ */
+function cleanInline(children, trimEdges, afterSpace = false) {
+    // Merge neighbours that look the same, so a space split across two runs is seen as one.
+    const merged = [];
+    for (const child of children) {
+        const last = merged[merged.length - 1];
+        if (last && sameLook(last, child))
+            last.text = String(last.text ?? '') + String(child.text ?? '');
+        else
+            merged.push(child);
+    }
+    let previousEndsWithSpace = trimEdges || afterSpace; // at the start of a block a space is a stray one
+    const tidy = [];
+    for (const node of merged) {
+        if (!isText(node)) {
+            if (node.type === 'link' || node.type === 'autolink') {
+                // A link's text is cleaned in place, but a space doubled across its edge is still a double space.
+                node.children = cleanInline(node.children ?? [], false, previousEndsWithSpace);
+                previousEndsWithSpace = endsWithSpace(node.children);
+            }
+            else if (node.type === 'linebreak') {
+                trimEnd(tidy); // spaces at the end of a line
+                previousEndsWithSpace = true;
+            }
+            else if (node.children) {
+                // A nested block, a list inside a list item: the text before it ends there.
+                trimEnd(tidy);
+                cleanNode(node);
+                previousEndsWithSpace = true;
+            }
+            else {
+                previousEndsWithSpace = node.type === 'tab';
+            }
+            tidy.push(node);
+            continue;
+        }
+        let text = String(node.text ?? '').normalize('NFC');
+        if (!isCode(node)) {
+            text = text.replace(REPEATED_SPACE, ' ');
+            if (previousEndsWithSpace)
+                text = text.replace(/^[ \t]+/, '');
+        }
+        if (text === '')
+            continue;
+        node.text = text;
+        previousEndsWithSpace = !isCode(node) && /[ \t]$/.test(text);
+        tidy.push(node);
+    }
+    if (trimEdges)
+        trimEnd(tidy);
+    return tidy;
+}
+function cleanNode(node) {
+    const children = node.children;
+    if (!children)
+        return;
+    const hasInline = children.some((child) => isText(child) || child.type === 'linebreak' || child.type === 'tab' || child.type === 'link' || child.type === 'autolink');
+    if (hasInline)
+        node.children = cleanInline(children, true);
+    else
+        children.forEach(cleanNode);
+}
+/**
+ * Tidies a document in place, the way the editor's "clean up text" does and a little further:
+ * Unicode NFC (Arabic-script text can store the same letters in different code points), runs of
+ * spaces or tabs collapsed to one, text runs with the same formatting merged, empty runs removed,
+ * and stray spaces at the start and end of each block trimmed. Text with the code format is left
+ * exactly as written. Structure, empty paragraphs and everything that is not text are untouched.
+ */
+export function cleanState(state) {
+    rootChildren(state).forEach(cleanNode);
+    return state;
+}

package/dist/convert/index.d.ts

@@ -0,0 +1,34 @@
+import type { SerializedEditorState } from 'lexical';
+import { type FormatRegistry } from '../registry.js';
+import type { ConverterContext, FormatId } from '../types.js';
+import { cleanState } from './clean.js';
+export { cleanState };
+export interface ConvertContentOptions {
+    /** The format `content` is in. */
+    inputFormat: FormatId;
+    /** The format to write. */
+    outputFormat: FormatId;
+    /**
+     * Tidy the text on the way (see `cleanState`): Unicode NFC, repeated spaces collapsed, stray
+     * spaces at the edges of blocks trimmed, look-alike runs merged. On by default; pass `false`
+     * to convert exactly what is there.
+     */
+    clean?: boolean;
+    /** Passed to the parse and the serialize (image URL resolver and the like). */
+    context?: ConverterContext;
+    /** Defaults to the registry with all four built-in formats. */
+    registry?: FormatRegistry;
+}
+/** Reads `content` and returns it as Lexical state, cleaned unless `clean` is false. */
+export declare function convertContentToState(content: string, options: Omit<ConvertContentOptions, 'outputFormat'>): SerializedEditorState;
+/**
+ * Converts a document from one format to another through the editor's own parsers and
+ * serializers, so the result is exactly what the editor would save in that format. Needs no
+ * editor or DOM for Markdown, Lexical JSON and plain text (HTML input uses `DOMParser`).
+ *
+ * Going to a format that holds less than the input (rich text to plain text, a table to
+ * Markdown, ...) degrades the way the format's fidelity matrix says; see
+ * `docs/lexical-editor-spec.md` and `docs/markdown-dialect.md`.
+ */
+export declare function convertContent(content: string, options: ConvertContentOptions): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/convert/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,UAAU,EAAE,CAAC;AAEtB,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,WAAW,EAAE,QAAQ,CAAC;IACtB,2BAA2B;IAC3B,YAAY,EAAE,QAAQ,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,wFAAwF;AACxF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,cAAc,CAAC,GAAG,qBAAqB,CAUlI;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAGtF"}

package/dist/convert/index.js

@@ -0,0 +1,29 @@
+import { defaultFormatRegistry } from '../registry.js';
+import { cleanState } from './clean.js';
+export { cleanState };
+/** Reads `content` and returns it as Lexical state, cleaned unless `clean` is false. */
+export function convertContentToState(content, options) {
+    const { inputFormat, clean = true, context, registry = defaultFormatRegistry } = options;
+    let state;
+    try {
+        state = registry.parse(inputFormat, content, context);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`convertContent: the input is not valid ${inputFormat}: ${reason}`);
+    }
+    return clean ? cleanState(state) : state;
+}
+/**
+ * Converts a document from one format to another through the editor's own parsers and
+ * serializers, so the result is exactly what the editor would save in that format. Needs no
+ * editor or DOM for Markdown, Lexical JSON and plain text (HTML input uses `DOMParser`).
+ *
+ * Going to a format that holds less than the input (rich text to plain text, a table to
+ * Markdown, ...) degrades the way the format's fidelity matrix says; see
+ * `docs/lexical-editor-spec.md` and `docs/markdown-dialect.md`.
+ */
+export function convertContent(content, options) {
+    const registry = options.registry ?? defaultFormatRegistry;
+    return registry.serialize(options.outputFormat, convertContentToState(content, options), options.context);
+}

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { lexicalJsonConverter } from './lexical-json/index.js';
 export { markdownConverter } from './markdown/index.js';
 export { htmlConverter } from './html/index.js';
 export { mergePages, mergePagesToState, type MergePagesOptions, type PageInput } from './merge/index.js';
+export { convertContent, convertContentToState, cleanState, type ConvertContentOptions } from './convert/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,UAAU,EAAE,KAAK,qBAAqB,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -5,3 +5,4 @@ export { lexicalJsonConverter } from './lexical-json/index.js';
 export { markdownConverter } from './markdown/index.js';
 export { htmlConverter } from './html/index.js';
 export { mergePages, mergePagesToState } from './merge/index.js';
+export { convertContent, convertContentToState, cleanState } from './convert/index.js';

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

@@ -1 +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;AAmUjD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,CAO3F"}
+{"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;AAoUjD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,qBAAqB,CAO3F"}

package/dist/markdown/parse.js

@@ -264,6 +264,8 @@ function blocks(nodes, extra = {}) {
             case 'leafDirective': {
                 if (node.name === 'pagebreak')
                     out.push({ type: 'page-break', version: 1 });
+                else if (node.name === 'blank')
+                    out.push(paragraph());
                 else if (node.name === 'figure') {
                     const attrs = node.attributes ?? {};
                     const src = safeImageSrc(attrs.src ?? '');
@@ -302,7 +304,7 @@ function restoreUnknownDirectives(node, source) {
     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';
+        const unknownLeaf = c.type === 'leafDirective' && c.name !== 'pagebreak' && c.name !== 'blank' && 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 };

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

@@ -1 +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;AA6C7D,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAWjD;AAqHD,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,CAMhE;AAuJD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAM9F"}
+{"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;AA6C7D,2GAA2G;AAC3G,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAWjD;AAqHD,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,CAMhE;AAuJD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAc9F"}

package/dist/markdown/serialize.js

@@ -2,7 +2,7 @@ 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 { FORMAT_BOLD, FORMAT_CODE, FORMAT_HIGHLIGHT, FORMAT_ITALIC, FORMAT_STRIKETHROUGH, FORMAT_SUBSCRIPT, FORMAT_SUPERSCRIPT, FORMAT_UNDERLINE, isEmptyParagraph, rootChildren, } from '../shared/serialized.js';
 import { directive } from './mdast.js';
 import { layoutOrDefault, scaleOrDefault } from '../shared/poetry.js';
 import { nodeToHtml, setFootnoteOrder } from '../html/serialize.js';
@@ -333,7 +333,14 @@ function blockToMd(node, ctx) {
 export function serializeMarkdown(state, ctx) {
     const blocks = rootChildren(state);
     setFootnoteOrder(blocks);
-    const tree = { type: 'root', children: blocks.flatMap((n) => blockToMd(n, ctx)) };
+    // Markdown has no empty paragraph, so a run of them at the end of the document (which marks where a
+    // page's last paragraph ends, see mergePages) is written as `::blank` lines to survive a save.
+    let end = blocks.length;
+    while (end > 0 && (isEmptyParagraph(blocks[end - 1]) || blocks[end - 1].type === 'footnote-list'))
+        end -= 1;
+    // A document that is nothing but empty paragraphs is still just empty (end === 0).
+    const children = blocks.flatMap((n, i) => end > 0 && i >= end && isEmptyParagraph(n) ? [directive('leafDirective', 'blank', {})] : blockToMd(n, ctx));
+    const tree = { type: 'root', children };
     // remark-stringify consumes mdast; our MdNode is a structural subset of it.
     return String(processor.stringify(tree)).replace(/\n+$/, '\n').replace(/^\n+$/, '');
 }

package/dist/merge/continuation.d.ts

@@ -11,13 +11,11 @@ export declare function endsMidSentence(block: SNode): boolean;
  * and alignment. A direction left unset on either side is compatible with anything.
  */
 export declare function canJoinParagraphs(previous: SNode | undefined, next: SNode | undefined): boolean;
-/** A paragraph with nothing in it: only whitespace and line breaks. */
-export declare function isEmptyParagraph(block: SNode | undefined): boolean;
 /**
- * Whether a page's text ends with an empty line, which marks the end of a paragraph. Markdown
- * cannot hold an empty paragraph (the parser drops it), so it is read from the raw text: the
- * text must end with a blank line (`\n\n`), not just a final newline. For every other format it
- * is a trailing empty paragraph in the parsed page.
+ * Whether a page's text ends with an empty line, which marks the end of a paragraph: a trailing
+ * empty paragraph in the parsed page (Markdown writes one as `::blank`). Markdown written by hand
+ * may instead just end with a blank line (`\n\n`, not only a final newline), which the parser
+ * would drop, so for Markdown the raw text is checked too.
  */
 export declare function endsWithBlankLine(rawFormat: string, rawText: string, blocks: SNode[]): boolean;
 /** Appends `next`'s content to `previous` (which is changed), separated by one space unless one is already there. */

package/dist/merge/continuation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/merge/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAc5D;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAGrD;AAKD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,KAAK,GAAG,SAAS,EAAE,IAAI,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAM/F;AAED,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAG9F;AAKD,qHAAqH;AACrH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,CAOjE"}
+{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/merge/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAc9E;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAGrD;AAKD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,KAAK,GAAG,SAAS,EAAE,IAAI,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAM/F;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAG9F;AAKD,qHAAqH;AACrH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,IAAI,CAOjE"}

package/dist/merge/continuation.js

@@ -1,4 +1,4 @@
-import { textNode } from '../shared/serialized.js';
+import { isEmptyParagraph, textNode } from '../shared/serialized.js';
 /** Marks that end a sentence, in Urdu and Latin script: ۔ ؟ ! ? . … and the CJK full stop. */
 const SENTENCE_END = /[۔؟!?.…。]/;
 /** Closing quotes and brackets that may follow the mark and still end the sentence: ” ’ " ' ) ] » */
@@ -38,20 +38,16 @@ export function canJoinParagraphs(previous, next) {
         return false;
     return alignment(previous) === alignment(next);
 }
-/** A paragraph with nothing in it: only whitespace and line breaks. */
-export function isEmptyParagraph(block) {
-    return !!block && block.type === 'paragraph' && plainText(block).trim() === '';
-}
 /**
- * Whether a page's text ends with an empty line, which marks the end of a paragraph. Markdown
- * cannot hold an empty paragraph (the parser drops it), so it is read from the raw text: the
- * text must end with a blank line (`\n\n`), not just a final newline. For every other format it
- * is a trailing empty paragraph in the parsed page.
+ * Whether a page's text ends with an empty line, which marks the end of a paragraph: a trailing
+ * empty paragraph in the parsed page (Markdown writes one as `::blank`). Markdown written by hand
+ * may instead just end with a blank line (`\n\n`, not only a final newline), which the parser
+ * would drop, so for Markdown the raw text is checked too.
  */
 export function endsWithBlankLine(rawFormat, rawText, blocks) {
-    if (rawFormat === 'markdown')
-        return /(\r?\n[ \t]*){2,}$/.test(rawText);
-    return isEmptyParagraph(blocks[blocks.length - 1]);
+    if (isEmptyParagraph(blocks[blocks.length - 1]))
+        return true;
+    return rawFormat === 'markdown' && /(\r?\n[ \t]*){2,}$/.test(rawText);
 }
 const startsWithSpace = (children) => /^\s/.test(plainText({ type: 'x', children: children.slice(0, 1) }));
 const endsWithSpace = (children) => /\s$/.test(plainText({ type: 'x', children: children.slice(-1) }));

package/dist/merge/index.js

@@ -1,6 +1,6 @@
 import { defaultFormatRegistry } from '../registry.js';
-import { elementBase, makeState, rootChildren } from '../shared/serialized.js';
-import { canJoinParagraphs, endsMidSentence, endsWithBlankLine, isEmptyParagraph, joinParagraphs } from './continuation.js';
+import { elementBase, isEmptyParagraph, makeState, rootChildren } from '../shared/serialized.js';
+import { canJoinParagraphs, endsMidSentence, endsWithBlankLine, joinParagraphs } from './continuation.js';
 /** Parses each page and returns the combined document as Lexical state, without serializing it. */
 export function mergePagesToState(pages, options = {}) {
     const { inputFormat = 'markdown', skipBlankPages = false, joinParagraphs: joinMode, context, registry = defaultFormatRegistry } = options;

package/dist/shared/serialized.d.ts

@@ -33,4 +33,6 @@ export declare function isInlineNode(node: SNode): boolean;
  * order, among all such nodes. Walks the whole tree once so every converter
  * numbers references and their matching footnote-list entries identically. */
 export declare function collectFootnoteOrder(blocks: SNode[]): Map<string, number>;
+/** A paragraph with nothing in it: no children, or only whitespace and line breaks. */
+export declare function isEmptyParagraph(node: SNode | undefined): boolean;
 //# sourceMappingURL=serialized.d.ts.map

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

@@ -1 +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;AAED;;;8EAG8E;AAC9E,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAUzE"}
+{"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;AAED;;;8EAG8E;AAC9E,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAUzE;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAMjE"}

package/dist/shared/serialized.js

@@ -45,3 +45,9 @@ export function collectFootnoteOrder(blocks) {
     blocks.forEach(visit);
     return order;
 }
+/** A paragraph with nothing in it: no children, or only whitespace and line breaks. */
+export function isEmptyParagraph(node) {
+    return (!!node &&
+        node.type === 'paragraph' &&
+        (node.children ?? []).every((child) => (child.type === 'text' ? String(child.text ?? '').trim() === '' : child.type === 'linebreak')));
+}

package/package.json

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