@remigius42/morg 0.9.1 → 0.10.0

package/dist/presets/logseq.js

@@ -5,7 +5,8 @@ import { fitsKeywordLine, FRONTMATTER_BLOCK_BEGIN, frontmatterBlock, isFrontmatt
 import { keyValueEntries } from "../core/keyValueLines.js";
 import { tryParse } from "../core/render.js";
 import { orgNodeToText } from "../core/uniorgToMdast/shared.js";
-import { markdownOutlineToOrg, orgOutlineToMarkdown } from "./logseqOutline.js";
+import { FUZZY_LINK_RE } from "./links.js";
+import { frontmatterLength, markdownOutlineToOrg, orgOutlineToMarkdown, translateMarkdownOutline, translateOrgOutline } from "./logseqOutline.js";
 /**
  * Logseq dialect preset: the outline of blocks, page properties, page
  * and block references, highlights and hiccup.
@@ -22,8 +23,21 @@ export function logseq() {
     };
     return {
         ...page,
+        markdown: {
+            ...page.markdown,
+            bullet: "-",
+            links: {
+                read: text => text.replace(LABELED_PAGE_REF_RE, "[[$2][$1]]"),
+                write: text => text.replace(FUZZY_LINK_RE, "[$2]([[$1]])")
+            }
+        },
         convertOrg: (org, convert, context) => orgOutlineToMarkdown(org, convert, presets, context),
-        convertMarkdown: (markdown, convert, context) => markdownOutlineToOrg(markdown, convert, presets, context)
+        convertMarkdown: (markdown, convert, context) => markdownOutlineToOrg(markdown, convert, presets, context),
+        translateOrg: translateOrgOutline,
+        translateMarkdown: (markdown, context) => translateMarkdownOutline(markdown, context, {
+            vanilla: propertiesToFrontmatter,
+            logseq: frontmatterToProperties
+        })
     };
 }
 // the hooks for a page's properties
@@ -47,6 +61,8 @@ function pagePreset() {
         }
     };
 }
+// a labeled page ref in Logseq Markdown
+const LABELED_PAGE_REF_RE = /\[([^\][]+)\]\(\[\[([^\][]+)\]\]\)/g;
 // the hooks for a block's content
 function blockPreset() {
     const bareUrls = new Map();
@@ -333,6 +349,64 @@ function pagePropertiesToFrontmatter(lines) {
         ? [...block, ...rest]
         : [...rest.slice(0, at + 1), ...block.slice(1, -1), ...rest.slice(at + 1)];
 }
+const MD_PAGE_PROPERTY_KEY_RE = /^[\w.-]+$/;
+// a Logseq Markdown page's lines: a frontmatter, if any, and the
+// properties below it, up to a blank line
+function splitPageLines(lines) {
+    const frontmatter = frontmatterLength(lines);
+    const blank = lines.indexOf("", frontmatter);
+    const end = blank === -1 ? lines.length : blank;
+    return {
+        frontmatter: lines.slice(0, frontmatter),
+        properties: keyValueEntries(lines.slice(frontmatter, end).join("\n")),
+        rest: lines.slice(end)
+    };
+}
+// Logseq Markdown → Vanilla Markdown: page properties as plain
+// frontmatter, as Markdown tools read metadata (ADR 0006); no org is
+// in the way, so every key maps
+function propertiesToFrontmatter(lines) {
+    const { frontmatter, properties, rest } = splitPageLines(lines);
+    if (!properties?.length) {
+        return lines;
+    }
+    const yaml = stringifyYaml(Object.fromEntries(properties), {
+        lineWidth: 0
+    }).replace(/\n$/, "");
+    return [
+        "---",
+        ...frontmatter.slice(1, -1),
+        ...yaml.split("\n"),
+        "---",
+        ...rest
+    ];
+}
+// the reverse: flat entries are page properties, written as Logseq
+// writes them; what Logseq reads no property from stays frontmatter
+function frontmatterToProperties(lines) {
+    if (lines[0] !== "---") {
+        return lines;
+    }
+    const end = lines.indexOf("---", 1);
+    const { keywords, yaml } = takeFrontmatterEntries(lines.slice(1, end).join("\n"), (key, value, text) => {
+        const flat = flatValue(value, text);
+        return flat !== null &&
+            MD_PAGE_PROPERTY_KEY_RE.test(text(key)) &&
+            !flat.includes("\n")
+            ? [[text(key), flat]]
+            : null;
+    });
+    if (!keywords.length) {
+        return lines;
+    }
+    const rest = yaml.replace(/\n+$/, "");
+    return [
+        ...(rest.trim() ? ["---", rest, "---"] : []),
+        ...keywords.map(([key, value]) => `${key}::${value ? ` ${value}` : ""}`),
+        "",
+        ...lines.slice(end + 1)
+    ];
+}
 // the reverse: leading keywords become the first block, verbatim, keys
 // lower-cased (uniorg upper-cases them, Logseq reads only lower case)
 function pageProperties(uniorgAst) {

package/dist/presets/logseqOutline.d.ts

@@ -25,6 +25,16 @@ interface Presets {
     vanillaReader?: (preset: Preset) => Preset;
     vanillaInline?: Preset;
 }
+interface MarkdownPages {
+    vanilla: (lines: string[]) => string[];
+    logseq: (lines: string[]) => string[];
+}
+/**
+ * How many lines a Markdown page's leading frontmatter takes, 0 for none.
+ * @param lines The page's lines.
+ * @returns The frontmatter's line count, its fences included.
+ */
+export declare function frontmatterLength(lines: string[]): number;
 /**
  * Converts a Logseq org page to Markdown, block by block: Logseq's,
  * or Vanilla where the preset is on the input side only.
@@ -44,4 +54,24 @@ export declare function orgOutlineToMarkdown(org: string, convert: FragmentConve
  * @returns The org page.
  */
 export declare function markdownOutlineToOrg(markdown: string, convert: FragmentConverter, presets: Presets, context: ConversionContext): string;
+/**
+ * Translates an org page between Logseq org and Vanilla org, which
+ * differ in their headlines only (ADR 0006): a block's lines are kept,
+ * but for its first line, on its stars' line in Logseq org and below an
+ * empty title in Vanilla org where it starts an element.
+ * @param org The org page.
+ * @param context The side Logseq is on.
+ * @returns The page in the other dialect.
+ */
+export declare function translateOrgOutline(org: string, context: ConversionContext): string;
+/**
+ * Translates a Markdown page between Logseq Markdown and Vanilla
+ * Markdown: blocks become list items and headings and back, their meta
+ * as Vanilla Markdown writes it (ADR 0006); a block's content is kept.
+ * @param markdown The Markdown page.
+ * @param context The side Logseq is on.
+ * @param pages What writes a page's lines in either dialect.
+ * @returns The page in the other dialect.
+ */
+export declare function translateMarkdownOutline(markdown: string, context: ConversionContext, pages: MarkdownPages): string;
 export {};

package/dist/presets/logseqOutline.js

@@ -2,6 +2,7 @@ import { consumesBracedScripts } from "../core/bracedScripts.js";
 import { mayBeLineSyntax, readsAsLineSyntax } from "../core/lineSyntax.js";
 import { positionParser, tryParse } from "../core/render.js";
 import { ZERO_WIDTH_SPACE } from "../core/markupBoundary.js";
+import { mapOutsideCode } from "../core/outsideCode.js";
 import { isDrawerStart, isOrgBlockStart, orgElementEnd } from "../core/passthroughSource.js";
 import { readVanillaMarkdownOutline } from "./logseqVanillaMarkdown.js";
 // Logseq stores a page as an outline of blocks, each block a content
@@ -20,6 +21,7 @@ const STATE_LINE_RE = /^[-*] (?=State ")/;
 const MD_HEADING_RE = /^(#{1,6})(?: (.*))?$/;
 const HEADLINE_RE = /^\*+ /;
 const FENCE_RE = /^\s*(?:```|~~~)/;
+const QUERY_LANGUAGE = "query";
 // 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: ^:{}";
@@ -149,19 +151,26 @@ function readOrgBlock({ level, lines }, joined = false) {
         content: metaFirst ? body : [first, ...body]
     };
 }
-function readOrgOutline(org, vanilla) {
-    const { page, blocks } = splitBlocks(org.replace(/\r?\n$/, "").split(/\r?\n/), line => {
+function splitOrgBlocks(org) {
+    return 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;
     });
+}
+// Vanilla org: a first line written below an empty title, as it starts
+// an element, is the block's first line again
+function joinTitle(lines) {
+    const [title, ...rest] = lines;
+    const joined = title === "" && startsElement(rest);
+    return { lines: joined ? rest : lines, joined };
+}
+function readOrgOutline(org, vanilla) {
+    const { page, blocks } = splitOrgBlocks(org);
     return {
         page,
         blocks: blocks.map(({ level, lines }) => {
-            // Vanilla org: a first line written below an empty title, as it
-            // starts an element, is the block's first line again
-            const [title, ...rest] = lines;
-            const joined = vanilla && title === "" && startsElement(rest);
-            return readOrgBlock({ level, lines: joined ? rest : lines }, joined);
+            const read = vanilla ? joinTitle(lines) : { lines, joined: false };
+            return readOrgBlock({ level, lines: read.lines }, read.joined);
         })
     };
 }
@@ -199,10 +208,18 @@ function readMarkdownBlock({ level, lines: source }) {
         content: metaFirst ? body : [titleLine, ...body]
     };
 }
+/**
+ * How many lines a Markdown page's leading frontmatter takes, 0 for none.
+ * @param lines The page's lines.
+ * @returns The frontmatter's line count, its fences included.
+ */
+export function frontmatterLength(lines) {
+    return lines[0] === "---" ? lines.indexOf("---", 1) + 1 : 0;
+}
 function readMarkdownOutline(markdown) {
     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);
+    const frontmatter = lines.slice(0, frontmatterLength(lines));
     let fenced = false;
     const { page, blocks } = splitBlocks(lines.slice(frontmatter.length), line => {
         const match = MD_BLOCK_RE.exec(line);
@@ -285,23 +302,32 @@ function startsElement(lines) {
 // an empty title keeps the space Logseq org leaves out, and a first line
 // that starts an element goes below the stars (ADR 0006)
 function writeOrgBlock(block, vanilla = false) {
-    const lines = arrange(block.metaFirst, orgMetaLines(block.meta, block.heading), block.content);
+    return writeOrgLines({
+        level: block.level,
+        lines: arrange(block.metaFirst, orgMetaLines(block.meta, block.heading), block.content)
+    }, vanilla);
+}
+function writeOrgLines({ level, lines }, vanilla) {
     const [title = "", ...more] = vanilla && startsElement(lines) ? ["", ...lines] : lines;
     return [
-        `${"*".repeat(block.level)}${title || vanilla ? ` ${title}` : ""}`,
+        `${"*".repeat(level)}${title || vanilla ? ` ${title}` : ""}`,
         ...more
     ].join("\n");
 }
 function writeOutline({ page, blocks }, writeBlock) {
     return [...page, ...blocks.map(writeBlock)].join("\n").concat("\n");
 }
-// a block's title is a headline's, which Logseq reads as inline text
-// only; converted with the lines below it, it must not read as a list,
+// a table or a rule, which Logseq reads on a headline's line
+const TITLE_ELEMENT_RE = /^(\||-{5,}\s*$)/;
+// a block's title is a headline's, inline text but for a table or a
+// rule; converted with the lines below it, it must not read as a list,
 // a headline or a fixed-width line, so an escape the core drops keeps
 // it text (ADR 0006)
 function inlineTitle(block) {
     const [title = "", ...rest] = block.content;
-    return !block.metaFirst && readsAsLineSyntax(title)
+    return !block.metaFirst &&
+        !TITLE_ELEMENT_RE.test(title) &&
+        readsAsLineSyntax(title)
         ? [`${ZERO_WIDTH_SPACE}${title}`, ...rest]
         : block.content;
 }
@@ -421,13 +447,18 @@ function writeVanillaMarkdownOutline({ page, blocks }, context) {
 export function orgOutlineToMarkdown(org, convert, presets, context) {
     const { page, blocks } = readOrgOutline(org, context.side === "output");
     const vanilla = context.side === "input";
+    if (context.side === "output") {
+        warnMisread(splitOrgBlocks(org).blocks, context, MISREAD_IN_MARKDOWN);
+    }
+    // read as Logseq org, a block's title is inline text (ADR 0006)
+    const inline = context.side !== "output";
     const pageLines = vanilla ? (presets.vanillaPage?.(page) ?? page) : page;
     const convertCarried = (fragment, preset) => convert(fragment, preset, vanilla ? presets.vanillaInline : undefined);
     const outline = {
         page: convertPage(pageLines, convertCarried, presets.page),
         blocks: blocks.map(block => ({
             ...block,
-            content: convertContent(withBracedScripts(vanilla ? inlineTitle(block) : block.content), convertCarried, presets.block)
+            content: convertContent(withBracedScripts(inline ? inlineTitle(block) : block.content), convertCarried, presets.block)
         }))
     };
     return vanilla
@@ -461,7 +492,270 @@ export function markdownOutlineToOrg(markdown, convert, presets, context) {
                 ...block,
                 content: convertMarkdownContent(block.content, convertCarried, presets.block).filter(line => line !== BRACED_SCRIPTS_LINE)
             };
-            return vanilla ? dropTitleEscape(converted) : converted;
+            return context.side === "input" ? converted : dropTitleEscape(converted);
         })
     }, block => writeOrgBlock(block, context.side === "input"));
 }
+// Logseq's task markers (mldoc's), the done ones after the bar, for
+// Emacs, which knows TODO and DONE only; Logseq reads no such line
+const TODO_LINE = "#+TODO: TODO NOW LATER DOING WAIT WAITING IN-PROGRESS STARTED | DONE CANCELED CANCELLED";
+const EMACS_UNKNOWN_MARKER_RE = /^(NOW|LATER|DOING|WAIT|WAITING|IN-PROGRESS|STARTED|CANCELED|CANCELLED)(?: |$)/;
+const KEYWORD_LINE_RE = /^#\+\S+:/;
+const OWN_TODO_LINE_RE = /^#\+(?:SEQ_|TYP_)?TODO:(.*)$/i;
+// the markers a #+TODO: line declares, without their keys
+function declaredMarkers(line) {
+    const [, markers = ""] = OWN_TODO_LINE_RE.exec(line) ?? [];
+    return markers
+        .split(/\s+/)
+        .map(marker => marker.replace(/\(.*\)$/, ""))
+        .filter(marker => marker && marker !== "|");
+}
+const LOGSEQ_MARKERS = new Set(declaredMarkers(TODO_LINE));
+// Vanilla org: a page whose blocks use a marker Emacs does not know,
+// nor the page's own #+TODO: lines, names them all after its leading
+// keywords
+function withTodoLine(page, blocks) {
+    const declared = new Set(page.flatMap(declaredMarkers));
+    const undeclared = blocks.some(({ lines }) => {
+        const [, marker = ""] = EMACS_UNKNOWN_MARKER_RE.exec(lines[0] ?? "") ?? [];
+        return marker && !declared.has(marker);
+    });
+    if (!undeclared) {
+        return page;
+    }
+    const end = page.findIndex(line => !KEYWORD_LINE_RE.test(line));
+    const at = end === -1 ? page.length : end;
+    return [...page.slice(0, at), TODO_LINE, ...page.slice(at)];
+}
+// Logseq org: the line is Vanilla org's alone; Logseq reads an own one
+// as a page property, and its markers as text, unless they are its own
+function withoutTodoLine(page, context) {
+    for (const line of page) {
+        const unknown = declaredMarkers(line).filter(marker => !LOGSEQ_MARKERS.has(marker));
+        if (unknown.length) {
+            context.onWarning?.(`Logseq reads no #+TODO: line; it shows ${unknown.join(", ")} as text`);
+        }
+    }
+    return page.filter(line => line !== TODO_LINE);
+}
+const PROPERTY_LINE_RE = /^(\s*):([^\s:]+):(?:\s+(.*?))?\s*$/;
+// a block Logseq shows collapsed is one Emacs shows folded, a property
+// in either's own terms
+function foldedProperties(lines, vanilla, context) {
+    let drawer = false;
+    return lines.map(line => {
+        const match = PROPERTY_LINE_RE.exec(line);
+        const name = match?.[2]?.toUpperCase();
+        drawer = name === "PROPERTIES" || (drawer && name !== "END");
+        return drawer && match ? foldedProperty(match, vanilla, context) : line;
+    });
+}
+// a drawer's property in the other dialect; Logseq has none of
+// Emacs's other visibilities
+function foldedProperty([line, indent = "", key = "", value = ""], vanilla, context) {
+    const name = key.toUpperCase();
+    if (vanilla) {
+        return name === "COLLAPSED" && value === "true"
+            ? `${indent}:VISIBILITY: folded`
+            : line;
+    }
+    if (name !== "VISIBILITY") {
+        return line;
+    }
+    if (value === "folded") {
+        return `${indent}:collapsed: true`;
+    }
+    context.onWarning?.(`Logseq has no VISIBILITY ${value}; kept as a property`);
+    return line;
+}
+// what Logseq (mldoc) reads otherwise than Emacs does: a search link
+// as a page ref, a radio target as a target and text; and every
+// keyword line on the page as a page property
+const MISREAD = [
+    [
+        /\[\[[*#][^\]]*\](?:\[[^\]]*\])?\]/g,
+        n => `Logseq reads ${count(n, "[[*heading]] or [[#custom-id]] link")} as refs to pages of that name`
+    ],
+    [
+        /\[\[id:[^\]]*\]\]/g,
+        n => `Logseq reads ${count(n, "[[id:…]] link")} without a label as a ref to a page of that name`
+    ],
+    [/<<<[^<>]+>>>/g, n => `Logseq misreads ${count(n, "<<<radio>>> target")}`],
+    [
+        /^\s*#\+[^\s:]+:/g,
+        n => `Logseq takes ${count(n, "#+KEY: line")} below the first headline for a page property`
+    ]
+];
+// in Logseq md, where the others are Markdown links or text
+const MISREAD_IN_MARKDOWN = [
+    [
+        /\[\[\*[^\]]*\](?:\[[^\]]*\])?\]/g,
+        n => `Logseq reads ${count(n, "[[*heading]] link")} as refs to pages of that name`
+    ]
+];
+const ORG_BLOCK_BOUNDARY_RE = /^\s*#\+(BEGIN|END)_(\S+)/i;
+function count(n, noun) {
+    return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+// Logseq org or md from Vanilla org: what Emacs constructs Logseq
+// misreads, outside org blocks, whose content is no markup
+function warnMisread(blocks, context, misread) {
+    const counts = misread.map(() => 0);
+    let block = "";
+    for (const line of blocks.flatMap(({ lines }) => lines)) {
+        const [, boundary = "", name = ""] = ORG_BLOCK_BOUNDARY_RE.exec(line) ?? [];
+        if (block || boundary) {
+            const end = boundary.toUpperCase() === "END" && name.toUpperCase() === block;
+            block = end ? "" : block || name.toUpperCase();
+            continue;
+        }
+        misread.forEach(([pattern], i) => {
+            counts[i] = (counts[i] ?? 0) + (line.match(pattern)?.length ?? 0);
+        });
+    }
+    misread.forEach(([, message], i) => {
+        if (counts[i]) {
+            context.onWarning?.(message(counts[i]));
+        }
+    });
+}
+/**
+ * Translates an org page between Logseq org and Vanilla org, which
+ * differ in their headlines only (ADR 0006): a block's lines are kept,
+ * but for its first line, on its stars' line in Logseq org and below an
+ * empty title in Vanilla org where it starts an element.
+ * @param org The org page.
+ * @param context The side Logseq is on.
+ * @returns The page in the other dialect.
+ */
+export function translateOrgOutline(org, context) {
+    if (!org) {
+        return org;
+    }
+    const vanilla = context.side === "input";
+    const { page, blocks } = splitOrgBlocks(org);
+    if (!vanilla) {
+        warnMisread(blocks, context, MISREAD);
+    }
+    return [
+        ...(vanilla ? withTodoLine(page, blocks) : withoutTodoLine(page, context)),
+        ...blocks.map(({ level, lines }) => writeOrgLines({
+            level,
+            lines: foldedProperties(vanilla ? lines : joinTitle(lines).lines, vanilla, context)
+        }, vanilla))
+    ]
+        .join("\n")
+        .concat("\n");
+}
+const ORG_BLOCK_START_RE = /^#\+begin_(\S+)(?:\s+(.*?))?\s*$/i;
+// a fence the lines hold no run of backticks as long as
+function fenceFor(lines) {
+    const longest = Math.max(2, ...lines.flatMap(line => line.match(/`+/g) ?? []).map(run => run.length));
+    return "`".repeat(longest + 1);
+}
+// Vanilla Markdown: a block's org blocks as Markdown writes them, a
+// source or example block fenced, a quote quoted, a query in a `query`
+// code block (ADR 0006); others have no Markdown form and stay
+function orgBlockToMarkdown(lines) {
+    const [, type = "", parameters = ""] = ORG_BLOCK_START_RE.exec(lines[0] ?? "") ?? [];
+    const body = lines.slice(1, -1);
+    const info = {
+        SRC: parameters,
+        EXAMPLE: "",
+        QUERY: QUERY_LANGUAGE
+    }[type.toUpperCase()];
+    if (info !== undefined) {
+        const fence = fenceFor(body);
+        return [`${fence}${info}`, ...body, fence];
+    }
+    return type.toUpperCase() === "QUOTE"
+        ? body.map(line => (line ? `> ${line}` : ">"))
+        : lines;
+}
+function orgBlocksToMarkdown(content) {
+    const result = [];
+    let fenced = false;
+    for (let i = 0; i < content.length; i++) {
+        const line = content[i] ?? "";
+        fenced = FENCE_RE.test(line) ? !fenced : fenced;
+        const end = fenced || !isOrgBlockStart(line) ? -1 : orgElementEnd(content, i);
+        if (end === -1) {
+            result.push(line);
+            continue;
+        }
+        result.push(...orgBlockToMarkdown(content.slice(i, end + 1)));
+        i = end;
+    }
+    return result;
+}
+const QUERY_FENCE_RE = /^(`{3,}|~{3,})\s*query\s*$/;
+// Logseq Markdown: a `query` code block is a query block, which Logseq
+// Markdown writes as the block itself (ADR 0006)
+function queryCodeToBlocks(content) {
+    const result = [];
+    let fence = "";
+    for (const line of content) {
+        const query = QUERY_FENCE_RE.exec(line)?.[1];
+        if (!fence && query) {
+            fence = query;
+            result.push("#+BEGIN_QUERY");
+        }
+        else if (fence && line.trim() === fence) {
+            fence = "";
+            result.push("#+END_QUERY");
+        }
+        else {
+            result.push(line);
+        }
+    }
+    return result;
+}
+// Logseq Markdown: spaces after a bullet the whole content shares, which
+// a Vanilla list item would read as its content's column
+function dedentCommon(content) {
+    const indent = Math.min(...content
+        .filter(line => line.trim())
+        .map(line => /^ */.exec(line)?.[0].length ?? 0));
+    return Number.isFinite(indent) && indent
+        ? content.map(line => line.slice(Math.min(indent, line.length)))
+        : content;
+}
+// a translation's page links, but in code
+function relinkContent(content, relink) {
+    return relink
+        ? mapOutsideCode(content.join("\n"), relink).split("\n")
+        : content;
+}
+/**
+ * Translates a Markdown page between Logseq Markdown and Vanilla
+ * Markdown: blocks become list items and headings and back, their meta
+ * as Vanilla Markdown writes it (ADR 0006); a block's content is kept.
+ * @param markdown The Markdown page.
+ * @param context The side Logseq is on.
+ * @param pages What writes a page's lines in either dialect.
+ * @returns The page in the other dialect.
+ */
+export function translateMarkdownOutline(markdown, context, pages) {
+    if (!markdown) {
+        return markdown;
+    }
+    if (context.side === "input") {
+        const { page, blocks } = readMarkdownOutline(markdown);
+        const text = pages.vanilla(page).join("\n").replace(/\n+$/, "");
+        return writeVanillaMarkdownOutline({
+            page: text ? [text] : [],
+            blocks: blocks.map(block => ({
+                ...block,
+                content: relinkContent(orgBlocksToMarkdown(dedentCommon(block.content)), context.relink)
+            }))
+        }, context);
+    }
+    const { page, blocks } = readVanillaMarkdownOutline(markdown, context);
+    return writeOutline({
+        page: pages.logseq(page),
+        blocks: blocks.map(block => ({
+            ...block,
+            content: relinkContent(queryCodeToBlocks(block.content), context.relink)
+        }))
+    }, writeMarkdownBlock);
+}

package/dist/presets/logseqVanillaMarkdown.js

@@ -22,7 +22,9 @@ function span(node) {
         (node.position?.end.line ?? 1) - 1
     ];
 }
-const BULLET_RE = /^\s*(?:[-*+]|\d+[.)])(?: |$)/;
+// a bullet up to its content's column: one to four spaces after it, or
+// one where more start indented code
+const BULLET_RE = /^\s*(?:[-*+]|\d+[.)])(?: {1,4}(?=\S)| |$)/;
 const CHECKBOX_RE = /^\[([ xX])\](?: |$)/;
 // the markers Logseq shows unchecked other than TODO, which a task item
 // writes after its checkbox
@@ -275,7 +277,12 @@ export function readVanillaMarkdownOutline(markdown, context) {
 // text below a heading is its body; after a list, a block of its own
 function readText(node, level, body, reader) {
     const [start, end] = span(node);
-    const source = reader.lines.slice(start, end + 1);
+    // a rule's source may be bulleted (`- ---`), a list in a block
+    // read from its own column, as an item's content is
+    const column = (node.position?.start.column ?? 1) - 1;
+    const source = node.type === "thematicBreak"
+        ? ["---"]
+        : reader.lines.slice(start, end + 1).map(line => dedent(line, column));
     if (body) {
         // the body's paragraphs keep the blank lines between them
         body.content.push(...(body.content.length > 1 ? [""] : []), ...source);

package/dist/presets/obsidian.js

@@ -1,5 +1,7 @@
 import { visit } from "unist-util-visit";
 import { toString } from "orgast-util-to-string";
+import { maskCode } from "../core/outsideCode.js";
+import { FUZZY_LINK_RE } from "./links.js";
 /**
  * Obsidian dialect preset: `[[Page]]` / `[[Page|alias]]` wikilinks map
  * to org fuzzy links (`[[Page]]` / `[[Page][alias]]`).
@@ -9,16 +11,28 @@ export function obsidian() {
         name: "obsidian",
         markdown: {
             read: { org: rewriteAliasedWikilinks },
-            write: fuzzyLinksToWikilinks
-        }
+            write: fuzzyLinksToWikilinks,
+            links: {
+                read: text => text.replace(ALIASED_PAGE_LINK_RE, "[[$1][$2]]"),
+                // a bare `|` would split a table's cell
+                write: (text, inTable) => text.replace(FUZZY_LINK_RE, inTable ? "[[$1\\|$2]]" : "[[$1|$2]]")
+            }
+        },
+        // Vanilla Markdown reads Obsidian's own syntax but for these; the
+        // way back has nothing to do
+        translateMarkdown: (markdown, context) => context.side === "input" ? toVanilla(markdown) : markdown
     };
 }
+const ALIASED_WIKILINK_RE = /\[\[([^\][|]+)\|([^\][]+)\]\]/g;
+// in Markdown text: not an embed, whose `|300` is a size, and with a
+// table cell's escaped pipe (`[[Page\|alias]]`)
+const ALIASED_PAGE_LINK_RE = /(?<!!)\[\[([^\][|\\]+)\\?\|([^\][]+)\]\]/g;
 // md→org: a wikilink travels as plain text; org already reads `[[Page]]`
 // as a fuzzy link, only the `[[Page|alias]]` form needs rewriting to
 // org's `[[Page][alias]]` description syntax
 function rewriteAliasedWikilinks(uniorgAst) {
     visit(uniorgAst, "text", (node) => {
-        node.value = node.value.replace(/\[\[([^\][|]+)\|([^\][]+)\]\]/g, "[[$1][$2]]");
+        node.value = node.value.replace(ALIASED_WIKILINK_RE, "[[$1][$2]]");
     });
     return uniorgAst;
 }
@@ -40,3 +54,53 @@ function fuzzyLinksToWikilinks(uniorgAst) {
     });
     return uniorgAst;
 }
+const COMMENT_RE = /%%([\s\S]*?)%%/g;
+const FOOTNOTE_LABEL_RE = /\[\^(\d+)\]/g;
+// Obsidian Markdown → Vanilla Markdown: a comment is an HTML comment,
+// an inline footnote a footnote, numbered on from the page's own, its
+// definition at the end; their delimiters count outside code only, what
+// they hold may be code
+function toVanilla(markdown) {
+    let masked = maskCode(markdown);
+    const edits = [];
+    for (const { index, 0: comment } of masked.matchAll(COMMENT_RE)) {
+        const end = index + comment.length;
+        edits.push([index, end, `<!--${markdown.slice(index + 2, end - 2)}-->`]);
+        // a footnote in a comment is part of it
+        masked =
+            masked.slice(0, index) + "\0".repeat(comment.length) + masked.slice(end);
+    }
+    let next = Math.max(0, ...[...markdown.matchAll(FOOTNOTE_LABEL_RE)].map(([, n]) => Number(n))) + 1;
+    const definitions = [];
+    for (const [start, end] of inlineFootnotes(masked)) {
+        definitions.push(`[^${next}]: ${markdown.slice(start + 2, end)}`);
+        edits.push([start, end + 1, `[^${next++}]`]);
+    }
+    let result = markdown;
+    for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0])) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return definitions.length
+        ? `${result.replace(/\n*$/, "")}\n\n${definitions.join("\n")}\n`
+        : result;
+}
+// each `^[note]`, its brackets balanced: where it starts, and its `]`
+function inlineFootnotes(text) {
+    const notes = [];
+    for (let start = text.indexOf("^["); start !== -1;) {
+        let depth = 0;
+        let end = start + 1;
+        for (; end < text.length; end++) {
+            depth += text[end] === "[" ? 1 : text[end] === "]" ? -1 : 0;
+            if (!depth) {
+                break;
+            }
+        }
+        if (end === text.length) {
+            break;
+        }
+        notes.push([start, end]);
+        start = text.indexOf("^[", end + 1);
+    }
+    return notes;
+}