@remigius42/morg 0.4.0

package/dist/core/uniorgToMdast/lists.js

@@ -0,0 +1,94 @@
+import { toString as orgastToString } from "orgast-util-to-string";
+import { htmlEnabled } from "./shared.js";
+import { transformNodes } from "./elements.js";
+export function transformPlainList(ctx, node) {
+    if (node.listType === "descriptive" && htmlEnabled(ctx, "descriptiveList")) {
+        return descriptiveListToHtml(node);
+    }
+    return transformUniorgList(ctx, node);
+}
+// a descriptive list item starts with a list-item-tag (the term)
+function listItemTag(item) {
+    return (item.children || []).find(child => child.type === "list-item-tag");
+}
+// `&`, `<` and `>` in the text would otherwise produce invalid html that
+// interpretDefinitionList cannot read back; decoded again on that side
+function escapeHtmlText(text) {
+    return text
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+// with useHtml a descriptive list renders as a <dl> block (a preserved
+// md-ism on the return trip); terms and definitions are flattened to text
+function descriptiveListToHtml(node) {
+    const lines = ["<dl>"];
+    for (const item of node.children || []) {
+        if (item.type !== "list-item") {
+            continue;
+        }
+        const tag = listItemTag(item);
+        const definition = (item.children || []).filter(child => child !== tag);
+        lines.push(`<dt>${escapeHtmlText(tag ? orgastToString(tag).trim() : "")}</dt>`);
+        lines.push(`<dd>${escapeHtmlText(definition
+            .map(child => orgastToString(child))
+            .join("")
+            .trim())}</dd>`);
+    }
+    lines.push("</dl>");
+    return { type: "html", value: lines.join("\n") };
+}
+// A single blank line does not end a list in org, so one uniorg plain-list
+// can mix ordered and unordered bullets. Markdown cannot: split the items
+// into runs by bullet kind, one mdast list per run.
+function transformUniorgList(ctx, node) {
+    const items = (node.children || []).filter((child) => child.type === "list-item");
+    const runs = [];
+    let previousOrdered;
+    for (const item of items) {
+        const ordered = /^\d/.test(item.bullet);
+        if (ordered === previousOrdered) {
+            runs[runs.length - 1]?.push(item);
+        }
+        else {
+            runs.push([item]);
+            previousOrdered = ordered;
+        }
+    }
+    return runs.map(run => {
+        const firstBullet = run[0]?.bullet ?? "- ";
+        const ordered = /^\d/.test(firstBullet);
+        return {
+            type: "list",
+            ordered,
+            start: ordered ? parseInt(firstBullet, 10) || 1 : null,
+            spread: false,
+            children: run.map(item => transformUniorgListItem(ctx, item))
+        };
+    });
+}
+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
+    const tag = listItemTag(item);
+    const children = transformNodes(ctx, (item.children || []).filter(child => child !== tag));
+    if (tag) {
+        const term = {
+            type: "text",
+            value: `${orgastToString(tag)} :: `
+        };
+        const first = children[0];
+        if (first?.type === "paragraph") {
+            first.children.unshift(term);
+        }
+        else {
+            children.unshift({ type: "paragraph", children: [term] });
+        }
+    }
+    return {
+        type: "listItem",
+        spread: false,
+        checked: item.checkbox === "on" ? true : item.checkbox === "off" ? false : null,
+        children
+    };
+}

package/dist/core/uniorgToMdast/objects.d.ts

@@ -0,0 +1,4 @@
+import type { PhrasingContent } from "mdast";
+import type { ObjectType } from "uniorg";
+import { type TransformContext } from "./shared.js";
+export declare function transformUniorgObjects(ctx: TransformContext, children: ObjectType[] | undefined): PhrasingContent[];

package/dist/core/uniorgToMdast/objects.js

@@ -0,0 +1,152 @@
+import { toString as orgastToString } from "orgast-util-to-string";
+import { htmlEnabled, orgNodeToText, warn } from "./shared.js";
+import { transformFootnoteReference } from "./footnotes.js";
+const IMAGE_EXTENSION_RE = /\.(png|jpe?g|gif|svg|webp|avif|bmp|ico)$/i;
+export function transformUniorgObjects(ctx, children) {
+    return (children || [])
+        .flatMap(child => transformUniorgObjectToMdastPhrasingContent(ctx, child))
+        .filter(Boolean);
+}
+function transformUniorgObjectToMdastPhrasingContent(ctx, node) {
+    switch (node.type) {
+        case "text":
+            return { type: "text", value: node.value };
+        case "bold":
+            return {
+                type: "strong",
+                children: transformUniorgObjects(ctx, node.children)
+            };
+        case "italic":
+            return {
+                type: "emphasis",
+                children: transformUniorgObjects(ctx, node.children)
+            };
+        case "strike-through":
+            return {
+                type: "delete",
+                children: transformUniorgObjects(ctx, node.children)
+            };
+        case "link":
+            return transformUniorgLink(ctx, node);
+        case "code":
+        case "verbatim":
+            return { type: "inlineCode", value: node.value };
+        case "line-break":
+            return { type: "break" };
+        case "footnote-reference":
+            return transformFootnoteReference(ctx, node);
+        case "underline":
+        case "superscript":
+        case "subscript":
+            return transformScriptMarkup(ctx, node);
+        case "latex-fragment":
+            // display-only paragraphs become math blocks (see the paragraph
+            // handler); a fragment inside running text is inline math
+            return {
+                type: "inlineMath",
+                value: node.contents.trim()
+            };
+        case "entity":
+            // org export renders entities as their character; \alpha → α
+            return { type: "text", value: node.utf8 };
+        case "timestamp":
+            // md has no timestamps; keep the raw org value as text so the
+            // return trip re-parses it natively
+            return { type: "text", value: node.rawValue };
+        case "statistics-cookie":
+            return { type: "text", value: node.value };
+        case "citation":
+            // org-cite has no md equivalent; keep the raw [cite:…] text so the
+            // return trip re-parses it natively
+            return { type: "text", value: orgNodeToText(node).trim() };
+        case "verbatim-inline":
+            // preset-emitted passthrough: rendered unescaped by a custom
+            // stringify handler (see orgToMarkdown)
+            return {
+                type: "verbatimInline",
+                value: node.value
+            };
+        case "export-snippet":
+            return transformExportSnippet(node);
+        // remaining object types have no mapping; dropped with a warning
+        default:
+            warn(ctx, `dropped org ${node.type}`);
+            return null;
+    }
+}
+function transformUniorgLink(ctx, node) {
+    const descriptionText = orgastToString(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 };
+    }
+    // a description equal to the url (a common Logseq pattern) is no
+    // description: text === url makes remark-stringify emit an
+    // autolink (<url>), which restores to a plain org link. Urls full
+    // of / and _ re-parse as italic/subscript inside the description
+    // (and even uniorg-stringify garbles them back), so compare with
+    // org's emphasis-marker characters stripped from both sides
+    const withoutMarkers = (value) => value.replace(/[/*_+~={}]/g, "");
+    const serializedDescription = node.children.length
+        ? orgNodeToText({
+            type: "paragraph",
+            children: node.children,
+            contentsBegin: 0,
+            contentsEnd: 0
+        }).trim()
+        : "";
+    if (!node.children.length ||
+        withoutMarkers(serializedDescription) === withoutMarkers(node.rawLink)) {
+        return {
+            type: "link",
+            url: node.rawLink,
+            children: [{ type: "text", value: node.rawLink }]
+        };
+    }
+    const children = transformUniorgObjects(ctx, node.children);
+    // md cannot nest links; flatten a description that contains one
+    // (org parses bare urls inside descriptions as links)
+    const flattened = children.some(child => child.type === "link" || child.type === "image")
+        ? [{ type: "text", value: descriptionText }]
+        : children;
+    return { type: "link", url: node.rawLink, children: flattened };
+}
+function transformScriptMarkup(ctx, node) {
+    // markdown has no equivalents; with useHtml render as raw html
+    // (a preserved md-ism on the return trip), otherwise keep the raw
+    // org markup as text so the return trip re-parses it natively
+    // (convergent, like inline timestamps)
+    if (htmlEnabled(ctx, node.type)) {
+        const tagName = node.type === "underline"
+            ? "u"
+            : node.type === "superscript"
+                ? "sup"
+                : "sub";
+        return [
+            { type: "html", value: `<${tagName}>` },
+            ...transformUniorgObjects(ctx, node.children),
+            { type: "html", value: `</${tagName}>` }
+        ];
+    }
+    const content = orgastToString(node);
+    return {
+        type: "text",
+        value: node.type === "underline"
+            ? `_${content}_`
+            : node.type === "superscript"
+                ? `^{${content}}`
+                : `_{${content}}`
+    };
+}
+function transformExportSnippet(node) {
+    if (node.backEnd !== "html") {
+        // kept as raw @@backend:…@@ text (unescaped) so the return trip
+        // re-parses the snippet natively
+        return {
+            type: "verbatimInline",
+            value: `@@${node.backEnd}:${node.value}@@`
+        };
+    }
+    return { type: "html", value: node.value };
+}

package/dist/core/uniorgToMdast/shared.d.ts

@@ -0,0 +1,25 @@
+import type { PhrasingContent, RootContent } from "mdast";
+import { type Toggle } from "../../options.js";
+export interface UniorgToMdastOptions {
+    preserveOrgisms?: Toggle;
+    useHtml?: Toggle;
+    taskCheckboxes?: boolean;
+    orgismKeys?: Record<string, string>;
+    onWarning?: (message: string) => void;
+}
+export interface TransformContext {
+    options: UniorgToMdastOptions;
+    inlineFootnotes: {
+        label: string;
+        children: PhrasingContent[];
+    }[];
+    usedFootnoteLabels: Set<string>;
+}
+export declare function orgismEnabled(ctx: TransformContext, key: string): boolean;
+export declare function htmlEnabled(ctx: TransformContext, key: string): boolean;
+export declare function warn(ctx: TransformContext, message: string): void;
+export declare function keyName(ctx: TransformContext, key: string): string;
+export declare function keyValueParagraph(lines: string[]): RootContent;
+export declare function orgNodeToText(node: unknown): string;
+export declare function trimTrailingNewline(value: string): string;
+export declare function affiliatedLines(node: unknown): string[];

package/dist/core/uniorgToMdast/shared.js

@@ -0,0 +1,55 @@
+import { toString as orgastToString } from "orgast-util-to-string";
+import { unified } from "unified";
+import { uniorgStringify } from "uniorg-stringify";
+import { toggleEnabled } from "../../options.js";
+export function orgismEnabled(ctx, key) {
+    return toggleEnabled(ctx.options.preserveOrgisms, key);
+}
+export function htmlEnabled(ctx, key) {
+    return toggleEnabled(ctx.options.useHtml, key, false);
+}
+export function warn(ctx, message) {
+    ctx.options.onWarning?.(message);
+}
+// org-ism key:: names are user-configurable (ADR 0002 point 5)
+export function keyName(ctx, key) {
+    return ctx.options.orgismKeys?.[key] ?? key;
+}
+// custom mdast node stringified verbatim (see orgToMarkdown handlers) so
+// keys like custom_id are not markdown-escaped to custom\_id
+export function keyValueParagraph(lines) {
+    return { type: "keyValue", value: lines.join("\n") };
+}
+// renders a single uniorg node back to its org text (without the
+// trailing newline), for verbatim passthrough of org-only constructs
+export function orgNodeToText(node) {
+    const orgText = unified()
+        .use(uniorgStringify)
+        .stringify({
+        type: "org-data",
+        children: [node],
+        contentsBegin: 0,
+        contentsEnd: 0
+    });
+    return orgText.replace(/\n$/, "");
+}
+// uniorg block values keep the newline before the #+end_ line; mdast
+// code values do not include it
+export function trimTrailingNewline(value) {
+    return value.replace(/\n$/, "");
+}
+// affiliated keywords (#+CAPTION:, #+NAME:, #+ATTR_*) precede their
+// element as verbatim lines so the return trip re-attaches them natively
+export function affiliatedLines(node) {
+    const affiliated = node
+        .affiliated;
+    return Object.entries(affiliated ?? {}).flatMap(([key, value]) => {
+        const entries = Array.isArray(value) ? value : [value];
+        return entries.map(entry => {
+            const text = Array.isArray(entry)
+                ? entry.map(child => orgastToString(child)).join("")
+                : String(entry);
+            return `#+${key}: ${text}`;
+        });
+    });
+}

package/dist/core/uniorgToMdast/tables.d.ts

@@ -0,0 +1,6 @@
+import type { RootContent } from "mdast";
+import type { GreaterElementType } from "uniorg";
+import { type TransformContext } from "./shared.js";
+export declare function transformTable(ctx: TransformContext, node: Extract<GreaterElementType, {
+    type: "table";
+}>): RootContent;

package/dist/core/uniorgToMdast/tables.js

@@ -0,0 +1,66 @@
+import { trimTrailingNewline } from "./shared.js";
+import { transformUniorgObjects } from "./objects.js";
+function cellText(cell) {
+    return (cell.children || [])
+        .map(child => (child.type === "text" ? child.value : ""))
+        .join("")
+        .trim();
+}
+function isAlignmentCookieRow(row) {
+    const cells = row.children || [];
+    return (cells.length > 0 &&
+        cells.every(cell => {
+            const text = cellText(cell);
+            return text === "" || /^<[lrc]\d*>$/.test(text);
+        }) &&
+        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();
+    }
+    return node;
+}
+export function transformTable(ctx, node) {
+    if (node.tableType === "table.el") {
+        // table.el tables have no cell structure, only a verbatim value;
+        // a table.el-tagged fenced block carries it so the return trip
+        // can restore the table
+        return {
+            type: "code",
+            lang: "table.el",
+            value: trimTrailingNewline(node.value)
+        };
+    }
+    const standardRows = (node.children || []).filter((row) => row.type === "table-row" && row.rowType === "standard");
+    // an org alignment cookie row (| <l> | <r> | <c> |) becomes GFM
+    // column alignment instead of a content row
+    const cookieRow = standardRows.find(isAlignmentCookieRow);
+    const align = cookieRow
+        ? (cookieRow.children || []).map(cell => {
+            const cookie = /^<([lrc])\d*>$/.exec(cellText(cell))?.[1];
+            return cookie === "l"
+                ? "left"
+                : cookie === "r"
+                    ? "right"
+                    : cookie === "c"
+                        ? "center"
+                        : null;
+        })
+        : null;
+    return {
+        type: "table",
+        align,
+        children: standardRows
+            .filter(row => row !== cookieRow)
+            .map(row => ({
+            type: "tableRow",
+            children: (row.children || []).map(cell => ({
+                type: "tableCell",
+                children: transformUniorgObjects(ctx, cell.children).map(trimCellPadding)
+            }))
+        }))
+    };
+}

package/dist/fileNames.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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
+ * name happens to start with a dot.
+ *
+ * The extension comes from the last path segment, since the CLI is handed
+ * paths rather than the bare names the Web UI reads off a `File`; the stem
+ * keeps any directory, being the part a derived name builds on.
+ */
+export declare function splitFileName(name: string): {
+    stem: string;
+    extension: string;
+};
+/** The format a file name implies, or undefined if it implies none. */
+export declare function formatFromFileName(name: string): "markdown" | "org" | undefined;

package/dist/fileNames.js

@@ -0,0 +1,34 @@
+/** The document formats morg reads, by file extension. */
+const DOCUMENT_FORMATS = new Map([
+    ["md", "markdown"],
+    ["org", "org"]
+]);
+/**
+ * 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
+ * name happens to start with a dot.
+ *
+ * The extension comes from the last path segment, since the CLI is handed
+ * paths rather than the bare names the Web UI reads off a `File`; the stem
+ * keeps any directory, being the part a derived name builds on.
+ */
+export function splitFileName(name) {
+    const base = name.slice(lastSeparator(name) + 1);
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0) {
+        return { stem: name, extension: "" };
+    }
+    return {
+        stem: name.slice(0, name.length - base.length + dot),
+        extension: base.slice(dot + 1).toLowerCase()
+    };
+}
+/** Index of the last path separator, or -1. Windows accepts both. */
+function lastSeparator(name) {
+    return Math.max(name.lastIndexOf("/"), name.lastIndexOf("\\"));
+}
+/** The format a file name implies, or undefined if it implies none. */
+export function formatFromFileName(name) {
+    return DOCUMENT_FORMATS.get(splitFileName(name).extension);
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { convertMarkdownToOrg } from "./markdownToOrg.js";
+export { convertOrgToMarkdown } from "./orgToMarkdown.js";
+export { normalizeMarkdown, normalizeOrg } from "./normalize.js";
+export type { NormalizeOptions } from "./normalize.js";
+export { parseConfig } from "./config.js";
+export type { MorgConfig } from "./config.js";
+export { transformMdastToUniorgAst } from "./core/mdastToUniorg/index.js";
+export { transformUniorgAstToMdast } from "./core/uniorgToMdast/index.js";
+export { logseq } from "./presets/logseq.js";
+export { obsidian } from "./presets/obsidian.js";
+export type { Preset } from "./presets/types.js";
+export type { LogseqPresetOptions } from "./presets/logseq.js";
+export type { Toggle, MarkdownToOrgOptions, OrgToMarkdownOptions, MarkdownStyleOptions } from "./options.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { convertMarkdownToOrg } from "./markdownToOrg.js";
+export { convertOrgToMarkdown } from "./orgToMarkdown.js";
+export { normalizeMarkdown, normalizeOrg } from "./normalize.js";
+export { parseConfig } from "./config.js";
+export { transformMdastToUniorgAst } from "./core/mdastToUniorg/index.js";
+export { transformUniorgAstToMdast } from "./core/uniorgToMdast/index.js";
+export { logseq } from "./presets/logseq.js";
+export { obsidian } from "./presets/obsidian.js";

package/dist/markdownToOrg.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownToOrgOptions } from "./options.js";
+/**
+ * Converts a Markdown string to an Org-mode string.
+ * @param markdown The Markdown string to convert.
+ * @param options Conversion options (md-ism preservation, dialect preset).
+ * @returns The converted Org-mode string.
+ */
+export declare function convertMarkdownToOrg(markdown: string, options?: MarkdownToOrgOptions): string;