@remigius42/morg 0.9.2 → 0.10.1

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,8 +2,9 @@ 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";
+import { columns, dedent as dedentColumns, readVanillaMarkdownOutline } from "./logseqVanillaMarkdown.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
@@ -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,10 +302,15 @@ 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");
 }
@@ -425,6 +447,9 @@ 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;
@@ -471,3 +496,266 @@ export function markdownOutlineToOrg(markdown, convert, presets, context) {
         })
     }, 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: indentation 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 => columns(/^[ \t]*/.exec(line)?.[0] ?? "")));
+    return Number.isFinite(indent) && indent
+        ? content.map(line => dedentColumns(line, indent))
+        : 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.d.ts

@@ -1,5 +1,7 @@
 import type { Outline } from "./logseqOutline.js";
 import type { ConversionContext } from "./types.js";
+export declare function dedent(line: string, column: number): string;
+export declare function columns(text: string, start?: number): number;
 /**
  * Reads a Vanilla Markdown page into Logseq's outline.
  * @param markdown The Markdown page.

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
@@ -68,10 +70,29 @@ function readMeta(lines, context) {
     }
     return meta;
 }
-// a lazy continuation line sits anywhere left of the column
-function dedent(line, column) {
-    const indent = /^ */.exec(line)?.[0].length ?? 0;
-    return line.slice(Math.min(indent, column));
+// a lazy continuation line sits anywhere left of the column; a tab
+// reaches the next tab stop (4), the part of it right of the column
+// stays as spaces
+export function dedent(line, column) {
+    let width = 0;
+    let i = 0;
+    while (width < column && (line[i] === " " || line[i] === "\t")) {
+        width = columns(line[i++] ?? "", width);
+    }
+    return " ".repeat(Math.max(0, width - column)) + line.slice(i);
+}
+// the column text ends at, from a start column, a tab reaching the next
+// tab stop
+export function columns(text, start = 0) {
+    let width = start;
+    for (const char of text) {
+        width += char === "\t" ? 4 - (width % 4) : 1;
+    }
+    return width;
+}
+// the column a list item's content starts at
+function contentColumn(line) {
+    return columns(BULLET_RE.exec(line)?.[0] ?? "");
 }
 function leadingProperties(lines) {
     const count = lines.findIndex(line => !PROPERTY_RE.test(line));
@@ -81,9 +102,9 @@ function leadingProperties(lines) {
 // its checkbox read, continuation lines moved left past the bullet
 function itemSource(item, end, lines) {
     const [first = "", ...rest] = lines.slice(span(item)[0], end + 1);
-    const column = BULLET_RE.exec(first)?.[0].length ?? 0;
+    const column = contentColumn(first);
     return [
-        taskTitle(item, first.slice(column)),
+        taskTitle(item, first.slice(BULLET_RE.exec(first)?.[0].length ?? 0)),
         ...rest.map(line => dedent(line, column))
     ];
 }
@@ -121,7 +142,7 @@ function readItem(item, level, ordered, reader) {
     reader.blocks.push(block);
     // what follows the first nested list: more lists, and text, which a
     // block's content cannot hold after its children, as child blocks
-    const column = BULLET_RE.exec(reader.lines[span(item)[0]] ?? "")?.[0].length;
+    const column = contentColumn(reader.lines[span(item)[0]] ?? "");
     const rest = nested[0]
         ? item.children.slice(item.children.indexOf(nested[0]))
         : [];
@@ -138,7 +159,7 @@ function readItem(item, level, ordered, reader) {
             meta: [],
             content: reader.lines
                 .slice(start, end + 1)
-                .map(line => dedent(line, column ?? 0))
+                .map(line => dedent(line, column))
         });
     }
 }
@@ -275,7 +296,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 = columns(reader.lines[start]?.slice(0, (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);