@remigius42/morg 0.4.0 → 0.6.0

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 {

package/dist/core/mdastToUniorg/phrasing.js

@@ -1,4 +1,7 @@
 import { mdismEnabled, warn } from "./context.js";
+import { visit } from "unist-util-visit";
+import { escapeOrgPath } from "../orgPath.js";
+import { orgParser, renderInline } from "../render.js";
 // html tags morg itself emits under useHtml; with interpretHtml a bare
 // open/close pair becomes the corresponding native org object
 const INLINE_HTML_ORG_TYPES = {
@@ -30,20 +33,87 @@ export function transformPhrasingChildren(ctx, children) {
             ? matchInlineHtmlPair(children, i)
             : null;
         if (pair) {
-            result.push({
+            result.push(...hoistEdgeWhitespace(joinLines({
                 type: pair.orgType,
                 children: transformPhrasingChildren(ctx, children.slice(i + 1, pair.end))
-            });
+            })));
             i = pair.end;
             continue;
         }
+        if (node.type === "inlineCode") {
+            result.push(...transformMdastInlineCode(ctx, node.value));
+            continue;
+        }
         const transformed = transformMdastPhrasingContentToUniorgObject(ctx, node);
         if (transformed) {
-            result.push(transformed);
+            result.push(...hoistEdgeWhitespace(joinLines(transformed)));
         }
     }
     return result;
 }
+const CONTAINER_MARKUP = new Set([
+    "bold",
+    "italic",
+    "strike-through",
+    "underline"
+]);
+// org markup spans at most two lines; beyond that its line endings
+// become spaces, as CommonMark renders them anyway (see
+// transformMdastInlineCode)
+function joinLines(node) {
+    if (!CONTAINER_MARKUP.has(node.type)) {
+        return node;
+    }
+    const texts = [];
+    visit(node, "text", (text) => {
+        texts.push(text);
+    });
+    const lineEndings = texts
+        .map(text => text.value)
+        .join("")
+        .split("\n").length - 1;
+    if (lineEndings > 1) {
+        for (const text of texts) {
+            text.value = text.value.replaceAll("\n", " ");
+        }
+    }
+    return node;
+}
+// strips the whitespace at the edges of `children`, returning it
+function takeEdgeWhitespace(children) {
+    const first = children[0];
+    const last = children.at(-1);
+    let before = "";
+    let after = "";
+    if (first?.type === "text") {
+        before = /^\s*/.exec(first.value)?.[0] ?? "";
+        first.value = first.value.slice(before.length);
+    }
+    if (last?.type === "text") {
+        after = /\s*$/.exec(last.value)?.[0] ?? "";
+        last.value = last.value.slice(0, last.value.length - after.length);
+    }
+    return { before, after };
+}
+// org markup may not start or end with whitespace, which a code span's
+// moved-out edge whitespace (see transformMdastInlineCode) can leave
+// inside it; it moves out further, to the markup's siblings
+function hoistEdgeWhitespace(node) {
+    if (!CONTAINER_MARKUP.has(node.type) || !("children" in node)) {
+        return [node];
+    }
+    const { before, after } = takeEdgeWhitespace(node.children);
+    if (!before && !after) {
+        return [node];
+    }
+    const content = node.children.filter(child => child.type !== "text" || child.value !== "");
+    const text = (value) => value ? [{ type: "text", value }] : [];
+    return [
+        ...text(before),
+        ...(content.length ? [{ ...node, children: content }] : []),
+        ...text(after)
+    ];
+}
 // an org bracket-link path cannot contain [ or ]; percent-encoding keeps
 // the url equivalent and, unlike org's backslash escaping, survives being
 // parsed back (uniorg does not decode `\[`). A silent normalization, not
@@ -51,6 +121,36 @@ export function transformPhrasingChildren(ctx, children) {
 function orgSafeUrl(url) {
     return url.replaceAll("[", "%5B").replaceAll("]", "%5D");
 }
+// a url without a scheme is a relative path in markdown, but a bare org
+// path is a fuzzy link (a heading search); org's file: type keeps it a
+// file. A #anchor becomes org's search option, which finds a
+// <<target>> or a headline of that name. `[[page]]` / `((uuid))` urls
+// are dialect references (logseq), not paths
+const SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+function isRelativePath(url) {
+    return url !== "" && !SCHEME_RE.test(url) && !/^(#|\/\/|\[|\()/.test(url);
+}
+// md urls are percent-encoded, org paths are not; a malformed escape
+// stays as written
+function decodeUrlPart(part) {
+    try {
+        return decodeURIComponent(part);
+    }
+    catch {
+        return part;
+    }
+}
+function orgLinkTarget(url) {
+    if (!isRelativePath(url)) {
+        return { rawLink: orgSafeUrl(url), linkType: "url" };
+    }
+    const hash = url.indexOf("#");
+    const path = escapeOrgPath(decodeUrlPart(hash === -1 ? url : url.slice(0, hash)));
+    const search = hash === -1
+        ? ""
+        : `::${escapeOrgPath(decodeUrlPart(url.slice(hash + 1)), true)}`;
+    return { rawLink: `file:${path}${search}`, linkType: "file" };
+}
 function transformMdastLink(ctx, linkNode) {
     const [only] = linkNode.children;
     // text equal to the url (autolinks) is no description; a plain
@@ -61,13 +161,13 @@ function transformMdastLink(ctx, linkNode) {
         ? []
         : transformPhrasingChildren(ctx, linkNode.children);
     // rawLink should just be the URL, uniorg-stringify adds the brackets
-    const url = orgSafeUrl(linkNode.url);
+    const { rawLink, linkType } = orgLinkTarget(linkNode.url);
     return {
         type: "link",
         format: "bracket", // Assuming bracket format for Markdown links
-        linkType: "url",
-        rawLink: url,
-        path: url,
+        linkType,
+        rawLink,
+        path: rawLink,
         children: linkChildren
     };
 }
@@ -101,16 +201,51 @@ function transformMdastImage(ctx, node) {
     if (node.title) {
         warn(ctx, `dropped image title "${node.title}" (${node.url})`);
     }
-    const url = orgSafeUrl(node.url);
+    const { rawLink } = orgLinkTarget(node.url);
     return {
         type: "link",
         format: "bracket",
         linkType: "file",
-        rawLink: url,
-        path: url,
+        rawLink,
+        path: rawLink,
         children: node.alt ? [{ type: "text", value: node.alt }] : []
     };
 }
+// org markup spans at most two lines; CommonMark renders a line ending
+// inside a code span as a space, so nothing is lost. Org markup may not
+// start or end with whitespace either: edge whitespace moves outside
+// the markers, a one-space shift in the rendered output
+function transformMdastInlineCode(ctx, value) {
+    const [, before = "", code = "", after = ""] = /^(\s*)(.*?)(\s*)$/s.exec(value.replace(/\r\n?|\n/g, " ")) ?? [];
+    if (!code) {
+        // org has no empty code markup
+        warn(ctx, "whitespace-only inline code kept as text");
+        return [{ type: "text", value: before }];
+    }
+    const type = codeType(code);
+    if (!type) {
+        warn(ctx, "inline code holding both ~ and = kept as text");
+        return [{ type: "text", value: before + code + after }];
+    }
+    return [
+        ...(before ? [{ type: "text", value: before }] : []),
+        { type, value: code },
+        ...(after ? [{ type: "text", value: after }] : [])
+    ];
+}
+// org ends code at the first `~` it may close on (`~a~ b~`); verbatim
+// keeps such code whole, and comes back as md code too, unless a `=`
+// ends it early in turn
+function codeType(code) {
+    return ["code", "verbatim"].find(type => !code.includes(type === "code" ? "~" : "=") ||
+        readsWhole({ type, value: code }));
+}
+// whether org reads `node`, rendered, back as the same node
+function readsWhole(node) {
+    const [paragraph] = orgParser.parse(renderInline(node)).children;
+    const [first, ...rest] = paragraph && "children" in paragraph ? paragraph.children : [];
+    return !rest.length && first?.type === node.type && first.value === node.value;
+}
 function transformMdastInlineMath(node) {
     const value = node.value;
     return {
@@ -144,8 +279,6 @@ function transformMdastPhrasingContentToUniorgObject(ctx, node) {
             return transformMdastLinkReference(ctx, node);
         case "imageReference":
             return transformMdastImageReference(ctx, node);
-        case "inlineCode":
-            return { type: "code", value: node.value };
         case "inlineMath":
             return transformMdastInlineMath(node);
         case "break":

package/dist/core/orgPath.d.ts

@@ -0,0 +1,9 @@
+/**
+ * md→org: a decoded file link path, or its search option, as org link
+ * text.
+ */
+export declare function escapeOrgPath(part: string, isSearch?: boolean): string;
+/**
+ * org→md: the inverse of `escapeOrgPath`.
+ */
+export declare function unescapeOrgPath(part: string): string;

package/dist/core/orgPath.js

@@ -0,0 +1,24 @@
+// an org bracket-link path cannot contain [ or ], and `::` starts its
+// search option. morg percent-encodes those (uniorg does not decode org's
+// own backslash escaping); a literal % in front of such an escape gets
+// one more `25`, so the encoding stays reversible (`%5B` ↔ `%255B`)
+const ESCAPE_RE = /%((?:25)*)(5B|5D|3A)/g;
+const ESCAPED = { "5B": "[", "5D": "]", "3A": ":" };
+/**
+ * md→org: a decoded file link path, or its search option, as org link
+ * text.
+ */
+export function escapeOrgPath(part, isSearch = false) {
+    const escaped = part
+        .replace(ESCAPE_RE, "%25$1$2")
+        .replaceAll("[", "%5B")
+        .replaceAll("]", "%5D");
+    // a colon next to another, or before the `::` separator
+    return isSearch ? escaped : escaped.replace(/:(?=:|$)/g, "%3A");
+}
+/**
+ * org→md: the inverse of `escapeOrgPath`.
+ */
+export function unescapeOrgPath(part) {
+    return part.replace(ESCAPE_RE, (_, more, code) => more ? `%${more.slice(2)}${code}` : (ESCAPED[code] ?? code));
+}

package/dist/core/render.d.ts

@@ -0,0 +1,33 @@
+import type { Parent } from "unist";
+export type Node = Parent["children"][number] & {
+    value?: string;
+};
+export declare const orgParser: import("unified").Processor<import("uniorg").OrgData, undefined, undefined, undefined, undefined>;
+export declare const positionParser: import("unified").Processor<import("uniorg").OrgData, undefined, undefined, undefined, undefined>;
+/**
+ * Parses `text` as an org document, or returns undefined where uniorg
+ * throws: it takes a line starting `_.` or `_)` for a bullet, then
+ * fails to read it (org has no such bullet; see underscoreBullets).
+ */
+export declare function tryParse(text: string, parser?: {
+    parse(text: string): unknown;
+}): Parent | undefined;
+export declare function isInline(node: Node | Parent): boolean;
+/**
+ * How org renders an inline node within its line.
+ */
+export declare function renderInline(node: Node): string;
+/**
+ * An inline node's delimiters around its children, as org renders them
+ * (`*` and `*`, `[[url][` and `]]`).
+ */
+export declare function delimiters(node: Node): [string, string];
+/**
+ * The org rendering of each child; a block element only ends a line.
+ */
+export declare function renderChildren(children: Node[]): string[];
+/**
+ * The index of the rendered child `offset` (into the joined rendering)
+ * lies in, and the offset within that child.
+ */
+export declare function locate(rendered: string[], offset: number): [number, number];

package/dist/core/render.js

@@ -0,0 +1,101 @@
+import { unified } from "unified";
+import uniorgParse from "uniorg-parse";
+import { uniorgStringify } from "uniorg-stringify";
+// built once: constructing a processor per parse dominates the cost
+export const orgParser = unified().use(uniorgParse).freeze();
+export const positionParser = unified()
+    .use(uniorgParse, { trackPosition: true })
+    .freeze();
+const stringifier = unified().use(uniorgStringify).freeze();
+/**
+ * Parses `text` as an org document, or returns undefined where uniorg
+ * throws: it takes a line starting `_.` or `_)` for a bullet, then
+ * fails to read it (org has no such bullet; see underscoreBullets).
+ */
+export function tryParse(text, parser = orgParser) {
+    try {
+        return parser.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+// uniorg's inline node types; anything else is a block element (in a
+// list item's flattened content: a nested list or code block)
+const INLINE_TYPES = new Set([
+    "text",
+    "bold",
+    "italic",
+    "underline",
+    "strike-through",
+    "code",
+    "verbatim",
+    "link",
+    "footnote-reference",
+    "latex-fragment",
+    "entity",
+    "timestamp",
+    "subscript",
+    "superscript",
+    "export-snippet",
+    "statistics-cookie",
+    "citation",
+    "line-break"
+]);
+export function isInline(node) {
+    return INLINE_TYPES.has(node.type);
+}
+// ends the rendering, so the paragraph's own trailing newline and
+// whitespace trimming stay out of it
+const SENTINEL = "\u0000";
+/**
+ * How org renders an inline node within its line.
+ */
+export function renderInline(node) {
+    if (node.type === "text") {
+        return node.value ?? "";
+    }
+    const rendered = String(stringifier.stringify({
+        type: "org-data",
+        children: [
+            {
+                type: "paragraph",
+                children: [node, { type: "text", value: SENTINEL }]
+            }
+        ]
+    }));
+    return rendered.slice(0, rendered.lastIndexOf(SENTINEL));
+}
+// stands in for an inline node's content
+const CONTENT = "\u0001";
+/**
+ * An inline node's delimiters around its children, as org renders them
+ * (`*` and `*`, `[[url][` and `]]`).
+ */
+export function delimiters(node) {
+    const [open = "", close = ""] = renderInline({
+        ...node,
+        children: [{ type: "text", value: CONTENT }]
+    }).split(CONTENT);
+    return [open, close];
+}
+/**
+ * The org rendering of each child; a block element only ends a line.
+ */
+export function renderChildren(children) {
+    return children.map(child => (isInline(child) ? renderInline(child) : "\n"));
+}
+/**
+ * The index of the rendered child `offset` (into the joined rendering)
+ * lies in, and the offset within that child.
+ */
+export function locate(rendered, offset) {
+    let start = 0;
+    for (const [index, part] of rendered.entries()) {
+        if (offset < start + part.length) {
+            return [index, offset - start];
+        }
+        start += part.length;
+    }
+    return [-1, 0];
+}

package/dist/core/tablePipes.d.ts

@@ -0,0 +1,8 @@
+import type { Parent } from "unist";
+/**
+ * md→org: a `|` in a table cell's text (md `\|`) would end the cell; org
+ * has no escaped `|`, but renders the `\vert` entity as one, `{}` ending
+ * its name before any letter. Runs after the preset, whose wikilink
+ * aliases (`[[Page|alias]]`) are no text.
+ */
+export declare function escapeTablePipes(tree: Parent): void;

package/dist/core/tablePipes.js

@@ -0,0 +1,14 @@
+import { visit } from "unist-util-visit";
+/**
+ * md→org: a `|` in a table cell's text (md `\|`) would end the cell; org
+ * has no escaped `|`, but renders the `\vert` entity as one, `{}` ending
+ * its name before any letter. Runs after the preset, whose wikilink
+ * aliases (`[[Page|alias]]`) are no text.
+ */
+export function escapeTablePipes(tree) {
+    visit(tree, "table-cell", (cell) => {
+        visit(cell, "text", (node) => {
+            node.value = node.value?.replaceAll("|", "\\vert{}");
+        });
+    });
+}

package/dist/core/underscoreBullets.d.ts

@@ -0,0 +1,10 @@
+import type { Parent } from "unist";
+/**
+ * org→md: guards the lines uniorg misreads before parsing.
+ */
+export declare function guardUnderscoreBullets(org: string): string;
+/**
+ * org→md: drops the guards again, also where uniorg reads no text (a
+ * src block's code). A zero-width space the author put there goes too.
+ */
+export declare function dropUnderscoreBulletGuards(tree: Parent): void;

package/dist/core/underscoreBullets.js

@@ -0,0 +1,32 @@
+import { visit } from "unist-util-visit";
+import { ZERO_WIDTH_SPACE } from "./markupBoundary.js";
+// ====================================================================
+// WORKAROUND for a bug in uniorg-parse 3.2.2 (upstream issue: not filed
+// yet, see TODO.md). Drop this module once a fixed version is in; the
+// canary in tests/uniorgWorkarounds.spec.ts fails then.
+// ====================================================================
+// Its `listItemRe` takes a line starting `_.` or `_)` for a list item
+// (`\w` includes `_`), but its `fullListItemRe`, like org itself, has
+// no such bullet. `parseListStructure` then throws (`match error`), or,
+// when a real bullet line follows, reads that one instead and silently
+// drops the line. Org reads the line as text, and so does uniorg with a
+// zero-width space in front (morg's line-start escape, see lineSyntax)
+const UNDERSCORE_BULLET_RE = /^([ \t]*)(?=_[.)](?:[ \t]|$))/gm;
+/**
+ * org→md: guards the lines uniorg misreads before parsing.
+ */
+export function guardUnderscoreBullets(org) {
+    return org.replace(UNDERSCORE_BULLET_RE, `$1${ZERO_WIDTH_SPACE}`);
+}
+const GUARD_RE = new RegExp(`(^|\\n)([ \\t]*)${ZERO_WIDTH_SPACE}(?=_[.)](?:[ \\t\\n]|$))`, "g");
+/**
+ * org→md: drops the guards again, also where uniorg reads no text (a
+ * src block's code). A zero-width space the author put there goes too.
+ */
+export function dropUnderscoreBulletGuards(tree) {
+    visit(tree, (node) => {
+        if (typeof node.value === "string") {
+            node.value = node.value.replace(GUARD_RE, "$1$2");
+        }
+    });
+}

package/dist/core/uniorgToMdast/elements.js

@@ -191,7 +191,7 @@ function transformParagraph(ctx, node) {
     const children = transformUniorgObjects(ctx, node.children);
     // md gives leading whitespace structural meaning (list
     // continuation, code); collapse per-line indentation inside
-    // paragraphs — insignificant in org and in rendered md alike
+    // paragraphs, insignificant in org and in rendered md alike
     children.forEach((child, index) => {
         if (child.type === "text") {
             child.value = child.value.replace(/\n[ \t]+/g, "\n");

package/dist/core/uniorgToMdast/lists.js

@@ -67,11 +67,22 @@ function transformUniorgList(ctx, node) {
         };
     });
 }
+// uniorg keeps a list item's indentation in its code blocks' values;
+// md indents them itself. Only that much is dropped, as uniorg-stringify
+// does, so the code keeps its own
+function outdent(value, level) {
+    return value.replace(new RegExp(`^ {0,${level}}`, "gm"), "");
+}
 function transformUniorgListItem(ctx, item) {
     // md has no descriptive lists, so keep the ` :: ` syntax literally in the
-    // item text — the return trip re-parses it as a descriptive list
+    // item text; the return trip re-parses it as a descriptive list
     const tag = listItemTag(item);
     const children = transformNodes(ctx, (item.children || []).filter(child => child !== tag));
+    for (const child of children) {
+        if (child.type === "code") {
+            child.value = outdent(child.value, item.indent + item.bullet.length);
+        }
+    }
     if (tag) {
         const term = {
             type: "text",

package/dist/core/uniorgToMdast/objects.js

@@ -1,6 +1,7 @@
 import { toString as orgastToString } from "orgast-util-to-string";
 import { htmlEnabled, orgNodeToText, warn } from "./shared.js";
 import { transformFootnoteReference } from "./footnotes.js";
+import { unescapeOrgPath } from "../orgPath.js";
 const IMAGE_EXTENSION_RE = /\.(png|jpe?g|gif|svg|webp|avif|bmp|ico)$/i;
 export function transformUniorgObjects(ctx, children) {
     return (children || [])
@@ -74,12 +75,43 @@ function transformUniorgObjectToMdastPhrasingContent(ctx, node) {
             return null;
     }
 }
+// the inverse of md→org's decoding: % and # would be read as an escape
+// or the anchor, and a markdown url cannot hold a bare space. Org path
+// escapes (`[`, `]`, `:`) are undone first rather than escaped twice
+function encodeUrlPart(part) {
+    return unescapeOrgPath(part)
+        .replaceAll("%", "%25")
+        .replaceAll("#", "%23")
+        .replaceAll(" ", "%20");
+}
+// a path starting like `a:` would read as a url scheme in markdown
+function encodeUrlPath(path) {
+    const encoded = encodeUrlPart(path);
+    return /^[a-z][a-z0-9+.-]*:/i.test(encoded)
+        ? encoded.replaceAll(":", "%3A")
+        : encoded;
+}
+// an org file: link (or a ./ path) is a relative markdown link, the
+// search option becoming the #anchor
+function markdownUrl(node) {
+    if (node.linkType !== "file") {
+        return node.rawLink;
+    }
+    const target = node.rawLink.replace(/^file:/, "");
+    const search = target.indexOf("::");
+    return search === -1
+        ? encodeUrlPath(target)
+        : `${encodeUrlPath(target.slice(0, search))}#${encodeUrlPart(target.slice(search + 2))}`;
+}
 function transformUniorgLink(ctx, node) {
     const descriptionText = orgastToString(node);
+    const url = markdownUrl(node);
     // org has no dedicated image syntax; the common convention is a
-    // link to an image file, so map those to markdown images
-    if (IMAGE_EXTENSION_RE.test(node.rawLink)) {
-        return { type: "image", url: node.rawLink, alt: descriptionText };
+    // link to an image file, so map those to markdown images; a file
+    // link's ::search option is no part of the file name
+    const path = node.linkType === "file" ? node.rawLink.replace(/::.*$/s, "") : node.rawLink;
+    if (IMAGE_EXTENSION_RE.test(path)) {
+        return { type: "image", url, alt: descriptionText };
     }
     // a description equal to the url (a common Logseq pattern) is no
     // description: text === url makes remark-stringify emit an
@@ -100,8 +132,8 @@ function transformUniorgLink(ctx, node) {
         withoutMarkers(serializedDescription) === withoutMarkers(node.rawLink)) {
         return {
             type: "link",
-            url: node.rawLink,
-            children: [{ type: "text", value: node.rawLink }]
+            url,
+            children: [{ type: "text", value: url }]
         };
     }
     const children = transformUniorgObjects(ctx, node.children);
@@ -110,7 +142,7 @@ function transformUniorgLink(ctx, node) {
     const flattened = children.some(child => child.type === "link" || child.type === "image")
         ? [{ type: "text", value: descriptionText }]
         : children;
-    return { type: "link", url: node.rawLink, children: flattened };
+    return { type: "link", url, children: flattened };
 }
 function transformScriptMarkup(ctx, node) {
     // markdown has no equivalents; with useHtml render as raw html

package/dist/core/uniorgToMdast/tables.js

@@ -16,12 +16,18 @@ function isAlignmentCookieRow(row) {
         cells.some(cell => cellText(cell) !== ""));
 }
 // org cell content keeps the aligning whitespace padding; markdown
-// cells are re-padded by the stringifier
-function trimCellPadding(node) {
-    if (node.type === "text") {
-        node.value = node.value.trim();
+// cells are re-padded by the stringifier. Only the cell's edges are
+// padding: a space between text and markup is content
+function trimCellPadding(children) {
+    const first = children[0];
+    if (first?.type === "text") {
+        first.value = first.value.trimStart();
     }
-    return node;
+    const last = children.at(-1);
+    if (last?.type === "text") {
+        last.value = last.value.trimEnd();
+    }
+    return children;
 }
 export function transformTable(ctx, node) {
     if (node.tableType === "table.el") {
@@ -59,7 +65,7 @@ export function transformTable(ctx, node) {
             type: "tableRow",
             children: (row.children || []).map(cell => ({
                 type: "tableCell",
-                children: transformUniorgObjects(ctx, cell.children).map(trimCellPadding)
+                children: trimCellPadding(transformUniorgObjects(ctx, cell.children))
             }))
         }))
     };

package/dist/fileNames.d.ts

@@ -1,7 +1,7 @@
 /**
  * Splits a file name into the part a derived name keeps and the extension
  * that carries its format. A dotless name and a dotfile both have no
- * extension — `org` is a file called org, and `.org` is a hidden file whose
+ * extension: `org` is a file called org, and `.org` is a hidden file whose
  * name happens to start with a dot.
  *
  * The extension comes from the last path segment, since the CLI is handed

package/dist/fileNames.js

@@ -6,7 +6,7 @@ const DOCUMENT_FORMATS = new Map([
 /**
  * Splits a file name into the part a derived name keeps and the extension
  * that carries its format. A dotless name and a dotfile both have no
- * extension — `org` is a file called org, and `.org` is a hidden file whose
+ * extension: `org` is a file called org, and `.org` is a hidden file whose
  * name happens to start with a dot.
  *
  * The extension comes from the last path segment, since the CLI is handed