@remigius42/morg 0.5.0 → 0.6.0

package/dist/core/bracedScripts.d.ts

@@ -0,0 +1,12 @@
+import type { OrgData } from "uniorg";
+/**
+ * md→org: adds `^:{}` to the document's `#+OPTIONS:` when its text
+ * holds a bare underscore or caret org would read as a script.
+ */
+export declare function requireBracedScripts(uniorgAst: OrgData): void;
+/**
+ * org→md: parses org, honoring its `^:` setting, and consuming `^:{}`
+ * where the text needs it: md→org adds it only then, so anywhere else
+ * it is the author's own setting.
+ */
+export declare function parseOrg(org: string): OrgData;

package/dist/core/bracedScripts.js

@@ -0,0 +1,159 @@
+import { unified } from "unified";
+import uniorgParse from "uniorg-parse";
+import { EXIT, visit } from "unist-util-visit";
+import { isInline, orgParser, positionParser, renderChildren, tryParse } from "./render.js";
+// org's `#+OPTIONS: ^:{}` limits sub/superscripts to the braced form
+// (`H_{2}O`), so a bare underscore or caret (`a_b`, `x^y`) stays text.
+// Markdown has no script syntax, so md text needs it; the braced
+// scripts morg itself emits are unaffected
+const BRACED_SCRIPTS = "^:{}";
+// built once: constructing a processor per parse dominates the cost
+const bracedScriptsParser = unified()
+    .use(uniorgParse, { useSubSuperscripts: "{}" })
+    .freeze();
+function isScript(node) {
+    return node.type === "subscript" || node.type === "superscript";
+}
+// a tree uniorg fails to read counts as holding none
+function countScripts(tree) {
+    let count = 0;
+    if (tree) {
+        visit(tree, (node) => {
+            if (isScript(node)) {
+                count++;
+            }
+        });
+    }
+    return count;
+}
+// a block's inline content as org renders it; a block element inside
+// (a list item's nested list) only ends a line
+function renderedContent(node) {
+    if (isInline(node) ||
+        !("children" in node) ||
+        !node.children.some(isInline)) {
+        return undefined;
+    }
+    return renderChildren(node.children).join("");
+}
+// a script org reads without `^:{}` only (uniorg's
+// matchSubstringRegex without the braced form, loosened): a `_` or `^`
+// after a non-blank, then `(`, `*`, or a word ending in a letter or
+// digit. Text without one reads the same either way and skips the parses
+const BARE_SCRIPT_RE = /\S[_^](?:[(*]|[+-]?[\p{L}\p{N}.,\\]*[\p{L}\p{N}])/u;
+// whether `tree` (of `content`) holds a script not in the braced form.
+// uniorg tries the braced form first, so without one both parsers read
+// the same, and the braced parse can be skipped
+function holdsBareScript(tree, content) {
+    let found = false;
+    visit(tree, (node) => {
+        const offset = node.position?.start.offset;
+        found =
+            isScript(node) && offset !== undefined && content[offset + 1] !== "{";
+        return found ? EXIT : undefined;
+    });
+    return found;
+}
+function readsBareScriptsIn(content) {
+    if (!BARE_SCRIPT_RE.test(content)) {
+        return false;
+    }
+    const tree = tryParse(content, positionParser);
+    return (tree !== undefined &&
+        holdsBareScript(tree, content) &&
+        countScripts(tree) > countScripts(tryParse(content, bracedScriptsParser)));
+}
+// whether org reads a script in the text that `^:{}` would keep text.
+// Checked per block as rendered, not per text node: the char before a
+// `_` or `^` may belong to a neighbor (a marker, a link's `]`, an
+// escape); a script never spans blocks
+function readsBareScripts(tree) {
+    let found = false;
+    visit(tree, (node) => {
+        const content = renderedContent(node);
+        found = content !== undefined && readsBareScriptsIn(content);
+        return found ? EXIT : undefined;
+    });
+    return found;
+}
+function isOptions(node) {
+    return (node.type === "keyword" && node.key.toUpperCase() === "OPTIONS");
+}
+/**
+ * md→org: adds `^:{}` to the document's `#+OPTIONS:` when its text
+ * holds a bare underscore or caret org would read as a script.
+ */
+export function requireBracedScripts(uniorgAst) {
+    if (!readsBareScripts(uniorgAst)) {
+        return;
+    }
+    const options = uniorgAst.children.find(isOptions);
+    if (!options) {
+        uniorgAst.children.unshift({
+            type: "keyword",
+            key: "OPTIONS",
+            value: BRACED_SCRIPTS
+        });
+    }
+    else if (!/(^|\s)\^:/.test(options.value)) {
+        // an explicit ^: setting is the author's call
+        options.value = `${options.value} ${BRACED_SCRIPTS}`;
+    }
+}
+// the `^:` setting in an `#+OPTIONS:` value, if any
+function scriptsSetting(options) {
+    const items = options.split(/\s+/).filter(item => item.startsWith("^:"));
+    return items.at(-1)?.slice(2);
+}
+// org→md honors every `^:` setting: `{}` limits scripts to the braced
+// form, `nil` turns them off, `t` (org's default) keeps them on
+const scriptsParsers = {
+    "{}": bracedScriptsParser,
+    nil: unified().use(uniorgParse, { useSubSuperscripts: false }).freeze()
+};
+// the settings the document may use, which the parser has to know up
+// front; only a top-level keyword counts, which takes a parse to tell
+function mayUseScripts(org) {
+    const settings = [...org.matchAll(/^[ \t]*#\+options:(.*)$/gim)].map(([, value]) => scriptsSetting(value ?? ""));
+    return [...new Set(settings)].filter((setting) => setting !== undefined);
+}
+function usesScripts(uniorgAst, setting) {
+    return uniorgAst.children.some(node => isOptions(node) && scriptsSetting(node.value) === setting);
+}
+// drops `^:{}` from the top-level `#+OPTIONS:`, the whole keyword if
+// nothing else is left; md text has no scripts, so the return trip
+// re-adds it wherever it is needed
+function takeBracedScripts(uniorgAst) {
+    uniorgAst.children = uniorgAst.children.filter(node => {
+        if (!isOptions(node)) {
+            return true;
+        }
+        node.value = node.value
+            .split(/\s+/)
+            .filter(item => item && item !== BRACED_SCRIPTS)
+            .join(" ");
+        return node.value !== "";
+    });
+}
+/**
+ * org→md: parses org, honoring its `^:` setting, and consuming `^:{}`
+ * where the text needs it: md→org adds it only then, so anywhere else
+ * it is the author's own setting.
+ */
+export function parseOrg(org) {
+    for (const setting of mayUseScripts(org)) {
+        const parser = scriptsParsers[setting];
+        if (!parser) {
+            continue;
+        }
+        // keywords parse the same either way
+        const uniorgAst = parser.parse(org);
+        if (usesScripts(uniorgAst, setting)) {
+            if (setting === "{}" && readsBareScripts(uniorgAst)) {
+                takeBracedScripts(uniorgAst);
+            }
+            return uniorgAst;
+        }
+    }
+    return orgParser.parse(org);
+}

package/dist/core/footnoteReferences.d.ts

@@ -0,0 +1,10 @@
+import type { Parent } from "unist";
+/**
+ * md→org: escapes a literal `[fn:` in text.
+ */
+export declare function escapeFootnoteReferences(tree: Parent): void;
+/**
+ * org→md: drops the zero-width spaces `escapeFootnoteReferences`
+ * inserts.
+ */
+export declare function unescapeFootnoteReferences(tree: Parent): void;

package/dist/core/footnoteReferences.js

@@ -0,0 +1,24 @@
+import { visit } from "unist-util-visit";
+import { ZERO_WIDTH_SPACE } from "./markupBoundary.js";
+// org reads `[fn:` in text as a footnote reference (`[fn:1]`, `[fn::x]`,
+// `[fn:a:x]`), at a line start as a definition; a zero-width space after
+// the `[` leaves it text
+const REFERENCE = "[fn:";
+const ESCAPED = `[${ZERO_WIDTH_SPACE}fn:`;
+/**
+ * md→org: escapes a literal `[fn:` in text.
+ */
+export function escapeFootnoteReferences(tree) {
+    visit(tree, "text", (node) => {
+        node.value = node.value?.replaceAll(REFERENCE, ESCAPED);
+    });
+}
+/**
+ * org→md: drops the zero-width spaces `escapeFootnoteReferences`
+ * inserts.
+ */
+export function unescapeFootnoteReferences(tree) {
+    visit(tree, "text", (node) => {
+        node.value = node.value?.replaceAll(ESCAPED, REFERENCE);
+    });
+}

package/dist/core/lineSyntax.d.ts

@@ -0,0 +1,12 @@
+import type { Parent } from "unist";
+/**
+ * md→org: a paragraph line org would read as line syntax (an escaped
+ * `1\.` or `\*`, or a lazy continuation line) gets a leading zero-width
+ * space, or it would turn into a list item, headline, comment or table.
+ */
+export declare function escapeLineSyntax(tree: Parent): void;
+/**
+ * org→md: drops the line-start zero-width spaces `escapeLineSyntax`
+ * inserts.
+ */
+export declare function unescapeLineSyntax(tree: Parent): void;

package/dist/core/lineSyntax.js

@@ -0,0 +1,206 @@
+import { visit } from "unist-util-visit";
+// a line starting with a zero-width space is no org line syntax (list
+// item, headline, comment, keyword, table, ...), but renders as text
+import { ZERO_WIDTH_SPACE } from "./markupBoundary.js";
+import { delimiters, isInline, locate, positionParser, renderInline, tryParse } from "./render.js";
+// org line syntax starts with a bullet or stars and a blank (`- `,
+// `+ `, `** `), a rule (`-----`, table.el's `+-`), `#` and a blank or `+`,
+// `|`, `:`, `[fn:`, `\begin{`, `%%(`, or a word followed by `.`, `)` or
+// `:` (`1.`, `a)`, `CLOCK:`, `_.`); any other line (one starting with a
+// link, markup or code, say) is text, and skips the parse
+const MAY_BE_LINE_SYNTAX_RE = /^(?:[-+]|\*+)(?:\s|$)|^(?:-{5}|\+-|#(?:\s|$|\+)|[|:]|\[fn:|\\begin\{|%%\()|^[\p{L}\p{N}_]+[.):]/u;
+// whether org reads `line` as anything but a plain paragraph
+function readsAsLineSyntax(line) {
+    if (!MAY_BE_LINE_SYNTAX_RE.test(line)) {
+        return false;
+    }
+    // with its newline: a bullet ending the line (`1.`) needs one
+    const tree = tryParse(`${line}\n`);
+    if (!tree) {
+        // escaped, uniorg reads the line as text too
+        return true;
+    }
+    const [first, ...rest] = tree.children;
+    return first?.type !== "paragraph" || rest.length > 0;
+}
+// the rendered segments of inline content, descending into markup and
+// link descriptions, since a line may start inside them (`*a\n# b*`)
+function segments(children) {
+    return children.flatMap((node, index) => {
+        const at = { node, siblings: children, index };
+        if (!isInline(node)) {
+            // a block element (nested list, code block) only ends a line
+            return [{ ...at, text: "\n", opens: false }];
+        }
+        const inner = "children" in node ? node.children : [];
+        if (!inner.length) {
+            return [{ ...at, text: renderInline(node), opens: true }];
+        }
+        const [open, close] = delimiters(node);
+        return [
+            { ...at, text: open, opens: true },
+            ...segments(inner),
+            { ...at, text: close, opens: false }
+        ];
+    });
+}
+// the lines of the content as org renders it, not per text node: a
+// line may start with another node (`[fn:1] a`) or its syntax span
+// nodes (`* ~x~`). A line following a bullet or label has no start
+function lineStarts(children, { afterBullet }) {
+    const parts = segments(children);
+    const rendered = parts.map(part => part.text);
+    const content = rendered.join("");
+    const breaks = [0];
+    for (let i = content.indexOf("\n"); i !== -1; i = content.indexOf("\n", i + 1)) {
+        breaks.push(i + 1);
+    }
+    const starts = breaks.flatMap((lineBreak, number) => {
+        // org keeps a continuation line's indentation in the text
+        const [, indent = "", line = ""] = /^([ \t]*)(.*)/.exec(content.slice(lineBreak)) ?? [];
+        const [index, offset] = locate(rendered, lineBreak + indent.length);
+        const segment = parts[index];
+        return line && segment && !(afterBullet && number === 0)
+            ? [{ segment, offset, line, number }]
+            : [];
+    });
+    return { starts, lines: content.split("\n") };
+}
+// calls `rewrite` on every paragraph, every list item whose inline
+// content md→org flattens, and every headline (a logseq block's title
+// may span lines), with its context;
+// `applies` skips the rendering where there is nothing to rewrite
+function rewriteLines(tree, rewrite, applies = () => true) {
+    visit(tree, (node, index, parent) => {
+        if (!["paragraph", "list-item", "headline"].includes(node.type)) {
+            return;
+        }
+        const children = node.children;
+        if (applies(children)) {
+            rewrite(children, contextOf(node, index ?? 0, parent));
+        }
+    });
+}
+function contextOf(node, index, parent) {
+    return {
+        afterBullet: node.type === "list-item" ||
+            node.type === "headline" ||
+            (index === 0 &&
+                (parent?.type === "list-item" ||
+                    parent?.type === "footnote-definition")),
+        afterHeadline: parent?.children[index - 1]?.type === "headline",
+        headline: node.type === "headline"
+    };
+}
+/**
+ * md→org: a paragraph line org would read as line syntax (an escaped
+ * `1\.` or `\*`, or a lazy continuation line) gets a leading zero-width
+ * space, or it would turn into a list item, headline, comment or table.
+ */
+export function escapeLineSyntax(tree) {
+    rewriteLines(tree, (children, context) => {
+        const { starts } = lineStarts(children, context);
+        // passthrough is a paragraph of its own
+        if (!context.afterBullet && isPassthrough(starts)) {
+            return;
+        }
+        // back to front, so earlier offsets and indices stay valid
+        for (const { segment, offset, line } of starts.reverse()) {
+            if (readsAsLineSyntax(line)) {
+                escapeLineStart(segment, offset);
+            }
+        }
+        escapeElementStarts(children, context);
+    });
+}
+// org→md writes these org elements as md paragraphs of their org text,
+// to be read back as such (verbatim passthrough, see mappings.md)
+const PASSTHROUGH_TYPES = new Set([
+    "fixed-width",
+    "drawer",
+    "clock",
+    "diary-sexp",
+    "keyword",
+    "babel-call",
+    "special-block",
+    "center-block",
+    "verse-block",
+    "comment-block",
+    "export-block"
+]);
+// whether org reads the lines, all of them starting a line, as just
+// one passthrough element
+function isPassthrough(starts) {
+    const [first] = 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 !rest.length && PASSTHROUGH_TYPES.has(only?.type ?? "");
+}
+// line syntax spanning lines (`#+begin_src`…`#+end_src`, a drawer) or
+// depending on context (planning below a headline) shows only in the
+// whole content as org reads it; each round escapes the first line of
+// an element org reads there, as long as that exposes another
+function escapeElementStarts(children, context) {
+    const escaped = new Set();
+    for (;;) {
+        const { starts, lines } = lineStarts(children, context);
+        if (!starts.some(({ line }) => MAY_BE_LINE_SYNTAX_RE.test(line))) {
+            return;
+        }
+        const number = elementLine(lines, context);
+        const start = starts.find(candidate => candidate.number === number);
+        if (number === undefined || !start || escaped.has(number)) {
+            return;
+        }
+        escaped.add(number);
+        escapeLineStart(start.segment, start.offset);
+    }
+}
+// the index of the first content line org reads as the start of an
+// element other than a paragraph, if any
+function elementLine(lines, context) {
+    // a line after a bullet only continues the item's text
+    const first = context.headline ? "* x" : "x";
+    const content = context.afterBullet ? [first, ...lines.slice(1)] : lines;
+    const prefix = context.afterHeadline ? ["* x"] : [];
+    const tree = tryParse([...prefix, ...content, ""].join("\n"), positionParser);
+    const elements = (tree?.children ?? []).flatMap(node => node.type === "section" && "children" in node
+        ? node.children
+        : [node]);
+    const element = elements.find(node => node.type !== "paragraph" && node.type !== "headline");
+    const line = element?.position?.start.line;
+    return line === undefined ? undefined : line - 1 - prefix.length;
+}
+function escapeLineStart({ node, siblings, index, opens }, offset) {
+    if (node.type === "text") {
+        const value = node.value ?? "";
+        node.value = value.slice(0, offset) + ZERO_WIDTH_SPACE + value.slice(offset);
+    }
+    else if (opens && offset === 0) {
+        siblings.splice(index, 0, { type: "text", value: ZERO_WIDTH_SPACE });
+    }
+}
+/**
+ * org→md: drops the line-start zero-width spaces `escapeLineSyntax`
+ * inserts.
+ */
+export function unescapeLineSyntax(tree) {
+    rewriteLines(tree, (children, context) => {
+        const { starts } = lineStarts(children, context);
+        for (const { segment, offset } of starts.reverse()) {
+            const { node } = segment;
+            const value = node.value ?? "";
+            if (node.type === "text" && value[offset] === ZERO_WIDTH_SPACE) {
+                node.value = value.slice(0, offset) + value.slice(offset + 1);
+            }
+        }
+    }, holdsZeroWidthSpace);
+}
+function holdsZeroWidthSpace(children) {
+    return children.some(child => "children" in child
+        ? holdsZeroWidthSpace(child.children)
+        : child.type === "text" && child.value?.includes(ZERO_WIDTH_SPACE));
+}

package/dist/core/markupBoundary.d.ts

@@ -0,0 +1,12 @@
+import type { Parent } from "unist";
+export declare const ZERO_WIDTH_SPACE = "\u200B";
+/**
+ * md→org: escapes with zero-width spaces what org would otherwise misread:
+ * literal markers in text that form markup (`/etc/`), and markup whose
+ * neighbor is no valid boundary (`a~x~s`), which would stay literal.
+ */
+export declare function escapeOrgMarkup(tree: Parent): void;
+/**
+ * org→md: drops the zero-width spaces `escapeOrgMarkup` inserts.
+ */
+export declare function unescapeOrgMarkup(tree: Parent): void;

package/dist/core/markupBoundary.js

@@ -0,0 +1,195 @@
+import { SKIP, visit } from "unist-util-visit";
+import { locate, positionParser, renderChildren, tryParse } from "./render.js";
+// the org manual's escape character: a zero-width space is a valid
+// markup boundary (uniorg lists it in its emphasis regexp components)
+// but renders as nothing
+export const ZERO_WIDTH_SPACE = "\u200B";
+const MARKUP_TYPES = new Set([
+    "bold",
+    "italic",
+    "underline",
+    "strike-through",
+    "code",
+    "verbatim"
+]);
+// characters org accepts directly before an opening / after a closing
+// marker (uniorg's emphasisRegexpComponents pre / post)
+const PRE_RE = /[-–—\s\u200B('’"“”{]$/;
+const POST_RE = /^[-–—\s\u200B.,:!?;'’"“”)}[]/;
+function isMarkup(node) {
+    return MARKUP_TYPES.has(node?.type ?? "");
+}
+function allowsMarkupAfter(node) {
+    if (!node) {
+        return true;
+    }
+    if (node.type === "text") {
+        return !node.value || PRE_RE.test(node.value);
+    }
+    return false;
+}
+function allowsMarkupBefore(node) {
+    if (!node) {
+        return true;
+    }
+    if (node.type === "text") {
+        return !node.value || POST_RE.test(node.value);
+    }
+    // a link opens with `[`
+    return node.type === "link";
+}
+/**
+ * md→org: escapes with zero-width spaces what org would otherwise misread:
+ * literal markers in text that form markup (`/etc/`), and markup whose
+ * neighbor is no valid boundary (`a~x~s`), which would stay literal.
+ */
+export function escapeOrgMarkup(tree) {
+    // the separators are valid markup boundaries, so literal markers are
+    // checked next to them
+    separateMarkupBoundaries(tree);
+    defuseLiteralMarkers(tree);
+}
+/**
+ * org→md: drops the zero-width spaces `escapeOrgMarkup` inserts.
+ */
+export function unescapeOrgMarkup(tree) {
+    dropMarkupBoundaries(tree);
+    visit(tree, "text", (node) => {
+        node.value = node.value?.replace(DEFUSED_MARKER_RE, "$1");
+    });
+}
+const MARKER_RE = /[*/_=~+]/;
+const MARKERS_RE = new RegExp(MARKER_RE.source, "g");
+// org's emphasis rule, loosened, from an opening marker on: a non-blank
+// after it, the same marker closing after a non-blank, then an allowed
+// char, a table cell border or the end (the char before the marker is
+// checked apart)
+const MAY_OPEN_MARKUP_RE = /([*/_=~+])[^\s\u200B](?:[\s\S]*?[^\s\u200B])?\1(?:$|[-–—\s\u200B.,:!?;'’"“”)}[|])/y;
+const DEFUSED_MARKER_RE = /([*/_=~+])\u200B/g;
+// offsets of the opening markers of the outermost markup org reads in
+// `text`; none where uniorg fails to read it
+function markupOffsets(text) {
+    const tree = tryParse(text, positionParser);
+    if (!tree) {
+        return [];
+    }
+    const offsets = [];
+    visit(tree, (node) => {
+        if (!isMarkup(node)) {
+            return undefined;
+        }
+        const offset = node.position?.start.offset;
+        if (offset !== undefined) {
+            offsets.push(offset);
+        }
+        return SKIP;
+    });
+    return offsets;
+}
+function holdsMarker(node) {
+    return node.type === "text" && MARKER_RE.test(node.value ?? "");
+}
+// [child index, offset in its rendering] of each opening marker org
+// reads as markup that lies in a text child, i.e. is a literal marker
+function literalMarkers(children, rendered) {
+    return markupOffsets(rendered.join(""))
+        .map(offset => locate(rendered, offset))
+        .filter(([i]) => children[i]?.type === "text");
+}
+// whether a marker in a text child may open markup, by the rule above:
+// a marker another node renders (bold's `*`) needs no escape, so
+// neither it nor a marker org cannot read as markup takes a parse
+function mayHoldLiteralMarkup(children, rendered) {
+    const line = rendered.join("");
+    let start = 0;
+    return rendered.some((part, i) => {
+        const offset = start;
+        start += part.length;
+        return (children[i]?.type === "text" &&
+            [...part.matchAll(MARKERS_RE)].some(({ index }) => {
+                MAY_OPEN_MARKUP_RE.lastIndex = offset + index;
+                return mayOpenAt(part, index) && MAY_OPEN_MARKUP_RE.test(line);
+            }));
+    });
+}
+// uniorg checks the char before an opening marker (`a/b/` is no
+// markup), unless there is none in the text it parses: a char of another
+// node's rendering counts as none. It reads a marker after one (`#**x*`)
+// by backing off onto the first, which then opens without that check
+function mayOpenAt(text, index) {
+    const before = text[index - 1];
+    return (before === undefined ||
+        PRE_RE.test(before) ||
+        // uniorg opens after a table cell border too, found by fuzzing
+        before === "|" ||
+        MARKER_RE.test(text[index + 1] ?? ""));
+}
+// a zero-width space after an opening marker leaves org nothing to read
+// as markup (content may not start with one). Defusing an outer pair can
+// expose an inner one, hence the rounds; each defuses at least one
+// marker, so there are at most as many rounds as markers
+function defuseRendered(children, rendered) {
+    let rounds = rendered.join("").match(MARKERS_RE)?.length ?? 0;
+    let markers;
+    while (rounds-- > 0 &&
+        mayHoldLiteralMarkup(children, rendered) &&
+        (markers = literalMarkers(children, rendered)).length) {
+        for (const [i, offset] of markers.reverse()) {
+            const part = rendered[i] ?? "";
+            rendered[i] =
+                part.slice(0, offset + 1) + ZERO_WIDTH_SPACE + part.slice(offset + 1);
+        }
+    }
+}
+// checked on the rendered line, not per text node: another inline node
+// may split a literal pair (`*b ~x~ c*`)
+function defuseLiteralMarkers(tree) {
+    visit(tree, (node) => {
+        if (!("children" in node) || !node.children.some(holdsMarker)) {
+            return;
+        }
+        const children = node.children;
+        const rendered = renderChildren(children);
+        defuseRendered(children, rendered);
+        for (const [i, child] of children.entries()) {
+            if (child.type === "text") {
+                child.value = rendered[i];
+            }
+        }
+    });
+}
+function separateMarkupBoundaries(tree) {
+    visit(tree, (node) => {
+        if (!("children" in node) || !node.children.some(isMarkup)) {
+            return;
+        }
+        const children = [];
+        for (const [i, child] of node.children.entries()) {
+            if (isMarkup(child) && !allowsMarkupAfter(children.at(-1))) {
+                children.push({ type: "text", value: ZERO_WIDTH_SPACE });
+            }
+            children.push(child);
+            if (isMarkup(child) && !allowsMarkupBefore(node.children[i + 1])) {
+                children.push({ type: "text", value: ZERO_WIDTH_SPACE });
+            }
+        }
+        node.children = children;
+    });
+}
+function dropMarkupBoundaries(tree) {
+    visit(tree, "text", (node, index, parent) => {
+        if (index === undefined || !parent) {
+            return;
+        }
+        let value = node.value ?? "";
+        if (isMarkup(parent.children[index + 1]) &&
+            value.endsWith(ZERO_WIDTH_SPACE)) {
+            value = value.slice(0, -1);
+        }
+        if (isMarkup(parent.children[index - 1]) &&
+            value.startsWith(ZERO_WIDTH_SPACE)) {
+            value = value.slice(1);
+        }
+        node.value = value;
+    });
+}

package/dist/core/mdastToUniorg/index.js

@@ -78,7 +78,7 @@ export function transformMdastNodeToUniorgNode(ctx, node) {
         case "blockquote":
             return {
                 type: "quote-block",
-                children: transformBlockChildren(ctx, node.children)
+                children: transformBlockChildren(ctx, node.children.map(child => quotedHeadingAsText(ctx, child)))
             };
         case "code":
             return transformMdastCode(node);
@@ -93,3 +93,11 @@ export function transformMdastNodeToUniorgNode(ctx, node) {
             return null;
     }
 }
+// Emacs ends a quote block at a headline; the text stays
+function quotedHeadingAsText(ctx, node) {
+    if (node.type !== "heading") {
+        return node;
+    }
+    warn(ctx, "heading inside a blockquote became text");
+    return { type: "paragraph", children: node.children };
+}

package/dist/core/mdastToUniorg/lists.d.ts

@@ -1,4 +1,4 @@
 import type { List as MdastList } from "mdast";
 import type { List } from "uniorg";
-import type { TransformContext } from "./context.js";
+import { type TransformContext } from "./context.js";
 export declare function transformMdastList(ctx: TransformContext, listNode: MdastList, indent: number): List;