@remigius42/morg 0.9.2 → 0.10.1

package/dist/presets/obsidian.js

@@ -1,5 +1,7 @@
 import { visit } from "unist-util-visit";
 import { toString } from "orgast-util-to-string";
+import { maskCode } from "../core/outsideCode.js";
+import { FUZZY_LINK_RE } from "./links.js";
 /**
  * Obsidian dialect preset: `[[Page]]` / `[[Page|alias]]` wikilinks map
  * to org fuzzy links (`[[Page]]` / `[[Page][alias]]`).
@@ -9,16 +11,29 @@ export function obsidian() {
         name: "obsidian",
         markdown: {
             read: { org: rewriteAliasedWikilinks },
-            write: fuzzyLinksToWikilinks
-        }
+            write: fuzzyLinksToWikilinks,
+            links: {
+                read: text => text.replace(ALIASED_PAGE_LINK_RE, "[[$1][$2]]"),
+                // a bare `|` would split a table's cell
+                write: (text, inTable) => text.replace(FUZZY_LINK_RE, inTable ? "[[$1\\|$2]]" : "[[$1|$2]]")
+            }
+        },
+        // Vanilla Markdown reads Obsidian's own syntax but for these; the
+        // way back has nothing to do
+        translateMarkdown: (markdown, context) => context.side === "input" ? toVanilla(markdown) : markdown
     };
 }
+// not an embed, whose `|300` is a size
+const ALIASED_WIKILINK_RE = /(?<!!)\[\[([^\][|]+)\|([^\][]+)\]\]/g;
+// in Markdown text: not an embed, whose `|300` is a size, and with a
+// table cell's escaped pipe (`[[Page\|alias]]`)
+const ALIASED_PAGE_LINK_RE = /(?<!!)\[\[([^\][|\\]+)\\?\|([^\][]+)\]\]/g;
 // md→org: a wikilink travels as plain text; org already reads `[[Page]]`
 // as a fuzzy link, only the `[[Page|alias]]` form needs rewriting to
 // org's `[[Page][alias]]` description syntax
 function rewriteAliasedWikilinks(uniorgAst) {
     visit(uniorgAst, "text", (node) => {
-        node.value = node.value.replace(/\[\[([^\][|]+)\|([^\][]+)\]\]/g, "[[$1][$2]]");
+        node.value = node.value.replace(ALIASED_WIKILINK_RE, "[[$1][$2]]");
     });
     return uniorgAst;
 }
@@ -30,13 +45,69 @@ function fuzzyLinksToWikilinks(uniorgAst) {
             return undefined;
         }
         const description = node.children.length ? toString(node) : "";
+        // an embed's `!` goes with it, else Markdown escapes it before `[`
+        const previous = parent.children[index - 1];
+        const embed = previous?.type === "text" && previous.value.endsWith("!");
+        if (embed) {
+            previous.value = previous.value.slice(0, -1);
+        }
         parent.children[index] = {
             type: "verbatim-inline",
-            value: description
+            value: `${embed ? "!" : ""}${description
                 ? `[[${node.rawLink}|${description}]]`
-                : `[[${node.rawLink}]]`
+                : `[[${node.rawLink}]]`}`
         };
         return undefined;
     });
     return uniorgAst;
 }
+const COMMENT_RE = /%%([\s\S]*?)%%/g;
+const FOOTNOTE_LABEL_RE = /\[\^(\d+)\]/g;
+// Obsidian Markdown → Vanilla Markdown: a comment is an HTML comment,
+// an inline footnote a footnote, numbered on from the page's own, its
+// definition at the end; their delimiters count outside code only, what
+// they hold may be code
+function toVanilla(markdown) {
+    let masked = maskCode(markdown);
+    const edits = [];
+    for (const { index, 0: comment } of masked.matchAll(COMMENT_RE)) {
+        const end = index + comment.length;
+        edits.push([index, end, `<!--${markdown.slice(index + 2, end - 2)}-->`]);
+        // a footnote in a comment is part of it
+        masked =
+            masked.slice(0, index) + "\0".repeat(comment.length) + masked.slice(end);
+    }
+    let next = Math.max(0, ...[...markdown.matchAll(FOOTNOTE_LABEL_RE)].map(([, n]) => Number(n))) + 1;
+    const definitions = [];
+    for (const [start, end] of inlineFootnotes(masked)) {
+        definitions.push(`[^${next}]: ${markdown.slice(start + 2, end)}`);
+        edits.push([start, end + 1, `[^${next++}]`]);
+    }
+    let result = markdown;
+    for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0])) {
+        result = result.slice(0, start) + text + result.slice(end);
+    }
+    return definitions.length
+        ? `${result.replace(/\n*$/, "")}\n\n${definitions.join("\n")}\n`
+        : result;
+}
+// each `^[note]`, its brackets balanced: where it starts, and its `]`
+function inlineFootnotes(text) {
+    const notes = [];
+    for (let start = text.indexOf("^["); start !== -1;) {
+        let depth = 0;
+        let end = start + 1;
+        for (; end < text.length; end++) {
+            depth += text[end] === "[" ? 1 : text[end] === "]" ? -1 : 0;
+            if (!depth) {
+                break;
+            }
+        }
+        if (end === text.length) {
+            break;
+        }
+        notes.push([start, end]);
+        start = text.indexOf("^[", end + 1);
+    }
+    return notes;
+}

package/dist/presets/types.d.ts

@@ -7,7 +7,9 @@ import type { OrgData } from "uniorg";
  * `convertMarkdown` take a whole conversion over, for a dialect whose
  * documents are no single org or Markdown document (an outline of
  * blocks, each its own fragment); `convert` runs the core on a fragment,
- * with the given preset's hooks.
+ * with the given preset's hooks. `translateOrg` and `translateMarkdown`
+ * translate a page between the preset's dialect of the format and
+ * Vanilla.
  */
 export interface Preset {
     name: string;
@@ -15,6 +17,8 @@ export interface Preset {
     org?: OrgDialect;
     convertOrg?: (org: string, convert: FragmentConverter, context: ConversionContext) => string;
     convertMarkdown?: (markdown: string, convert: FragmentConverter, context: ConversionContext) => string;
+    translateOrg?: (org: string, context: ConversionContext) => string;
+    translateMarkdown?: (markdown: string, context: ConversionContext) => string;
 }
 /**
  * What a preset that takes a whole conversion over learns of it: the
@@ -25,6 +29,11 @@ export interface ConversionContext {
     side: "both" | "input" | "output";
     onWarning?: (message: string) => void;
     orgismKeys?: Record<string, string>;
+    /**
+     * A translation's page links from the input's dialect into the
+     * output's, in a table's text or not.
+     */
+    relink?: (text: string, inTable: boolean) => string;
 }
 /**
  * Converts a fragment with the core, the given preset's AST hooks on
@@ -44,6 +53,17 @@ export interface MarkdownDialect {
         org?: (uniorgAst: OrgData) => OrgData;
     };
     write?: (uniorgAst: OrgData) => OrgData;
+    /**
+     * Its page links in Markdown text to org's fuzzy link syntax
+     * (`[[Page][label]]`) and back, for a translation between two
+     * dialects; `write` is told if the text is in a table.
+     */
+    links?: {
+        read: (text: string) => string;
+        write: (text: string, inTable: boolean) => string;
+    };
+    /** The bullet its outline needs, which no style may change. */
+    bullet?: "-" | "*" | "+";
 }
 /**
  * A preset's org dialect. `read` runs in org→md before the generic

package/dist/translate.d.ts

@@ -0,0 +1,34 @@
+import type { MarkdownStyleOptions } from "./options.js";
+import { type PresetOptions } from "./presets/sides.js";
+/**
+ * The presets of a translation, its warning callback and the org-ism
+ * key names Vanilla Markdown writes planning under.
+ */
+export type TranslateOptions = PresetOptions & {
+    onWarning?: (message: string) => void;
+    orgismKeys?: Record<string, string>;
+    /** The Markdown markers to write; others stay as written. */
+    markdownStyle?: MarkdownStyleOptions;
+};
+/**
+ * Translates an Org string from the Input Preset's dialect into the
+ * Output Preset's, changing only what the two dialects write
+ * differently (ADR 0006): a block's content is kept as written.
+ * @param org The Org string to translate.
+ * @param options The preset of each side, which must differ.
+ * @returns The Org string in the output's dialect.
+ * @throws If both sides name the same preset (that is `normalizeOrg`),
+ * or a side preset has no org dialect.
+ */
+export declare function translateOrg(org: string, options?: TranslateOptions): string;
+/**
+ * Translates a Markdown string from the Input Preset's dialect into the
+ * Output Preset's, changing only what the two dialects write
+ * differently (ADR 0006): a block's content is kept as written.
+ * @param markdown The Markdown string to translate.
+ * @param options The preset of each side, which must differ.
+ * @returns The Markdown string in the output's dialect.
+ * @throws If both sides name the same preset (that is
+ * `normalizeMarkdown`).
+ */
+export declare function translateMarkdown(markdown: string, options?: TranslateOptions): string;

package/dist/translate.js

@@ -0,0 +1,82 @@
+import { restyleMarkdown } from "./core/restyle.js";
+import { resolveSides } from "./presets/sides.js";
+/**
+ * Translates an Org string from the Input Preset's dialect into the
+ * Output Preset's, changing only what the two dialects write
+ * differently (ADR 0006): a block's content is kept as written.
+ * @param org The Org string to translate.
+ * @param options The preset of each side, which must differ.
+ * @returns The Org string in the output's dialect.
+ * @throws If both sides name the same preset (that is `normalizeOrg`),
+ * or a side preset has no org dialect.
+ */
+export function translateOrg(org, options = {}) {
+    const { input, output } = twoSides(options, "org", "normalizeOrg");
+    // Vanilla has no dialect to translate, so the other side does it
+    const side = input?.translateOrg ? "input" : "output";
+    const translate = (side === "input" ? input : output)?.translateOrg;
+    return translate
+        ? translate(org, {
+            side,
+            ...(options.onWarning && { onWarning: options.onWarning })
+        })
+        : org;
+}
+/**
+ * Translates a Markdown string from the Input Preset's dialect into the
+ * Output Preset's, changing only what the two dialects write
+ * differently (ADR 0006): a block's content is kept as written.
+ * @param markdown The Markdown string to translate.
+ * @param options The preset of each side, which must differ.
+ * @returns The Markdown string in the output's dialect.
+ * @throws If both sides name the same preset (that is
+ * `normalizeMarkdown`).
+ */
+export function translateMarkdown(markdown, options = {}) {
+    const { input, output } = twoSides(options, "markdown", "normalizeMarkdown");
+    const context = hookContext(options, pageLinks({ input, output }));
+    // into Vanilla from the input's dialect, then from it into the
+    // output's; a dialect does what its side needs
+    const vanilla = input?.translateMarkdown?.(markdown, { ...context, side: "input" }) ??
+        markdown;
+    const translated = output?.translateMarkdown?.(vanilla, { ...context, side: "output" }) ??
+        vanilla;
+    const style = outputStyle(options, output);
+    return style ? restyleMarkdown(translated, style) : translated;
+}
+// the style to write, but for a bullet the output's outline needs
+function outputStyle({ markdownStyle, onWarning }, output) {
+    const needed = output?.markdown?.bullet;
+    if (!markdownStyle?.bullet || !needed || markdownStyle.bullet === needed) {
+        return markdownStyle;
+    }
+    onWarning?.(`${output.name} Markdown writes its blocks with '${needed}'; bullet '${markdownStyle.bullet}' not applied`);
+    const style = { ...markdownStyle };
+    delete style.bullet;
+    return style;
+}
+// what a dialect's translation learns of the options
+function hookContext({ onWarning, orgismKeys }, relink) {
+    return {
+        ...(onWarning && { onWarning }),
+        ...(orgismKeys && { orgismKeys }),
+        ...(relink && { relink })
+    };
+}
+// page links between two dialects; a Vanilla side carries the other's
+function pageLinks({ input, output }) {
+    const read = input?.markdown?.links?.read;
+    const write = output?.markdown?.links?.write;
+    return read && write
+        ? (text, inTable) => write(read(text), inTable)
+        : undefined;
+}
+// a translation is between two dialects; one on both sides normalizes
+function twoSides(options, format, normalize) {
+    const sides = resolveSides(options, format, format);
+    const name = sides.input?.name ?? "vanilla";
+    if (name === (sides.output?.name ?? "vanilla")) {
+        throw new Error(`translation takes two presets; for '${name}' on both sides, use ${normalize}`);
+    }
+    return sides;
+}

package/dist/withinFormat.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizeOptions } from "./normalize.js";
+import type { Format } from "./presets/sides.js";
+/**
+ * Converts within one format: two presets translate between their
+ * dialects, one normalizes (ADR 0006). What both adapters do with one
+ * format on both sides.
+ * @param text The document.
+ * @param format Its format, on both sides.
+ * @param options The conversion's options, presets included.
+ * @returns The translated or normalized document.
+ */
+export declare function convertWithinFormat(text: string, format: Format, options?: NormalizeOptions): string;

package/dist/withinFormat.js

@@ -0,0 +1,18 @@
+import { normalizeMarkdown, normalizeOrg } from "./normalize.js";
+import { translateMarkdown, translateOrg } from "./translate.js";
+/**
+ * Converts within one format: two presets translate between their
+ * dialects, one normalizes (ADR 0006). What both adapters do with one
+ * format on both sides.
+ * @param text The document.
+ * @param format Its format, on both sides.
+ * @param options The conversion's options, presets included.
+ * @returns The translated or normalized document.
+ */
+export function convertWithinFormat(text, format, options = {}) {
+    const markdown = format === "markdown";
+    if (options.inputPreset || options.outputPreset) {
+        return (markdown ? translateMarkdown : translateOrg)(text, options);
+    }
+    return (markdown ? normalizeMarkdown : normalizeOrg)(text, options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remigius42/morg",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "Bidirectional Markdown ↔ Org-mode converter with round-trip convergence",
   "keywords": [
     "org-mode",
@@ -40,7 +40,7 @@
     "provenance": true
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "scripts": {
     "prepare": "husky",