@remigius42/morg 0.5.0 → 0.7.0

package/dist/core/lineSyntax.js

@@ -0,0 +1,221 @@
+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 ?? "");
+}
+/**
+ * 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.
+ * @param node The node.
+ * @param index Its index in its parent.
+ * @param parent Its parent.
+ */
+export function isPassthroughParagraph(node, index, parent) {
+    if (node.type !== "paragraph") {
+        return false;
+    }
+    const context = contextOf(node, index, parent);
+    const children = node.children;
+    return (!context.afterBullet && isPassthrough(lineStarts(children, context).starts));
+}
+// 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/blocks.d.ts

@@ -1,7 +1,6 @@
 import type { RootContent, PhrasingContent } from "mdast";
 import type { ElementType } from "uniorg";
 import { type TransformContext } from "./context.js";
-export declare function frontmatterToKeywords(yamlValue: string): ElementType[];
 export declare function transformMdastTable(ctx: TransformContext, node: Extract<RootContent, {
     type: "table";
 }>): ElementType;

package/dist/core/mdastToUniorg/blocks.js

@@ -1,35 +1,7 @@
 import { toString } from "orgast-util-to-string";
-import { parse as parseYaml } from "yaml";
 import { mdismEnabled } from "./context.js";
 import { transformPhrasingChildren } from "./phrasing.js";
-// a keyword is a single line, so anything that is not a single-line
-// scalar is JSON-encoded and restored by JSON.parse on the way back
-function keywordValue(value) {
-    if (value !== null && typeof value === "object") {
-        return JSON.stringify(value);
-    }
-    const text = String(value);
-    return text.includes("\n") ? JSON.stringify(text) : text;
-}
-// frontmatter entries become #+KEY: value keywords; scalar values as-is,
-// structured values JSON-encoded on a single line (see ADR 0002)
-export function frontmatterToKeywords(yamlValue) {
-    const data = parseYaml(yamlValue);
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
-        return [];
-    }
-    return Object.entries(data).flatMap(([key, value]) => {
-        // a sequence becomes repeated keywords -- org's own way of carrying
-        // several values for one key, and what they read back as
-        const values = Array.isArray(value) && value.length ? value : [value];
-        return values.map(item => ({
-            type: "keyword",
-            affiliated: {},
-            key: key.toUpperCase(),
-            value: keywordValue(item)
-        }));
-    });
-}
+import { KEYWORD_NAME } from "../frontmatterBlock.js";
 export function transformMdastTable(ctx, node) {
     const [headerRow, ...bodyRows] = node.children;
     // GFM column alignment maps to an org alignment cookie row
@@ -196,7 +168,7 @@ export function transformMdastHeading(ctx, node) {
         children: transformPhrasingChildren(ctx, node.children)
     };
 }
-const KEYWORD_LINE_RE = /^#\+\S+: /;
+const KEYWORD_LINE_RE = new RegExp(String.raw `^#\+${KEYWORD_NAME}: `);
 export function keywordOnlyLines(node) {
     if (!node.children.every(child => child.type === "text")) {
         return null;
@@ -204,7 +176,7 @@ export function keywordOnlyLines(node) {
     const lines = node.children
         .map(child => child.value)
         .join("")
-        .split("\n");
+        .split(/\r?\n/);
     return lines.length && lines.every(line => KEYWORD_LINE_RE.test(line))
         ? lines
         : null;

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

@@ -10,4 +10,10 @@ import type { MdastToUniorgOptions } from "./context.js";
  * @returns The transformed uniorg AST.
  */
 export declare function transformMdastToUniorgAst(mdast: MdastRoot, options?: MdastToUniorgOptions): OrgData;
+/**
+ * md→org pipeline: like `transformMdastToUniorgAst`, but the frontmatter
+ * stays a `morg-frontmatter` node a preset can still take entries out
+ * of; `renderFileHeader` turns it into the block.
+ */
+export declare function transformMdastToUniorgDraft(mdast: MdastRoot, options?: MdastToUniorgOptions): OrgData;
 export declare function transformMdastNodeToUniorgNode(ctx: TransformContext, node: RootContent | PhrasingContent): GreaterElementType | ElementType | Text | null;

package/dist/core/mdastToUniorg/index.js

@@ -1,6 +1,7 @@
 import { visit } from "unist-util-visit";
 import { warn } from "./context.js";
-import { frontmatterToKeywords, keywordOnlyLines, transformMdastCode, transformMdastHeading, transformMdastHtml, transformMdastMath, transformMdastTable } from "./blocks.js";
+import { fitsKeywordLine, fitsPropertyLine, markModeLine, renderFileHeader, takeMorgEntry, takesMorgEntries } from "../frontmatterBlock.js";
+import { keywordOnlyLines, transformMdastCode, transformMdastHeading, transformMdastHtml, transformMdastMath, transformMdastTable } from "./blocks.js";
 import { transformMdastList } from "./lists.js";
 import { transformPhrasingChildren } from "./phrasing.js";
 /**
@@ -10,6 +11,16 @@ import { transformPhrasingChildren } from "./phrasing.js";
  * @returns The transformed uniorg AST.
  */
 export function transformMdastToUniorgAst(mdast, options = {}) {
+    const orgAst = transformMdastToUniorgDraft(mdast, options);
+    renderFileHeader(orgAst);
+    return orgAst;
+}
+/**
+ * md→org pipeline: like `transformMdastToUniorgAst`, but the frontmatter
+ * stays a `morg-frontmatter` node a preset can still take entries out
+ * of; `renderFileHeader` turns it into the block.
+ */
+export function transformMdastToUniorgDraft(mdast, options = {}) {
     const ctx = { options, definitions: new Map() };
     visit(mdast, "definition", (definition) => {
         ctx.definitions.set(definition.identifier, {
@@ -17,13 +28,20 @@ export function transformMdastToUniorgAst(mdast, options = {}) {
             ...(definition.title != null && { title: definition.title })
         });
     });
+    const firstBody = mdast.children.find(child => child.type !== "yaml");
     const children = mdast.children
-        .flatMap(child => 
-    // frontmatter maps to org keywords, a native construct (one mdast
-    // node fans out to one keyword per entry)
-    child.type === "yaml"
-        ? frontmatterToKeywords(child.value)
-        : [transformMdastNodeToUniorgNode(ctx, child)])
+        .flatMap(child => {
+        // frontmatter is passive data, org keywords can act; it travels
+        // inert in a marked comment block (ADR 0005)
+        if (child.type === "yaml") {
+            return transformFrontmatter(child.value);
+        }
+        const node = transformMdastNodeToUniorgNode(ctx, child);
+        if (child === firstBody) {
+            markModeLine(node);
+        }
+        return [node];
+    })
         .filter(Boolean);
     const orgAst = {
         type: "org-data",
@@ -78,7 +96,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 +111,58 @@ 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 };
+}
+// morg's own entries, both or neither: one left in the YAML would keep
+// the other from joining it again on the way back
+function takeMorgEntries(yaml) {
+    // most frontmatter holds neither: no need to parse it
+    if (!yaml.includes("morg_")) {
+        return { keywords: [], properties: [], yaml };
+    }
+    const taken = takeMorgEntry(yaml, "morg_keywords", fitsKeywordLine);
+    const rest = takeMorgEntry(taken.yaml, "morg_properties", fitsPropertyLine);
+    return takesMorgEntries(rest.yaml)
+        ? { keywords: taken.keywords, properties: rest.keywords, yaml: rest.yaml }
+        : { keywords: [], properties: [], yaml };
+}
+function keywordNodes(keywords) {
+    return keywords.map(([key, value]) => ({
+        type: "keyword",
+        affiliated: {},
+        key,
+        value
+    }));
+}
+// org's own keywords go back to keywords; the rest of the frontmatter
+// stays inert data in the block
+function transformFrontmatter(value) {
+    // in the org file's line endings, which are LF
+    const lf = value.replaceAll("\r\n", "\n");
+    const { keywords, properties, yaml } = takeMorgEntries(lf);
+    const drawer = properties.length
+        ? [
+            {
+                type: "property-drawer",
+                children: properties.map(([key, propertyValue]) => ({
+                    type: "node-property",
+                    key,
+                    value: propertyValue
+                }))
+            }
+        ]
+        : [];
+    const nodes = keywordNodes(keywords);
+    // an empty frontmatter stays a block
+    if (yaml || !(keywords.length || properties.length)) {
+        const node = { type: "morg-frontmatter", yaml };
+        nodes.push(node);
+    }
+    return [...drawer, ...nodes];
+}

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;

package/dist/core/mdastToUniorg/lists.js

@@ -1,3 +1,4 @@
+import { warn } from "./context.js";
 import { transformPhrasingChildren } from "./phrasing.js";
 // circular import with index.js is fine in ESM: both sides only export
 // hoisted function declarations called after module initialization
@@ -17,19 +18,37 @@ export function transformMdastList(ctx, listNode, indent) {
         contentsEnd: 0
     };
 }
+// uniorg-stringify re-indents a list item's block by stripping up to
+// the item's indentation from each line first: a code block's value
+// has to carry that indentation (as uniorg's parser reads it), or its
+// own indentation shrinks
+function indentCode(node, level) {
+    const block = node;
+    if ((block?.type === "src-block" || block?.type === "example-block") &&
+        block.value !== undefined) {
+        block.value = block.value.replace(/^(?=.)/gm, " ".repeat(level));
+    }
+    return node;
+}
 function transformMdastListItem(ctx, item, indent, bullet) {
     const children = item.children
         .flatMap((child) => {
         if (child.type === "list") {
             return [transformMdastList(ctx, child, indent + bullet.length)];
         }
-        if (child.type === "paragraph") {
+        if (child.type === "heading") {
+            // org headlines cannot live inside a list item; the text stays
+            warn(ctx, "heading inside a list item became text");
+        }
+        if (child.type === "paragraph" || child.type === "heading") {
             return [
                 ...transformPhrasingChildren(ctx, child.children),
                 { type: "text", value: "\n" }
             ];
         }
-        return [transformMdastNodeToUniorgNode(ctx, child)];
+        return [
+            indentCode(transformMdastNodeToUniorgNode(ctx, child), indent + bullet.length)
+        ];
     })
         .filter(Boolean);
     return {