@remigius42/morg 0.9.1 → 0.10.0

package/README.md

@@ -6,7 +6,7 @@ Copyright 2026 [Andreas Remigius Schmidt](https://github.com/remigius42)
 [![Changelog](https://img.shields.io/github/v/tag/remigius42/morg?label=changelog)](https://github.com/remigius42/morg/blob/main/CHANGELOG.md)
 [![License](https://img.shields.io/badge/license-GPL--3.0--or--later-blue.svg)](LICENSE)
 [![CI](https://github.com/remigius42/morg/actions/workflows/ci.yml/badge.svg)](https://github.com/remigius42/morg/actions/workflows/ci.yml)
-![Node](https://img.shields.io/badge/node-%3E%3D20-lightgrey.svg)
+![Node](https://img.shields.io/badge/node-%3E%3D24-lightgrey.svg)
 [![Codacy grade](https://app.codacy.com/project/badge/Grade/da438d1b90e74d40b03f9fa5b3eca221)](https://app.codacy.com/gh/remigius42/morg/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 [![Codacy coverage](https://app.codacy.com/project/badge/Coverage/da438d1b90e74d40b03f9fa5b3eca221)](https://app.codacy.com/gh/remigius42/morg/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
 
@@ -18,7 +18,9 @@ Bidirectional **Markdown ↔ Org-mode** converter, built on the
 morg treats Org as a canonical plain-text format and Markdown (Obsidian,
 generic) as the interop surface. Dialect conventions, such as
 [Logseq](https://docs.logseq.com/)'s outline of blocks and page
-properties, are supported via presets.
+properties, are supported via presets. Within one format, morg
+translates between two dialects (Logseq Markdown ↔ Markdown, Obsidian
+↔ Logseq), changing only what they write differently.
 
 ## Round-trip convergence
 
@@ -63,6 +65,7 @@ happens in your browser, nothing is uploaded (see [ADR
 0003](docs/adr/0003-client-side-web-ui-on-github-pages.md)). Each side
 names its format and dialect (Input: Org (Logseq), Output: Markdown);
 the direction follows from the two, the same on both sides normalizes,
+two dialects of one format translate (Markdown (Logseq) → Markdown),
 and ⇄ swaps them. The
 chrome-less embed page (`/embed.html`, optionally with
 `?theme=dark|light`) can be iframed into other sites. It posts its
@@ -90,7 +93,8 @@ both at once and each goes where it belongs; an overlay names what is
 accepted while a drag is in flight, and anything that turns out not to
 be text is named in the warning list rather than loaded. The result can
 be copied or saved with the Copy and Download buttons; a normalized file
-is saved as `notes.normalized.org`, and switching to a direction that no
+is saved as `notes.normalized.org`, a translated one under its dialect
+(`page.vanilla.md`), and switching to a direction that no
 longer reads the opened file falls back to a generic name, so neither
 lands on top of its own source. Files are read and written by the
 browser itself; this is not an upload.
@@ -137,10 +141,14 @@ morg --input notes.md --output notes.org --silent
 # canonicalizing it; markers used inconsistently warn and are skipped
 morg --input notes.md --output notes.org --record-style
 
-# Normalize to canonical form (same format in and out); this
+# Translate between two dialects of one format, changing only what
+# they write differently (a block's content stays as written)
+morg --input-preset logseq --input page.md --output page.vanilla.md
+
+# Normalize to canonical form (same format and preset in and out); this
 # canonicalizes (the one-time reformat a first conversion would apply
 # anyway, ADR 0001); it is not a style formatter like prettier
-morg normalize --input notes.org --output notes.org
+morg --input notes.org --output notes.org
 ```
 
 ### Configuration file
@@ -223,6 +231,9 @@ preset })`: `preserveOrgisms` default `true`; `useHtml` (default
   `[[((uuid))][label]]`, and `^^highlight^^` markup survives verbatim
   (it would otherwise re-parse as superscripts).
 - `obsidian()`: wikilinks `[[Page]]` / `[[Page|alias]]` ↔ org fuzzy links
+  (`[[Page\|alias]]` in a table cell). Translated to Vanilla or Logseq
+  Markdown, a `%%comment%%` becomes an HTML comment and an inline
+  footnote `^[note]` a footnote.
 - `inputPreset` / `outputPreset` (on both conversions): the dialect
   the input is read in and the one the output is written in (ADR
   0006); leaving one out is Vanilla. `preset` sets both, but leaves a
@@ -231,15 +242,27 @@ preset })`: `preserveOrgisms` default `true`; `useHtml` (default
   `preset` naming another preset than a side preset.
 
 - `normalizeMarkdown(md, { preset })` / `normalizeOrg(org, { preset })`
-  (CLI: `morg normalize`): one full round trip to morg's canonical
+  (CLI: one format and preset on both sides): one full round trip to morg's canonical
   form, a fixed point, within one dialect: different presets per side
   throw. Canonicalization, not styling: org-isms and
   md-isms are rewritten exactly as a conversion would rewrite them.
   Normalize with the same preset/config you will convert with, since
   convergence is per-config (ADR 0002).
 
+- `translateOrg(org, { inputPreset, outputPreset })`: translates
+  between two org dialects (Logseq org ↔ Vanilla org), changing only
+  what they write differently: a block's content stays as written.
+  The same preset on both sides throws; that is `normalizeOrg`.
+  `translateMarkdown(md, { inputPreset, outputPreset })` does the same
+  within Markdown (Logseq md, Obsidian md and Vanilla md, any two);
+  `orgismKeys` names the
+  `key::` lines Vanilla md writes planning under, as in a conversion,
+  and `markdownStyle` rewrites the markers it names, leaving the rest
+  as written.
+
 - `markdownStyle: { bullet, emphasis, strong, fence, rule, ruleRepetition }`
-  (on `convertOrgToMarkdown` and `normalizeMarkdown`; CLI `--bullet`,
+  (on `convertOrgToMarkdown`, `normalizeMarkdown` and
+  `translateMarkdown`; CLI `--bullet`,
   `--emphasis`, `--strong`, `--fence`, `--rule`, `--rule-repetition`)
   are Markdown output style knobs. Defaults match prettier except
   emphasis (`*italic*`); `--emphasis _` aligns fully with prettier.
@@ -248,7 +271,7 @@ preset })`: `preserveOrgisms` default `true`; `useHtml` (default
   CommonMark/GFM prescribe no style; these defaults are morg's
   canonical choices, not a standard.
 
-Both convert functions also accept `onWarning: message => …`, called for
+The convert and translate functions also accept `onWarning: message => …`, called for
 each construct dropped without an equivalent (e.g. image titles, LaTeX
 fragments). The CLI wires this to stderr unless `-s` / `--silent` is
 given; the library is silent unless a callback is passed.
@@ -275,9 +298,10 @@ Project vocabulary lives in [CONTEXT.md](CONTEXT.md); design decisions in
 The core conversion surface is feature-complete and validated against
 real-world Logseq org vaults (edge cases found there live on as
 anonymized fixtures, e.g. `tests/fixtures/logseq-vault.org`), and
-the conversions between a Logseq dialect and Vanilla Org or Markdown
-are checked by round trips of that vault and of public Markdown and
-Org documentation from either side; the
+the conversions between a Logseq dialect and Vanilla Org or Markdown,
+and the translations between two dialects of one format, are checked
+by round trips of that vault and of public Markdown and Org
+documentation from either side; the
 client-side [Web UI](https://morg.binarypoetry.ch) is deployed from
 `main`. The npm package is `@remigius42/morg`, since the bare `morg`
 name is taken, and pushing a `v*` tag publishes it. Most of the code is

package/dist/cli/args.d.ts

@@ -1,5 +1,4 @@
 export interface CliArgs {
-    normalize: boolean;
     help: boolean;
     version: boolean;
     fromFormat: string | undefined;

package/dist/cli/args.js

@@ -1,14 +1,11 @@
 import { CliError } from "./error.js";
 import { FLAGS_BY_NAME } from "./flags.js";
 export function parseArgs(args) {
-    // `morg normalize` canonicalizes in place of converting: same format
-    // in and out, one full round trip (see ADR 0001)
-    const normalize = args[0] === "normalize";
-    if (normalize) {
-        args.shift();
+    // gone in 0.10.0: one format on both sides normalizes (ADR 0006)
+    if (args[0] === "normalize") {
+        throw new CliError("'morg normalize' is gone: the same format and preset on both sides normalizes (--from org --to org)");
     }
     const parsed = {
-        normalize,
         help: false,
         version: false,
         fromFormat: undefined,

package/dist/cli/conversion.d.ts

@@ -1,6 +1,6 @@
 import type { MorgConfig } from "../config.js";
 import type { MarkdownStyleOptions } from "../options.js";
-import type { PresetOptions } from "../presets/sides.js";
+import type { Format, PresetOptions } from "../presets/sides.js";
 import type { CliArgs } from "./args.js";
 export declare function buildConversionOptions(cli: CliArgs, config: MorgConfig, presets: PresetOptions): {
     mdToOrgOptions: import("../options.js").MarkdownToOrgOptions;
@@ -8,4 +8,4 @@ export declare function buildConversionOptions(cli: CliArgs, config: MorgConfig,
         markdownStyle: MarkdownStyleOptions;
     };
 };
-export declare function convert(inputContent: string, fromFormat: string, normalize: boolean, cli: CliArgs, config: MorgConfig, presets: PresetOptions): string;
+export declare function convert(inputContent: string, fromFormat: Format, toFormat: Format, cli: CliArgs, config: MorgConfig, presets: PresetOptions): string;

package/dist/cli/conversion.js

@@ -1,6 +1,6 @@
 import { convertMarkdownToOrg } from "../markdownToOrg.js";
 import { convertOrgToMarkdown } from "../orgToMarkdown.js";
-import { normalizeMarkdown, normalizeOrg } from "../normalize.js";
+import { convertWithinFormat } from "../withinFormat.js";
 import { buildConversionOptions as layerOptions } from "../conversionOptions.js";
 import { CliError } from "./error.js";
 export function buildConversionOptions(cli, config, presets) {
@@ -28,16 +28,14 @@ export function buildConversionOptions(cli, config, presets) {
         ...(config.orgismKeys && { orgismKeys: config.orgismKeys })
     });
 }
-export function convert(inputContent, fromFormat, normalize, cli, config, presets) {
+export function convert(inputContent, fromFormat, toFormat, cli, config, presets) {
     try {
         const { mdToOrgOptions, orgToMdOptions } = buildConversionOptions(cli, config, presets);
-        if (normalize) {
-            return fromFormat === "markdown"
-                ? normalizeMarkdown(inputContent, {
-                    ...mdToOrgOptions,
-                    ...orgToMdOptions
-                })
-                : normalizeOrg(inputContent, { ...mdToOrgOptions, ...orgToMdOptions });
+        if (fromFormat === toFormat) {
+            return convertWithinFormat(inputContent, fromFormat, {
+                ...mdToOrgOptions,
+                ...orgToMdOptions
+            });
         }
         if (fromFormat === "markdown") {
             return convertMarkdownToOrg(inputContent, mdToOrgOptions);

package/dist/cli/formats.d.ts

@@ -1,4 +1,4 @@
 import type { CliArgs } from "./args.js";
 import type { Format } from "../presets/sides.js";
 export declare function inferFormats(cli: CliArgs): [fromFormat: string | undefined, toFormat: string | undefined];
-export declare function validateFormats(fromFormat: string | undefined, toFormat: string | undefined, normalize: boolean): [fromFormat: Format, toFormat: Format];
+export declare function validateFormats(fromFormat: string | undefined, toFormat: string | undefined): [fromFormat: Format, toFormat: Format];

package/dist/cli/formats.js

@@ -9,17 +9,11 @@ export function inferFormats(cli) {
     if (cli.outputFile && !toFormat) {
         toFormat = formatFromFileName(cli.outputFile);
     }
-    return inferMissingFormat(cli.normalize, fromFormat, toFormat);
+    return inferMissingFormat(fromFormat, toFormat);
 }
 // Infer missing format based on the other
-function inferMissingFormat(normalize, fromFormat, toFormat) {
-    if (normalize) {
-        // mirror whichever side is known; a conflict between the two is left
-        // intact for validateFormats to reject rather than silently overwritten
-        fromFormat = fromFormat ?? toFormat;
-        toFormat = toFormat ?? fromFormat;
-    }
-    else if (fromFormat && !toFormat) {
+function inferMissingFormat(fromFormat, toFormat) {
+    if (fromFormat && !toFormat) {
         toFormat = fromFormat === "markdown" ? "org" : "markdown";
     }
     else if (toFormat && !fromFormat) {
@@ -36,7 +30,7 @@ function fileNameHint(flag, value) {
     const fileFlag = flag === "--from" ? "--input" : "--output";
     return `\n${flag} takes a format name; for a file use ${fileFlag} ${value}.`;
 }
-export function validateFormats(fromFormat, toFormat, normalize) {
+export function validateFormats(fromFormat, toFormat) {
     if (!fromFormat || !toFormat) {
         throw new CliError("Error: Could not determine conversion formats.\n" +
             "Please specify --from and --to, or provide input/output files with .md or .org extensions.");
@@ -50,12 +44,5 @@ export function validateFormats(fromFormat, toFormat, normalize) {
                 `'markdown' and 'org'.${fileNameHint(flag, value)}`);
         }
     }
-    if (!normalize && fromFormat === toFormat) {
-        throw new CliError("Error: Source and target formats cannot be the same.");
-    }
-    if (normalize && fromFormat !== toFormat) {
-        throw new CliError("Error: normalize reads and writes the same format; " +
-            `got '${fromFormat}' and '${toFormat}'.`);
-    }
     return [fromFormat, toFormat];
 }

package/dist/cli/help.js

@@ -5,15 +5,13 @@ const DESCRIPTION_COLUMN = Math.max(...FLAGS.map(spec => signature(spec).length)
 const section = (specs) => specs
     .map(spec => `  ${signature(spec).padEnd(DESCRIPTION_COLUMN)}${spec.description}`)
     .join("\n");
-export const HELP_TEXT = `Usage: morg [normalize] [options]
+export const HELP_TEXT = `Usage: morg [options]
 
 Convert between Markdown and Org-mode. Reads stdin and writes stdout
 unless --input/--output are given; formats are inferred from the .md and
 .org file extensions, so --from/--to are only needed for stdin or stdout.
-
-Commands:
-  ${"normalize".padEnd(DESCRIPTION_COLUMN)}Round-trip a document through the other format
-  ${"".padEnd(DESCRIPTION_COLUMN)}and back, canonicalizing it in its own format
+One format on both sides translates between two presets' dialects, and
+with one preset normalizes: a round trip through the other format.
 
 Options:
 ${section(FLAGS.filter(spec => spec.kind !== "style"))}
@@ -24,5 +22,6 @@ ${section(FLAGS.filter(spec => spec.kind === "style"))}
 Examples:
   morg --input notes.md --output notes.org
   morg --from markdown < notes.md > notes.org
-  morg normalize --input notes.org --output notes.org
+  morg --input-preset logseq --input page.md --output page.vanilla.md
+  morg --input notes.org --output notes.org
 `;

package/dist/cli.js

@@ -46,10 +46,10 @@ async function main() {
         return;
     }
     const config = loadConfig(cli.configPath);
-    const [fromFormat, toFormat] = validateFormats(...inferFormats(cli), cli.normalize);
+    const [fromFormat, toFormat] = validateFormats(...inferFormats(cli));
     const presets = resolvePresets(cli, config, fromFormat, toFormat);
     const inputContent = await readInput(cli.inputFile);
-    const outputContent = convert(inputContent, fromFormat, cli.normalize, cli, config, presets);
+    const outputContent = convert(inputContent, fromFormat, toFormat, cli, config, presets);
     if (cli.outputFile) {
         fs.writeFileSync(cli.outputFile, outputContent, "utf8");
     }

package/dist/conversionOptions.d.ts

@@ -40,9 +40,9 @@ export interface PresetNames {
  * per side, the first layer that sets the side or `preset` wins.
  * @param layers Preset names by layer, highest first.
  * @param from The input's format.
- * @param to The output's format; the input's for normalizing.
+ * @param to The output's format.
  * @returns The conversion's preset options.
  * @throws If a layer sets `preset` and another side preset, or a side
- * preset has no dialect for its side's format, or normalizing names two.
+ * preset has no dialect for its side's format.
  */
 export declare function resolvePresetOptions(layers: PresetNames[], from: Format, to: Format): PresetOptions;

package/dist/conversionOptions.js

@@ -60,13 +60,14 @@ function sidePreset(name, format, side) {
         ? resolveSide(undefined, preset, format, side)
         : resolveSide(preset, undefined, format, side);
 }
-// normalizing goes there and back within one dialect (ADR 0006), so
-// both sides must name the same preset, which then sets both ways
+// one preset on both sides of one format normalizes, going there and
+// back within its dialect, so it sets both ways of the trip; two
+// translate (ADR 0006)
 function normalizePresetOptions(layers) {
     const input = sideName(layers, "inputPreset")?.name ?? "vanilla";
     const output = sideName(layers, "outputPreset")?.name ?? "vanilla";
     if (input !== output) {
-        throw new Error(`normalize takes one preset; got inputPreset '${input}' and outputPreset '${output}'`);
+        return undefined;
     }
     const preset = createPreset(input);
     return preset ? { preset } : {};
@@ -76,15 +77,16 @@ function normalizePresetOptions(layers) {
  * per side, the first layer that sets the side or `preset` wins.
  * @param layers Preset names by layer, highest first.
  * @param from The input's format.
- * @param to The output's format; the input's for normalizing.
+ * @param to The output's format.
  * @returns The conversion's preset options.
  * @throws If a layer sets `preset` and another side preset, or a side
- * preset has no dialect for its side's format, or normalizing names two.
+ * preset has no dialect for its side's format.
  */
 export function resolvePresetOptions(layers, from, to) {
     layers.forEach(rejectConflict);
-    if (from === to) {
-        return normalizePresetOptions(layers);
+    const normalize = from === to ? normalizePresetOptions(layers) : undefined;
+    if (normalize) {
+        return normalize;
     }
     const input = sidePreset(sideName(layers, "inputPreset"), from, "input");
     const output = sidePreset(sideName(layers, "outputPreset"), to, "output");

package/dist/core/outsideCode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A Markdown string with its code, math, frontmatter and raw HTML
+ * blanked out (NUL characters, one per character), so a scan for syntax
+ * finds it outside them only, at the offsets it has in the string.
+ * @param markdown The Markdown string.
+ * @returns The masked string, as long as the input.
+ */
+export declare function maskCode(markdown: string): string;
+/**
+ * Maps a Markdown string's text, each stretch between code, math,
+ * frontmatter and raw HTML on its own, leaving those as written; a
+ * stretch ends where a table starts or ends too.
+ * @param markdown The Markdown string.
+ * @param map What a stretch of text becomes, told if it is in a table.
+ * @returns The mapped Markdown string.
+ */
+export declare function mapOutsideCode(markdown: string, map: (text: string, inTable: boolean) => string): string;

package/dist/core/outsideCode.js

@@ -0,0 +1,98 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMath from "remark-math";
+// what holds no Markdown text: code, math, frontmatter and raw HTML
+const VERBATIM = new Set([
+    "code",
+    "inlineCode",
+    "math",
+    "inlineMath",
+    "yaml",
+    "html"
+]);
+function verbatimRanges(node, ranges) {
+    if (VERBATIM.has(node.type)) {
+        ranges.push([
+            node.position?.start.offset ?? 0,
+            node.position?.end.offset ?? 0
+        ]);
+        return;
+    }
+    for (const child of node.children ?? []) {
+        verbatimRanges(child, ranges);
+    }
+}
+function parse(markdown) {
+    return unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkFrontmatter)
+        .use(remarkMath)
+        .parse(markdown);
+}
+function mask(markdown, tree) {
+    const ranges = [];
+    verbatimRanges(tree, ranges);
+    let masked = "";
+    let from = 0;
+    for (const [start, end] of ranges) {
+        masked += markdown.slice(from, start) + "\0".repeat(end - start);
+        from = end;
+    }
+    return masked + markdown.slice(from);
+}
+/**
+ * A Markdown string with its code, math, frontmatter and raw HTML
+ * blanked out (NUL characters, one per character), so a scan for syntax
+ * finds it outside them only, at the offsets it has in the string.
+ * @param markdown The Markdown string.
+ * @returns The masked string, as long as the input.
+ */
+export function maskCode(markdown) {
+    return mask(markdown, parse(markdown));
+}
+function tableRanges(node, ranges) {
+    if (node.type === "table") {
+        ranges.push([
+            node.position?.start.offset ?? 0,
+            node.position?.end.offset ?? 0
+        ]);
+        return;
+    }
+    for (const child of node.children ?? []) {
+        tableRanges(child, ranges);
+    }
+}
+/**
+ * Maps a Markdown string's text, each stretch between code, math,
+ * frontmatter and raw HTML on its own, leaving those as written; a
+ * stretch ends where a table starts or ends too.
+ * @param markdown The Markdown string.
+ * @param map What a stretch of text becomes, told if it is in a table.
+ * @returns The mapped Markdown string.
+ */
+export function mapOutsideCode(markdown, map) {
+    const tree = parse(markdown);
+    const tables = [];
+    tableRanges(tree, tables);
+    const bounds = tables.flat();
+    return [...mask(markdown, tree).matchAll(/\0+|[^\0]+/g)]
+        .map(({ 0: run, index }) => {
+        const end = index + run.length;
+        if (run.startsWith("\0")) {
+            return markdown.slice(index, end);
+        }
+        const cuts = [index, ...bounds.filter(b => b > index && b < end), end];
+        return cuts
+            .slice(1)
+            .map((to, i) => {
+            const from = cuts[i] ?? index;
+            const inTable = tables.some(([s, e]) => from >= s && from < e);
+            return map(markdown.slice(from, to), inTable);
+        })
+            .join("");
+    })
+        .join("");
+}

package/dist/core/restyle.d.ts

@@ -0,0 +1,9 @@
+import type { MarkdownStyleOptions } from "../options.js";
+/**
+ * Rewrites the markers a style names, and nothing else: the rest of the
+ * Markdown stays as written, where a stringifier would canonicalize it.
+ * @param markdown The Markdown string.
+ * @param style The markers to write.
+ * @returns The Markdown string with those markers.
+ */
+export declare function restyleMarkdown(markdown: string, style: MarkdownStyleOptions): string;

package/dist/core/restyle.js

@@ -0,0 +1,110 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMath from "remark-math";
+import { visit } from "unist-util-visit";
+function offsets(node) {
+    return [node.position?.start.offset ?? 0, node.position?.end.offset ?? 0];
+}
+function bulletEdits(tree, bullet) {
+    const edits = [];
+    visit(tree, "list", (list) => {
+        if (list.ordered) {
+            return;
+        }
+        for (const item of list.children) {
+            const [start] = offsets(item);
+            edits.push([start, start + 1, bullet]);
+        }
+    });
+    return edits;
+}
+// `_` closes no emphasis within a word
+function inWord(markdown, start, end) {
+    return /\w/.test(markdown[start - 1] ?? "") || /\w/.test(markdown[end] ?? "");
+}
+function delimiterEdits(tree, markdown, type, marker) {
+    const width = type === "strong" ? 2 : 1;
+    const edits = [];
+    visit(tree, type, (node) => {
+        const [start, end] = offsets(node);
+        if (markdown[start] === marker ||
+            (marker === "_" && inWord(markdown, start, end))) {
+            return;
+        }
+        const markers = marker.repeat(width);
+        edits.push([start, start + width, markers], [end - width, end, markers]);
+    });
+    return edits;
+}
+const FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+// a fenced block's opening and closing fence, unless its code holds a
+// run of the new marker, which could close it
+function fenceEdits(tree, markdown, fence) {
+    const edits = [];
+    visit(tree, "code", (node) => {
+        const [start, end] = offsets(node);
+        const source = markdown.slice(start, end);
+        const run = FENCE_RE.exec(source)?.[1];
+        if (!run || run[0] === fence || node.value.includes(fence.repeat(3))) {
+            return;
+        }
+        const markers = fence.repeat(run.length);
+        const open = start + source.indexOf(run);
+        edits.push([open, open + run.length, markers]);
+        // the closing fence may be longer, and missing at the document's end
+        const last = source.lastIndexOf("\n") + 1;
+        const closing = /^ *([`~]+) *$/.exec(source.slice(last));
+        if (last && closing?.[1]) {
+            const at = start + last + source.slice(last).indexOf(closing[1]);
+            edits.push([at, at + closing[1].length, fence.repeat(closing[1].length)]);
+        }
+    });
+    return edits;
+}
+// a thematic break, as long as it was unless the style says how long
+function ruleEdits(tree, markdown, { rule, ruleRepetition }) {
+    const edits = [];
+    visit(tree, "thematicBreak", (node) => {
+        const [start, end] = offsets(node);
+        const source = markdown.slice(start, end).trim();
+        const marker = rule ?? source[0] ?? "-";
+        const count = ruleRepetition ?? source.replace(/\s/g, "").length;
+        edits.push([start, end, marker.repeat(Math.max(3, count))]);
+    });
+    return edits;
+}
+/**
+ * Rewrites the markers a style names, and nothing else: the rest of the
+ * Markdown stays as written, where a stringifier would canonicalize it.
+ * @param markdown The Markdown string.
+ * @param style The markers to write.
+ * @returns The Markdown string with those markers.
+ */
+export function restyleMarkdown(markdown, style) {
+    const tree = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkFrontmatter)
+        .use(remarkMath)
+        .parse(markdown);
+    const edits = [
+        ...(style.bullet ? bulletEdits(tree, style.bullet) : []),
+        ...(style.emphasis
+            ? delimiterEdits(tree, markdown, "emphasis", style.emphasis)
+            : []),
+        ...(style.strong
+            ? delimiterEdits(tree, markdown, "strong", style.strong)
+            : []),
+        ...(style.fence ? fenceEdits(tree, markdown, style.fence) : []),
+        ...(style.rule || style.ruleRepetition
+            ? ruleEdits(tree, markdown, style)
+            : [])
+    ];
+    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 result;
+}

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export { convertMarkdownToOrg } from "./markdownToOrg.js";
 export { convertOrgToMarkdown } from "./orgToMarkdown.js";
 export { normalizeMarkdown, normalizeOrg } from "./normalize.js";
 export type { NormalizeOptions } from "./normalize.js";
+export { translateMarkdown, translateOrg } from "./translate.js";
+export type { TranslateOptions } from "./translate.js";
 export { parseConfig } from "./config.js";
 export type { MorgConfig } from "./config.js";
 export { transformMdastToUniorgAst } from "./core/mdastToUniorg/index.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export { convertMarkdownToOrg } from "./markdownToOrg.js";
 export { convertOrgToMarkdown } from "./orgToMarkdown.js";
 export { normalizeMarkdown, normalizeOrg } from "./normalize.js";
+export { translateMarkdown, translateOrg } from "./translate.js";
 export { parseConfig } from "./config.js";
 export { transformMdastToUniorgAst } from "./core/mdastToUniorg/index.js";
 export { transformUniorgAstToMdast } from "./core/uniorgToMdast/index.js";

package/dist/presets/links.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A labeled org fuzzy link in text (`[[Page][label]]`): the form a
+ * translation's page links pass through between two Markdown dialects
+ * (`MarkdownDialect.links`), as a conversion's pass through org.
+ */
+export declare const FUZZY_LINK_RE: RegExp;

package/dist/presets/links.js

@@ -0,0 +1,6 @@
+/**
+ * A labeled org fuzzy link in text (`[[Page][label]]`): the form a
+ * translation's page links pass through between two Markdown dialects
+ * (`MarkdownDialect.links`), as a conversion's pass through org.
+ */
+export const FUZZY_LINK_RE = /\[\[([^\][]+)\]\[([^\][]+)\]\]/g;