@remigius42/morg 0.7.0 → 0.8.0

package/README.md

@@ -17,8 +17,8 @@ Bidirectional **Markdown ↔ Org-mode** converter, built on the
 
 morg treats Org as a canonical plain-text format and Markdown (Obsidian,
 generic) as the interop surface. Dialect conventions, such as
-[Logseq](https://docs.logseq.com/)'s `heading::` properties and outline
-nesting, are supported via presets.
+[Logseq](https://docs.logseq.com/)'s outline of blocks and page
+properties, are supported via presets.
 
 ## Round-trip convergence
 
@@ -198,19 +198,20 @@ preset })`: `preserveOrgisms` default `true`; `useHtml` (default
   `- [x]`); headings become list items and do not restore on the
   return trip; anything with priority, tags or content keeps its
   heading and reports via `onWarning`
-- `logseq({ nestUnderHeadings })`: default `true`; content following a
-  heading nests as child blocks of that heading: paragraphs become child
-  headlines one level deeper (in Logseq org every outline block is a
-  headline), other constructs stay in the preceding block's body. The
-  reverse direction restores headings from `:heading:` properties and
-  turns plain block headlines back into paragraphs. Hiccup blocks
-  (`[:div …]`) pass through as plain text and are emitted unescaped in
-  Markdown. Page properties map both directions: a first block of
+- `logseq()`: a page is Logseq's outline of blocks, converted block by
+  block: a headline (stars, a space, the block's content, an empty
+  block as the bare stars) ↔ a `-` bullet indented one tab per level,
+  its lines below the first two spaces further in. A block's content
+  is one fragment, so a code block or table that starts on the
+  headline line converts as a whole. `:heading: N` ↔ `- ## …`, a
+  block's property drawer ↔ `key:: value` lines; planning lines and
+  other drawers (`:LOGBOOK:`) stay as written. A heading outside the
+  bullets is a top-level block, as Logseq writes a page's first one.
+  Page properties map both directions: a first block of
   `key:: value` lines and flat frontmatter entries ↔ leading
   `#+key: value` lines, which Logseq reads as page properties;
   frontmatter keys that act in Emacs (`todo`, `include`, …) stay inert.
-  Logseq's own syntax maps both directions: `TODO`/`DONE`
-  text markers and `[#A]` priorities ↔ org keywords/priorities, page
+  Task markers and `[#A]` priorities stay text, page
   references `[[page]]` and labeled forms `[label]([[page]])` ↔ org
   fuzzy links `[[page][label]]`, block refs `[label](((uuid)))` ↔
   `[[((uuid))][label]]`, and `^^highlight^^` markup survives verbatim

package/dist/core/bracedScripts.d.ts

@@ -4,6 +4,13 @@ import type { OrgData } from "uniorg";
  * holds a bare underscore or caret org would read as a script.
  */
 export declare function requireBracedScripts(uniorgAst: OrgData): void;
+/**
+ * Whether org→md would consume a `^:{}` setting at the head of `org`:
+ * its text reads a script org would otherwise take for one.
+ * @param org The org text, the setting included.
+ * @returns Whether the setting is taken as the one md→org adds.
+ */
+export declare function consumesBracedScripts(org: string): boolean;
 /**
  * org→md: parses org, honoring its `^:` setting, and consuming `^:{}`
  * where the text needs it: md→org adds it only then, so anywhere else

package/dist/core/bracedScripts.js

@@ -135,6 +135,16 @@ function takeBracedScripts(uniorgAst) {
         return node.value !== "";
     });
 }
+/**
+ * Whether org→md would consume a `^:{}` setting at the head of `org`:
+ * its text reads a script org would otherwise take for one.
+ * @param org The org text, the setting included.
+ * @returns Whether the setting is taken as the one md→org adds.
+ */
+export function consumesBracedScripts(org) {
+    // text without a bare script candidate skips the parse
+    return (BARE_SCRIPT_RE.test(org) && readsBareScripts(bracedScriptsParser.parse(org)));
+}
 /**
  * org→md: parses org, honoring its `^:` setting, and consuming `^:{}`
  * where the text needs it: md→org adds it only then, so anywhere else

package/dist/core/lineSyntax.d.ts

@@ -6,6 +6,13 @@ import { type Node } from "./render.js";
  * space, or it would turn into a list item, headline, comment or table.
  */
 export declare function escapeLineSyntax(tree: Parent): void;
+/**
+ * Whether org reads a text as just one passthrough element.
+ * @param text The org text.
+ * @returns Whether it is one block, drawer, keyword … org→md writes as
+ * its org text.
+ */
+export declare function readsAsPassthrough(text: string): boolean;
 /**
  * md→org: whether a node is a paragraph org→md wrote as the org text of
  * one passthrough element, which goes back as it is.

package/dist/core/lineSyntax.js

@@ -135,8 +135,16 @@ function isPassthrough(starts) {
     if (!first || !MAY_BE_LINE_SYNTAX_RE.test(first.line)) {
         return false;
     }
-    const lines = starts.map(({ line }) => line);
-    const [only, ...rest] = tryParse(`${lines.join("\n")}\n`)?.children ?? [];
+    return readsAsPassthrough(starts.map(({ line }) => line).join("\n"));
+}
+/**
+ * Whether org reads a text as just one passthrough element.
+ * @param text The org text.
+ * @returns Whether it is one block, drawer, keyword … org→md writes as
+ * its org text.
+ */
+export function readsAsPassthrough(text) {
+    const [only, ...rest] = tryParse(`${text}\n`)?.children ?? [];
     return !rest.length && PASSTHROUGH_TYPES.has(only?.type ?? "");
 }
 /**

package/dist/core/mdastToUniorg/blocks.js

@@ -125,8 +125,11 @@ export function transformMdastCode(node) {
             value: `${node.value}\n`
         };
     }
+    // the fence's meta is the block's switches and header arguments,
+    // which uniorg-stringify writes after the language
+    const language = [node.lang, node.meta].filter(Boolean).join(" ");
     return (node.lang
-        ? { type: "src-block", language: node.lang, value: node.value }
+        ? { type: "src-block", language, value: node.value }
         : {
             type: "example-block",
             value: node.value

package/dist/core/passthroughSource.d.ts

@@ -0,0 +1,21 @@
+import type { Root } from "mdast";
+/** Whether a line opens an org block (`#+begin_name`). */
+export declare function isOrgBlockStart(line: string): boolean;
+/** Whether a line opens an org drawer (`:NAME:`). */
+export declare function isDrawerStart(line: string): boolean;
+/**
+ * The line that ends the org block or drawer a line opens.
+ * @param lines The lines.
+ * @param start The index of the opening line.
+ * @returns The index of the `#+end_name` or `:END:` line, or -1.
+ */
+export declare function orgElementEnd(lines: string[], start: number): number;
+/**
+ * md→org: a passthrough element's org text may hold lines Markdown reads
+ * as syntax of its own (a blank line and an indented one, a `#`, `-`
+ * or `>` line); the top-level nodes it parsed into become one paragraph
+ * of the source text again, which goes back to org as it is.
+ * @param mdast The parsed Markdown.
+ * @param markdown Its source.
+ */
+export declare function keepPassthroughSource(mdast: Root, markdown: string): void;

package/dist/core/passthroughSource.js

@@ -0,0 +1,94 @@
+import { readsAsPassthrough } from "./lineSyntax.js";
+// the first line of an org block or drawer
+const BLOCK_START_RE = /^#\+begin_(\S+)/i;
+const DRAWER_START_RE = /^:[\w-]+:$/;
+/** Whether a line opens an org block (`#+begin_name`). */
+export function isOrgBlockStart(line) {
+    return BLOCK_START_RE.test(line);
+}
+/** Whether a line opens an org drawer (`:NAME:`). */
+export function isDrawerStart(line) {
+    return DRAWER_START_RE.test(line);
+}
+/**
+ * The line that ends the org block or drawer a line opens.
+ * @param lines The lines.
+ * @param start The index of the opening line.
+ * @returns The index of the `#+end_name` or `:END:` line, or -1.
+ */
+export function orgElementEnd(lines, start) {
+    const end = endPattern(lines[start] ?? "");
+    return end ? lines.findIndex((other, i) => i > start && end.test(other)) : -1;
+}
+// the pattern of the line that ends the block or drawer `line` opens
+function endPattern(line) {
+    const block = BLOCK_START_RE.exec(line)?.[1];
+    if (block) {
+        return new RegExp(`^#\\+end_${block.replace(/\W/g, "\\$&")}\\s*$`, "i");
+    }
+    return DRAWER_START_RE.test(line) ? /^:end:\s*$/i : null;
+}
+// the text from `offset` through the line that ends the block or
+// drawer opening there, read line by line rather than splitting the
+// rest of the document (a page may hold thousands of drawers)
+function elementSource(markdown, offset) {
+    const lineEnd = (from) => {
+        const index = markdown.indexOf("\n", from);
+        return index === -1 ? markdown.length : index;
+    };
+    let end = lineEnd(offset);
+    const pattern = endPattern(markdown.slice(offset, end));
+    while (pattern && end < markdown.length) {
+        const next = lineEnd(end + 1);
+        if (pattern.test(markdown.slice(end + 1, next))) {
+            return markdown.slice(offset, next);
+        }
+        end = next;
+    }
+    return null;
+}
+// the source offset where the passthrough element starting at a node
+// ends, or -1
+function passthroughEnd(node, markdown) {
+    const start = node.position?.start;
+    if (start?.column !== 1 || start.offset === undefined) {
+        return -1;
+    }
+    const source = elementSource(markdown, start.offset);
+    return source !== null && readsAsPassthrough(source)
+        ? start.offset + source.length
+        : -1;
+}
+// the index of the last node ending at `end`, from `i` on, or -1
+function lastNodeAt(nodes, i, end) {
+    let j = i;
+    while ((nodes[j]?.position?.end.offset ?? end) < end) {
+        j++;
+    }
+    return nodes[j]?.position?.end.offset === end ? j : -1;
+}
+/**
+ * md→org: a passthrough element's org text may hold lines Markdown reads
+ * as syntax of its own (a blank line and an indented one, a `#`, `-`
+ * or `>` line); the top-level nodes it parsed into become one paragraph
+ * of the source text again, which goes back to org as it is.
+ * @param mdast The parsed Markdown.
+ * @param markdown Its source.
+ */
+export function keepPassthroughSource(mdast, markdown) {
+    const children = [];
+    const nodes = mdast.children;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const end = passthroughEnd(node, markdown);
+        const last = end === -1 ? -1 : lastNodeAt(nodes, i, end);
+        if (last === -1) {
+            children.push(node);
+            continue;
+        }
+        const value = markdown.slice(node.position?.start.offset, end);
+        children.push({ type: "paragraph", children: [{ type: "text", value }] });
+        i = last;
+    }
+    mdast.children = children;
+}

package/dist/core/uniorgToMdast/elements.js

@@ -253,9 +253,14 @@ function transformQuoteBlock(ctx, node) {
     };
 }
 function transformSrcBlock(node) {
+    // switches and header arguments (`-n :results output`) are the
+    // fence's meta, after the language
+    const { switches, parameters } = node;
+    const meta = [switches, parameters].filter(Boolean).join(" ");
     return {
         type: "code",
         lang: node.language || null,
+        meta: node.language && meta ? meta : null,
         value: trimTrailingNewline(node.value)
     };
 }

package/dist/core/uniorgToMdast/shared.js

@@ -24,7 +24,12 @@ export function keyValueParagraph(lines) {
 // trailing newline), for verbatim passthrough of org-only constructs
 export function orgNodeToText(node) {
     const orgText = unified()
-        .use(uniorgStringify)
+        // a preset's verbatim-inline text is org text already
+        .use(uniorgStringify, {
+        handlers: {
+            "verbatim-inline": (inline) => inline.value
+        }
+    })
         .stringify({
         type: "org-data",
         children: [node],

package/dist/index.d.ts

@@ -8,6 +8,5 @@ export { transformMdastToUniorgAst } from "./core/mdastToUniorg/index.js";
 export { transformUniorgAstToMdast } from "./core/uniorgToMdast/index.js";
 export { logseq } from "./presets/logseq.js";
 export { obsidian } from "./presets/obsidian.js";
-export type { Preset } from "./presets/types.js";
-export type { LogseqPresetOptions } from "./presets/logseq.js";
+export type { FragmentConverter, Preset } from "./presets/types.js";
 export type { Toggle, MarkdownToOrgOptions, OrgToMarkdownOptions, MarkdownStyleOptions } from "./options.js";

package/dist/markdownToOrg.js

@@ -14,6 +14,7 @@ import { escapeFootnoteReferences } from "./core/footnoteReferences.js";
 import { escapeBackslashCommands } from "./core/backslashCommands.js";
 import { escapeTablePipes } from "./core/tablePipes.js";
 import { requireBracedScripts } from "./core/bracedScripts.js";
+import { keepPassthroughSource } from "./core/passthroughSource.js";
 import { keyValueEntries } from "./core/keyValueLines.js";
 /**
  * Converts a Markdown string to an Org-mode string.
@@ -22,6 +23,17 @@ import { keyValueEntries } from "./core/keyValueLines.js";
  * @returns The converted Org-mode string.
  */
 export function convertMarkdownToOrg(markdown, options = {}) {
+    const convertMarkdown = options.preset?.convertMarkdown;
+    return convertMarkdown
+        ? // a fragment's style is the preset's, not one to record
+            convertMarkdown(markdown, (fragment, preset) => convertMarkdownToOrg(fragment, {
+                ...options,
+                preset,
+                recordStyle: false
+            }))
+        : convertMarkdownDocument(markdown, options);
+}
+function convertMarkdownDocument(markdown, options) {
     // Phase 1: Parse Markdown to mdast
     const mdast = parseMarkdown(markdown, options.preset);
     // Phase 2: Generic mdast to uniorg-ast transformation
@@ -88,6 +100,7 @@ function parseMarkdown(markdown, preset) {
         .use(remarkFrontmatter)
         .use(remarkMath)
         .parse(markdown);
+    keepPassthroughSource(mdast, markdown);
     preset?.applyToMdast?.(mdast, markdown);
     return mdast;
 }

package/dist/orgToMarkdown.js

@@ -29,6 +29,12 @@ function separateTextAfterNestedList(left, right, parent) {
  * @returns The converted Markdown string.
  */
 export function convertOrgToMarkdown(org, options = {}) {
+    const convertOrg = options.preset?.convertOrg;
+    return convertOrg
+        ? convertOrg(org, (fragment, preset) => convertOrgToMarkdown(fragment, { ...options, preset }))
+        : convertOrgDocument(org, options);
+}
+function convertOrgDocument(org, options) {
     // Phase 1: Parse Org-mode to uniorg-ast
     // md text has no scripts, so ^:{} is implied there and consumed here
     // (see markdownToOrg); uniorg misreads `_.` lines (see underscoreBullets)

package/dist/presets/logseq.d.ts

@@ -1,25 +1,6 @@
-import type { OrgData } from "uniorg";
 import type { Preset } from "./types.js";
-export interface LogseqPresetOptions {
-    /**
-     * Content following a heading becomes children of that heading's block
-     * in Logseq's outline: paragraphs turn into child block headlines one
-     * level deeper; other constructs stay in the preceding block's body.
-     * Default: `true`.
-     */
-    nestUnderHeadings?: boolean;
-}
 /**
- * Logseq dialect preset: `heading::` properties and outline nesting.
+ * Logseq dialect preset: the outline of blocks, page properties, page
+ * and block references, highlights and hiccup.
  */
-export declare function logseq(options?: LogseqPresetOptions): Preset;
-/**
- * Applies Logseq-specific conventions to a uniorg AST: every heading gets
- * a `:heading:` property drawer, and with `nestUnderHeadings` following
- * paragraphs become child block headlines (in Logseq's org format every
- * outline block is a headline).
- * @param uniorgAst The uniorg AST to transform.
- * @param nestUnderHeadings Nest content as child blocks. Default: `true`.
- * @returns The Logseq-flavored uniorg AST.
- */
-export declare function applyLogseqSpecificsToUniorgAst(uniorgAst: OrgData, nestUnderHeadings?: boolean): OrgData;
+export declare function logseq(): Preset;

package/dist/presets/logseq.js

@@ -3,43 +3,141 @@ import { toString } from "orgast-util-to-string";
 import { isScalar, isSeq } from "yaml";
 import { fitsKeywordLine, isFrontmatterNode, isModeLine, isModeLineComment, takeFrontmatterEntries } from "../core/frontmatterBlock.js";
 import { keyValueEntries } from "../core/keyValueLines.js";
+import { tryParse } from "../core/render.js";
+import { markdownOutlineToOrg, orgOutlineToMarkdown } from "./logseqOutline.js";
 /**
- * Logseq dialect preset: `heading::` properties and outline nesting.
+ * Logseq dialect preset: the outline of blocks, page properties, page
+ * and block references, highlights and hiccup.
  */
-export function logseq(options = {}) {
-    const nestUnderHeadings = options.nestUnderHeadings ?? true;
-    return {
+export function logseq() {
+    const page = {
         name: "logseq",
         applyToMdast: keepPagePropertySource,
-        applyToUniorg: uniorgAst => applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings),
-        extractFromUniorg: extractLogseqSpecificsFromUniorgAst
+        applyToUniorg: uniorgAst => {
+            rewriteLabeledPageRefs(uniorgAst);
+            takePageProperties(uniorgAst);
+            return uniorgAst;
+        },
+        extractFromUniorg: uniorgAst => {
+            pageProperties(uniorgAst);
+            return extractInlineSpecifics(uniorgAst);
+        }
+    };
+    const bareUrls = new Map();
+    const block = {
+        name: "logseq",
+        applyToMdast: mdast => {
+            countBareUrls(mdast, bareUrls);
+            emailLinksToText(mdast);
+        },
+        applyToUniorg: uniorgAst => {
+            rewriteLabeledPageRefs(uniorgAst);
+            restoreBareUrls(uniorgAst, bareUrls);
+            return uniorgAst;
+        },
+        extractFromUniorg: uniorgAst => {
+            bareUrlsToText(uniorgAst);
+            return extractInlineSpecifics(uniorgAst);
+        }
     };
-}
-function headingProperty(level) {
-    return { type: "node-property", key: "heading", value: String(level) };
-}
-function headingDrawer(level) {
     return {
-        type: "property-drawer",
-        children: [headingProperty(level)],
-        contentsBegin: 0,
-        contentsEnd: 0
+        ...page,
+        convertOrg: (org, convert) => orgOutlineToMarkdown(org, convert, { page, block }),
+        convertMarkdown: (markdown, convert) => markdownOutlineToOrg(markdown, convert, { page, block })
     };
 }
-// org fixes the order below a headline: the planning line first, then a
-// single property drawer. :heading: therefore has to let the planning
-// line pass and join an existing drawer rather than displace either.
-// Returns whether the property has been placed on `node`.
-function placeHeadingProperty(node, level) {
-    if (node.type === "planning") {
-        return false;
+// Logseq md writes a url bare, as org writes a plain link; the core
+// carries a md link as a [[url]] bracket link, so md→org counts the
+// links that were bare in the source and turns as many back to plain.
+// Where org's plain link ends short of md's autolink on trailing
+// punctuation (a macro's `}}`), that tail splits off as text
+function countBareUrls(mdast, counts) {
+    counts.clear();
+    visit(mdast, "link", (node, index, parent) => {
+        const url = bareUrl(node);
+        if (url === null) {
+            return undefined;
+        }
+        counts.set(url, (counts.get(url) ?? 0) + 1);
+        const tail = node.url.slice(url.length);
+        if (tail && parent && index !== undefined) {
+            node.url = url;
+            node.children = [{ type: "text", value: url }];
+            parent.children.splice(index + 1, 0, { type: "text", value: tail });
+        }
+        return undefined;
+    });
+}
+// the plain link org reads for a link written bare, if the rest is
+// trailing punctuation
+function bareUrl(node) {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === undefined ||
+        end === undefined ||
+        end - start !== node.url.length) {
+        return null;
     }
-    if (node.type !== "property-drawer") {
-        return false;
+    const url = orgPlainLink(node.url);
+    return url !== null && /^[^\w(]*$/.test(node.url.slice(url.length))
+        ? url
+        : null;
+}
+// the url of the plain link org reads at the start of `url`, if any;
+// it ends early at a `(` (`…/Bandwidth_(signal)`) or a macro's `}}`
+function orgPlainLink(url) {
+    if (!/^https?:\/\//.test(url)) {
+        return null;
     }
-    ;
-    node.children.unshift(headingProperty(level));
-    return true;
+    const [paragraph] = tryParse(`${url}\n`)?.children ?? [];
+    const [link] = paragraph?.children ?? [];
+    return link?.format === "plain"
+        ? link.rawLink
+        : null;
+}
+function restoreBareUrls(uniorgAst, counts) {
+    visit(uniorgAst, "link", (node) => {
+        const count = counts.get(node.rawLink) ?? 0;
+        if (node.format === "bracket" && !node.children.length && count) {
+            node.format = "plain";
+            counts.set(node.rawLink, count - 1);
+        }
+    });
+}
+// org→md: a plain http(s) link stays a bare url, unescaped
+// an email address is text in Logseq org and written bare in Logseq md,
+// where GFM links it: md→org takes such a link back to its text, and
+// org→md keeps the address unescaped (keepVerbatimText)
+const EMAIL_RE = /[\w.+-]+@[\w-]+(?:\.[\w-]+)+/;
+function emailLinksToText(mdast) {
+    visit(mdast, "link", (node, index, parent) => {
+        const start = node.position?.start.offset;
+        const end = node.position?.end.offset;
+        const text = node.url.replace(/^mailto:/, "");
+        if (node.url.startsWith("mailto:") &&
+            start !== undefined &&
+            end !== undefined &&
+            end - start === text.length &&
+            parent &&
+            index !== undefined) {
+            parent.children[index] = { type: "text", value: text };
+        }
+    });
+}
+function bareUrlsToText(uniorgAst) {
+    visit(uniorgAst, "link", (node, index, parent) => {
+        if (node.format !== "plain" ||
+            !/^https?$/.test(node.linkType) ||
+            !parent ||
+            index === undefined) {
+            return undefined;
+        }
+        parent.children[index] = {
+            type: "verbatim-inline",
+            value: node.rawLink
+        };
+        return undefined;
+    });
 }
 // the page name of a [[page]] link destination, or null. The core
 // transform percent-encodes brackets in urls (an org link path cannot
@@ -66,80 +164,6 @@ function rewriteLabeledPageRefs(uniorgAst) {
         node.path = page;
     });
 }
-function toBlockHeadline(node, level) {
-    const blockHeadline = {
-        type: "headline",
-        level,
-        todoKeyword: null,
-        priority: null,
-        commented: false,
-        rawValue: "",
-        tags: [],
-        children: node.children
-    };
-    takeTaskMarker(blockHeadline);
-    return blockHeadline;
-}
-/**
- * Applies Logseq-specific conventions to a uniorg AST: every heading gets
- * a `:heading:` property drawer, and with `nestUnderHeadings` following
- * paragraphs become child block headlines (in Logseq's org format every
- * outline block is a headline).
- * @param uniorgAst The uniorg AST to transform.
- * @param nestUnderHeadings Nest content as child blocks. Default: `true`.
- * @returns The Logseq-flavored uniorg AST.
- */
-export function applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings = true) {
-    rewriteLabeledPageRefs(uniorgAst);
-    takePageProperties(uniorgAst);
-    const children = uniorgAst.children;
-    const result = [];
-    let currentLevel = 0;
-    // level of a headline whose :heading: property still needs a home
-    let pending = null;
-    const separate = () => {
-        if (!nestUnderHeadings) {
-            result.push({ type: "text", value: "\n" });
-        }
-    };
-    // no drawer took the property: give it one of its own
-    const settle = () => {
-        if (pending === null) {
-            return;
-        }
-        result.push(headingDrawer(pending));
-        pending = null;
-        separate();
-    };
-    for (const node of children) {
-        if (node.type === "headline") {
-            settle();
-            const headline = node;
-            currentLevel = headline.level;
-            takeTaskMarker(headline);
-            result.push(node);
-            pending = headline.level;
-            continue;
-        }
-        if (pending !== null) {
-            if (placeHeadingProperty(node, pending)) {
-                pending = null;
-                result.push(node);
-                separate();
-                continue;
-            }
-            if (node.type !== "planning") {
-                settle();
-            }
-        }
-        result.push(nestUnderHeadings && node.type === "paragraph"
-            ? toBlockHeadline(node, currentLevel + 1)
-            : node);
-    }
-    settle();
-    uniorgAst.children = result;
-    return uniorgAst;
-}
 // Logseq reads a page's first block of `key:: value` lines (md) and its
 // leading `#+key: value` lines (org) as page properties (ADR 0005)
 function pagePropertyEntries(text) {
@@ -264,40 +288,35 @@ function pageProperties(uniorgAst) {
         contentsEnd: 0
     });
 }
-// Logseq md keeps TODO/DONE as leading text markers and priorities as
-// [#A] text; in org they are the headline's TODO keyword and priority
-// (other Logseq markers like DOING are not org keywords and simply
-// stay in the title text)
-function takeTaskMarker(headline) {
-    const first = headline.children[0];
-    if (first?.type !== "text") {
-        return;
-    }
-    const marker = /^(TODO|DONE) (?:\[#([A-Z])\] )?/.exec(first.value);
-    if (!marker) {
-        return;
-    }
-    headline.todoKeyword = marker[1];
-    if (marker[2]) {
-        headline.priority = marker[2];
-    }
-    first.value = first.value.slice((marker[0] ?? "").length);
-}
-/**
- * Extracts Logseq-specific conventions from a uniorg AST: headlines with
- * a `:heading:` property become plain headings of that level, headlines
- * without one are outline blocks and become paragraphs.
- * @param uniorgAst The Logseq-flavored uniorg AST to transform.
- * @returns The generic uniorg AST.
- */
-function extractLogseqSpecificsFromUniorgAst(uniorgAst) {
-    pageProperties(uniorgAst);
-    extractInParent(uniorgAst);
+function extractInlineSpecifics(uniorgAst) {
+    keepVerbatimText(uniorgAst);
     repairHighlights(uniorgAst);
     fuzzyLinksToPageRefs(uniorgAst);
     markHiccupParagraphs(uniorgAst);
     return uniorgAst;
 }
+// text Logseq md writes as it is, which remark would escape: a task's
+// priority ([#A]), an email address, and a tag's # (`#tag` starting a
+// line, which mldoc reads as escaped plain text once written `\#`);
+// verbatim-inline keeps it
+const VERBATIM_TEXT_RE = new RegExp(`(\\[#[A-Z]\\]|${EMAIL_RE.source}|(?<!\\S)#(?=[^\\s#]|$))`);
+function keepVerbatimText(uniorgAst) {
+    visit(uniorgAst, "text", (node, index, parent) => {
+        const parts = node.value.split(VERBATIM_TEXT_RE);
+        if (parts.length === 1 || !parent || index === undefined) {
+            return undefined;
+        }
+        // split's captures sit at the odd indices
+        const nodes = parts
+            .map((value, i) => ({
+            type: i % 2 ? "verbatim-inline" : "text",
+            value
+        }))
+            .filter(part => part.value);
+        parent.children.splice(index, 1, ...nodes);
+        return index + nodes.length;
+    });
+}
 // Logseq highlight markup (^^words^^) re-parses as a caret plus a
 // superscript; merge the pieces back into literal text
 function repairHighlights(uniorgAst) {
@@ -360,69 +379,3 @@ function markHiccupParagraphs(uniorgAst) {
         }
     });
 }
-function extractInParent(parent) {
-    const children = parent.children;
-    for (let i = 0; i < children.length; i++) {
-        const node = children[i];
-        if (!node) {
-            continue;
-        }
-        if (node.type === "section") {
-            extractInParent(node);
-            continue;
-        }
-        if (node.type !== "headline") {
-            continue;
-        }
-        const headline = node;
-        if (headline.todoKeyword) {
-            // back to Logseq md's text conventions (TODO [#A] Ship it);
-            // verbatim-inline keeps the [#A] brackets unescaped
-            const priority = headline.priority ? `[#${headline.priority}] ` : "";
-            headline.children.unshift({
-                type: "verbatim-inline",
-                value: `${headline.todoKeyword} ${priority}`
-            });
-            headline.todoKeyword = null;
-            headline.priority = null;
-        }
-        // a planning line sits between the headline and its drawer
-        const drawerIndex = children[i + 1]?.type === "planning" ? i + 2 : i + 1;
-        const heading = takeHeadingProperty(children, drawerIndex);
-        if (heading !== null) {
-            headline.level = heading;
-        }
-        else {
-            // a block headline (no :heading:) is outline structure only; its
-            // title is the block's content
-            children[i] = {
-                type: "paragraph",
-                children: headline.children,
-                contentsBegin: 0,
-                contentsEnd: 0
-            };
-        }
-    }
-}
-// removes the heading property from a drawer at `index` (and the drawer
-// itself if that empties it); returns the heading level or null
-function takeHeadingProperty(children, index) {
-    const drawer = children[index];
-    if (drawer?.type !== "property-drawer") {
-        return null;
-    }
-    const properties = drawer.children;
-    const heading = properties.find(property => property.key === "heading");
-    if (!heading) {
-        return null;
-    }
-    const remaining = properties.filter(property => property !== heading);
-    if (remaining.length) {
-        ;
-        drawer.children = remaining;
-    }
-    else {
-        children.splice(index, 1);
-    }
-    return parseInt(heading.value, 10) || null;
-}

package/dist/presets/logseqOutline.d.ts

@@ -0,0 +1,22 @@
+import type { FragmentConverter, Preset } from "./types.js";
+interface Presets {
+    page: Preset;
+    block: Preset;
+}
+/**
+ * Converts a Logseq org page to Logseq Markdown, block by block.
+ * @param org The org page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @returns The Markdown page.
+ */
+export declare function orgOutlineToMarkdown(org: string, convert: FragmentConverter, presets: Presets): string;
+/**
+ * Converts a Logseq Markdown page to Logseq org, block by block.
+ * @param markdown The Markdown page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @returns The org page.
+ */
+export declare function markdownOutlineToOrg(markdown: string, convert: FragmentConverter, presets: Presets): string;
+export {};

package/dist/presets/logseqOutline.js

@@ -0,0 +1,251 @@
+import { consumesBracedScripts } from "../core/bracedScripts.js";
+import { isDrawerStart, isOrgBlockStart, orgElementEnd } from "../core/passthroughSource.js";
+// Logseq stores a page as an outline of blocks, each block a content
+// string it parses on its own: org writes a block as its level's stars,
+// a space and the content (an empty block as the bare stars), Markdown
+// as a `- ` bullet indented one tab per level, continuation lines two
+// spaces further in. Both are converted block by block, so a block's
+// content (a code block, a table, lines that run on) is one fragment.
+const ORG_BLOCK_RE = /^(\*+)(?: (.*))?$/;
+const MD_BLOCK_RE = /^(\t*)-(?: (.*))?$/;
+const PLANNING_RE = /^(?:SCHEDULED|DEADLINE): /;
+const ORG_PROPERTY_RE = /^:([^\s:]+):(?: (.*))?$/;
+const MD_PROPERTY_RE = /^([\w.-]+)::(?: (.*))?$/;
+// a repeated task's log line, which Logseq bullets per format
+const STATE_LINE_RE = /^[-*] (?=State ")/;
+const MD_HEADING_RE = /^(#{1,6})(?: (.*))?$/;
+const FENCE_RE = /^\s*(?:```|~~~)/;
+// md→org adds it for the text's bare `_` and `^`, which a block's
+// content holds as Logseq writes it
+const BRACED_SCRIPTS_LINE = "#+OPTIONS: ^:{}";
+function logbook(lines, bullet) {
+    return lines[0] === ":LOGBOOK:"
+        ? lines.map(line => line.replace(STATE_LINE_RE, `${bullet} `))
+        : lines;
+}
+function splitBlocks(lines, blockLevel) {
+    const page = [];
+    const blocks = [];
+    for (const line of lines) {
+        const start = blockLevel(line);
+        if (start) {
+            blocks.push({ level: start[0], lines: [start[1]] });
+        }
+        else if (blocks.length) {
+            blocks[blocks.length - 1]?.lines.push(line);
+        }
+        else {
+            page.push(line);
+        }
+    }
+    return { page, blocks };
+}
+// a block's leading planning lines and drawers, which Logseq writes
+// below the content's first line in either format
+function takeMeta(lines, isMeta) {
+    const meta = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        if (isDrawerStart(line)) {
+            const end = orgElementEnd(lines, i);
+            if (end === -1) {
+                break;
+            }
+            meta.push(lines.slice(i, end + 1));
+            i = end + 1;
+        }
+        else if (PLANNING_RE.test(line) || isMeta(line)) {
+            meta.push([line]);
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    return { meta, body: lines.slice(i) };
+}
+// the one org block whose content Logseq md writes as Markdown markup
+// (its <quote command), and org→md writes as a md quote
+const QUOTE_BLOCK_RE = /^#\+begin_quote\b/i;
+function convertOrgBlock(block, convert, preset) {
+    if (!QUOTE_BLOCK_RE.test(block[0] ?? "")) {
+        return block;
+    }
+    const content = convertContent(block.slice(1, -1), convert, preset);
+    return [block[0] ?? "", ...content, block.at(-1) ?? ""];
+}
+// md→org: a block's org blocks stay as written, as org→md writes them,
+// but for a quote's content; the text around them converts
+function convertMarkdownContent(lines, convert, preset) {
+    const result = [];
+    let text = [];
+    let fenced = false;
+    for (let i = 0; i < lines.length; i++) {
+        fenced = FENCE_RE.test(lines[i] ?? "") ? !fenced : fenced;
+        const end = fenced || !isOrgBlockStart(lines[i] ?? "") ? -1 : orgElementEnd(lines, i);
+        if (end === -1) {
+            text.push(lines[i] ?? "");
+            continue;
+        }
+        result.push(...convertContent(text, convert, preset), ...convertOrgBlock(lines.slice(i, end + 1), convert, preset));
+        text = [];
+        i = end;
+    }
+    return [...result, ...convertContent(text, convert, preset)];
+}
+function convertContent(lines, convert, preset) {
+    const content = lines.join("\n");
+    return content.trim()
+        ? convert(content, preset).replace(/\n+$/, "").split("\n")
+        : [];
+}
+function convertPage(lines, convert, preset) {
+    // Logseq ends the page properties with a blank line
+    return lines.some(line => line.trim())
+        ? [`${convert(lines.join("\n"), preset).replace(/\n+$/, "")}\n`]
+        : [];
+}
+/**
+ * Converts a Logseq org page to Logseq Markdown, block by block.
+ * @param org The org page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @returns The Markdown page.
+ */
+export function orgOutlineToMarkdown(org, convert, presets) {
+    const { page, blocks } = splitBlocks(org.replace(/\r?\n$/, "").split(/\r?\n/), line => {
+        const match = ORG_BLOCK_RE.exec(line);
+        return match ? [match[1]?.length ?? 0, match[2] ?? ""] : null;
+    });
+    return [
+        ...convertPage(page, convert, presets.page),
+        ...blocks.map(block => orgBlockToMarkdown(block, convert, presets.block))
+    ]
+        .join("\n")
+        .concat("\n");
+}
+// org→md reads a block's bare `_` and `^` as text, as md→org writes
+// them without the setting that would say so
+function withBracedScripts(lines) {
+    const braced = [BRACED_SCRIPTS_LINE, ...lines];
+    return consumesBracedScripts(braced.join("\n")) ? braced : lines;
+}
+function orgBlockToMarkdown(block, convert, preset) {
+    const [first = "", ...rest] = block.lines;
+    // content that starts with the block's properties puts their drawer
+    // on the headline line; its heading level is then a property too
+    const metaFirst = isDrawerStart(first);
+    const { meta, body } = takeMeta(metaFirst ? block.lines : rest, () => false);
+    let heading = "";
+    const metaLines = meta.flatMap(lines => {
+        if (lines[0] !== ":PROPERTIES:") {
+            return logbook(lines, "*");
+        }
+        return lines.slice(1, -1).flatMap(line => {
+            const [, key = "", value = ""] = ORG_PROPERTY_RE.exec(line) ?? [];
+            if (!metaFirst && key === "heading" && /^[1-6]$/.test(value)) {
+                heading = "#".repeat(Number(value));
+                return [];
+            }
+            return [`${key}::${value ? ` ${value}` : ""}`];
+        });
+    });
+    const content = convertContent(withBracedScripts(metaFirst ? body : [first, ...body]), convert, preset);
+    const [title = "", ...more] = arrange(metaFirst, metaLines, content);
+    const head = [heading, title].filter(Boolean).join(" ");
+    const indent = "\t".repeat(block.level - 1);
+    return [
+        `${indent}-${head ? ` ${head}` : ""}`,
+        ...more.map(line => `${indent}  ${line}`)
+    ].join("\n");
+}
+/**
+ * Converts a Logseq Markdown page to Logseq org, block by block.
+ * @param markdown The Markdown page.
+ * @param convert The core's fragment converter.
+ * @param presets The presets for the page properties and for a block.
+ * @returns The org page.
+ */
+export function markdownOutlineToOrg(markdown, convert, presets) {
+    const lines = markdown.replace(/\r?\n$/, "").split(/\r?\n/);
+    // a leading frontmatter is page content, its `- ` lines yaml items
+    const frontmatter = lines.slice(0, lines[0] === "---" ? lines.indexOf("---", 1) + 1 : 0);
+    let fenced = false;
+    const { page, blocks } = splitBlocks(lines.slice(frontmatter.length), line => {
+        const match = MD_BLOCK_RE.exec(line);
+        // a bullet starts a block, which may open a fence of its own
+        fenced = (match ? false : fenced) !== FENCE_RE.test(match?.[2] ?? line);
+        if (match) {
+            return [(match[1]?.length ?? 0) + 1, match[2] ?? ""];
+        }
+        // a heading outside the bullets is a top-level block, as Logseq
+        // writes a page's first block if it is a heading
+        return !fenced && MD_HEADING_RE.test(line) ? [1, line] : null;
+    });
+    page.unshift(...frontmatter);
+    return [
+        ...convertPage(page, convert, presets.page),
+        ...blocks.map(block => mdBlockToOrg(block, convert, presets.block))
+    ]
+        .join("\n")
+        .concat("\n");
+}
+// a continuation line sits two spaces inside its bullet
+function dedent(line, level) {
+    const indent = `${"\t".repeat(level - 1)}  `;
+    return line.startsWith(indent)
+        ? line.slice(indent.length)
+        : line.trim()
+            ? line
+            : "";
+}
+// the md meta lines in org: `key::` lines become the property drawer,
+// where the first of them was, or below the planning lines
+function orgMetaLines(meta, heading) {
+    const properties = heading ? [`:heading: ${heading}`] : [];
+    const lines = [];
+    for (const group of meta) {
+        const property = MD_PROPERTY_RE.exec(group[0] ?? "");
+        if (!property) {
+            lines.push(...logbook(group, "-"));
+            continue;
+        }
+        if (!lines.includes(null)) {
+            lines.push(null);
+        }
+        properties.push(`:${property[1]}:${property[2] ? ` ${property[2]}` : ""}`);
+    }
+    if (properties.length && !lines.includes(null)) {
+        lines.splice(lines.filter(line => PLANNING_RE.test(line ?? "")).length, 0, null);
+    }
+    const drawer = [":PROPERTIES:", ...properties, ":END:"];
+    return lines.flatMap(line => (line === null ? drawer : [line]));
+}
+// a block's content's first line, its meta lines, then the rest of the
+// content; content that starts with the meta lines keeps them first
+function arrange(metaFirst, meta, content) {
+    return metaFirst
+        ? [...meta, ...content]
+        : [content[0] ?? "", ...meta, ...content.slice(1)];
+}
+// `## title`: the heading level and the title
+function mdHeading(line) {
+    const match = MD_HEADING_RE.exec(line);
+    return match ? [match[1]?.length ?? 0, match[2] ?? ""] : [0, line];
+}
+function mdBlockToOrg(block, convert, preset) {
+    const [first = "", ...rest] = block.lines;
+    const lines = [first, ...rest.map(line => dedent(line, block.level))];
+    // content that starts with properties: their drawer opens on the
+    // headline line
+    const metaFirst = MD_PROPERTY_RE.test(first);
+    const [heading, titleLine] = metaFirst ? [0, ""] : mdHeading(first);
+    const { meta, body } = takeMeta(metaFirst ? lines : lines.slice(1), line => MD_PROPERTY_RE.test(line));
+    const content = convertMarkdownContent(metaFirst ? body : [titleLine, ...body], convert, preset).filter(line => line !== BRACED_SCRIPTS_LINE);
+    const [title = "", ...more] = arrange(metaFirst, orgMetaLines(meta, heading), content);
+    return [
+        `${"*".repeat(block.level)}${title ? ` ${title}` : ""}`,
+        ...more
+    ].join("\n");
+}

package/dist/presets/types.d.ts

@@ -6,10 +6,18 @@ import type { OrgData } from "uniorg";
  * transform, with the Markdown source at hand; `applyToUniorg` runs in the md→org pipeline after the generic transform;
  * `extractFromUniorg` runs in the org→md pipeline before the generic
  * transform, normalizing dialect conventions back to generic uniorg.
+ * `convertOrg` and `convertMarkdown` take a whole conversion over, for a
+ * dialect whose documents are no single org or Markdown document (an
+ * outline of blocks, each its own fragment); `convert` runs the core on
+ * a fragment, with the given preset's hooks.
  */
 export interface Preset {
     name: string;
     applyToMdast?: (mdast: MdastRoot, markdown: string) => void;
     applyToUniorg?: (uniorgAst: OrgData) => OrgData;
     extractFromUniorg?: (uniorgAst: OrgData) => OrgData;
+    convertOrg?: (org: string, convert: FragmentConverter) => string;
+    convertMarkdown?: (markdown: string, convert: FragmentConverter) => string;
 }
+/** Converts a fragment with the core and the given preset's AST hooks. */
+export type FragmentConverter = (fragment: string, preset?: Preset) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remigius42/morg",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Bidirectional Markdown ↔ Org-mode converter with round-trip convergence",
   "keywords": [
     "org-mode",