@remigius42/morg 0.8.0 → 0.9.1

package/README.md

@@ -60,7 +60,10 @@ color schemes.
 Try morg without installing anything at
 [morg.binarypoetry.ch](https://morg.binarypoetry.ch). All conversion
 happens in your browser, nothing is uploaded (see [ADR
-0003](docs/adr/0003-client-side-web-ui-on-github-pages.md)). The
+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,
+and ⇄ swaps them. The
 chrome-less embed page (`/embed.html`, optionally with
 `?theme=dark|light`) can be iframed into other sites. It posts its
 content height to the host on every change, so the frame can follow it
@@ -121,6 +124,9 @@ echo "# Hello" | morg --from markdown
 # Apply a dialect preset
 morg --input page.md --output page.org --preset logseq
 
+# Or one per side: read Logseq org, write Vanilla Markdown (ADR 0006)
+morg --input page.org --output page.md --input-preset logseq
+
 # Dropped constructs are reported on stderr; -s / --silent suppresses.
 # Boolean flags take an optional value, so --silent false overrides a
 # morg.toml that sets it
@@ -141,7 +147,7 @@ morg normalize --input notes.org --output notes.org
 
 Options can live in a `morg.toml` (auto-discovered in the working
 directory, or passed via `--config path`). Precedence: CLI flags >
-config file > defaults:
+config file > defaults, per side for the presets:
 
 ```toml
 preset = "logseq"
@@ -217,10 +223,17 @@ 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
+- `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
+  side Vanilla whose format the preset has no dialect for (Obsidian
+  writes no org); a side preset without one throws, and so does
+  `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
-  form, a fixed point. Canonicalization, not styling: org-isms and
+  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).
@@ -246,8 +259,8 @@ Two pipelines, each with a two-phase transformation separating the
 dialect-agnostic core from dialect presets:
 
 ```text
-md → org:  remark-parse → mdast→uniorg (core) → preset transforms → uniorg-stringify
-org → md:  uniorg-parse → preset extraction → uniorg→mdast (core) → remark-stringify
+md → org:  remark-parse → mdast→uniorg (core) → read md dialect → write org dialect → uniorg-stringify
+org → md:  uniorg-parse → read org dialect → write md dialect → uniorg→mdast (core) → remark-stringify
 ```
 
 Formatting is controlled by shaping the AST (e.g. inserting newline text nodes),
@@ -261,7 +274,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`); the
+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
 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

@@ -7,6 +7,8 @@ export interface CliArgs {
     inputFile: string | undefined;
     outputFile: string | undefined;
     presetName: string | undefined;
+    inputPresetName: string | undefined;
+    outputPresetName: string | undefined;
     silent: boolean | undefined;
     taskCheckboxes: boolean | undefined;
     interpretHtml: boolean | undefined;

package/dist/cli/args.js

@@ -16,6 +16,8 @@ export function parseArgs(args) {
         inputFile: undefined,
         outputFile: undefined,
         presetName: undefined,
+        inputPresetName: undefined,
+        outputPresetName: undefined,
         silent: undefined,
         taskCheckboxes: undefined,
         interpretHtml: undefined,

package/dist/cli/conversion.d.ts

@@ -1,11 +1,11 @@
 import type { MorgConfig } from "../config.js";
 import type { MarkdownStyleOptions } from "../options.js";
-import type { Preset } from "../presets/types.js";
+import type { PresetOptions } from "../presets/sides.js";
 import type { CliArgs } from "./args.js";
-export declare function buildConversionOptions(cli: CliArgs, config: MorgConfig, preset: Preset | undefined): {
+export declare function buildConversionOptions(cli: CliArgs, config: MorgConfig, presets: PresetOptions): {
     mdToOrgOptions: import("../options.js").MarkdownToOrgOptions;
     orgToMdOptions: import("../options.js").OrgToMarkdownOptions & {
         markdownStyle: MarkdownStyleOptions;
     };
 };
-export declare function convert(inputContent: string, fromFormat: string, normalize: boolean, cli: CliArgs, config: MorgConfig, preset: Preset | undefined): string;
+export declare function convert(inputContent: string, fromFormat: string, normalize: boolean, cli: CliArgs, config: MorgConfig, presets: PresetOptions): string;

package/dist/cli/conversion.js

@@ -3,7 +3,7 @@ import { convertOrgToMarkdown } from "../orgToMarkdown.js";
 import { normalizeMarkdown, normalizeOrg } from "../normalize.js";
 import { buildConversionOptions as layerOptions } from "../conversionOptions.js";
 import { CliError } from "./error.js";
-export function buildConversionOptions(cli, config, preset) {
+export function buildConversionOptions(cli, config, presets) {
     // an explicit --silent wins over the config; dropped constructs are
     // reported on stderr unless it ends up on
     const silent = cli.silent ?? config.silent ?? false;
@@ -23,14 +23,14 @@ export function buildConversionOptions(cli, config, preset) {
         recordStyle: cli.recordStyle,
         markdownStyle
     }, config, {
-        preset,
+        ...presets,
         onWarning,
         ...(config.orgismKeys && { orgismKeys: config.orgismKeys })
     });
 }
-export function convert(inputContent, fromFormat, normalize, cli, config, preset) {
+export function convert(inputContent, fromFormat, normalize, cli, config, presets) {
     try {
-        const { mdToOrgOptions, orgToMdOptions } = buildConversionOptions(cli, config, preset);
+        const { mdToOrgOptions, orgToMdOptions } = buildConversionOptions(cli, config, presets);
         if (normalize) {
             return fromFormat === "markdown"
                 ? normalizeMarkdown(inputContent, {

package/dist/cli/flags.d.ts

@@ -1,4 +1,4 @@
-type StringOption = "fromFormat" | "toFormat" | "inputFile" | "outputFile" | "presetName" | "configPath";
+type StringOption = "fromFormat" | "toFormat" | "inputFile" | "outputFile" | "presetName" | "inputPresetName" | "outputPresetName" | "configPath";
 type BooleanOption = "silent" | "taskCheckboxes" | "interpretHtml" | "recordStyle";
 type InfoOption = "help" | "version";
 export type FlagSpec = ({

package/dist/cli/flags.js

@@ -34,10 +34,24 @@ export const FLAGS = [
     {
         names: ["--preset"],
         arg: "<name>",
-        description: "Apply an editor preset, for example logseq",
+        description: "Read and write an editor's dialect, for example logseq",
         kind: "string",
         key: "presetName"
     },
+    {
+        names: ["--input-preset"],
+        arg: "<name>",
+        description: "Read the input in a preset's dialect",
+        kind: "string",
+        key: "inputPresetName"
+    },
+    {
+        names: ["--output-preset"],
+        arg: "<name>",
+        description: "Write the output in a preset's dialect",
+        kind: "string",
+        key: "outputPresetName"
+    },
     {
         names: ["--config"],
         arg: "<file>",

package/dist/cli/formats.d.ts

@@ -1,3 +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): asserts fromFormat is string;
+export declare function validateFormats(fromFormat: string | undefined, toFormat: string | undefined, normalize: boolean): [fromFormat: Format, toFormat: Format];

package/dist/cli/formats.js

@@ -57,4 +57,5 @@ export function validateFormats(fromFormat, toFormat, normalize) {
         throw new CliError("Error: normalize reads and writes the same format; " +
             `got '${fromFormat}' and '${toFormat}'.`);
     }
+    return [fromFormat, toFormat];
 }

package/dist/cli/presets.d.ts

@@ -1,2 +1,13 @@
-import type { Preset } from "../presets/types.js";
-export declare function resolvePreset(presetName: string | undefined): Preset | undefined;
+import type { MorgConfig } from "../config.js";
+import type { PresetOptions } from "../presets/sides.js";
+import type { CliArgs } from "./args.js";
+/**
+ * Resolves the presets per side, flags over the config (ADR 0006).
+ * @param cli The parsed arguments.
+ * @param config The parsed `morg.toml`.
+ * @param from The input's format.
+ * @param to The output's format.
+ * @returns The conversion's preset options.
+ * @throws {CliError} If the names conflict, are unknown or lack a dialect.
+ */
+export declare function resolvePresets(cli: CliArgs, config: MorgConfig, from: "markdown" | "org", to: "markdown" | "org"): PresetOptions;

package/dist/cli/presets.js

@@ -1,8 +1,22 @@
-import { createPreset } from "../presets/registry.js";
+import { resolvePresetOptions } from "../conversionOptions.js";
 import { CliError } from "./error.js";
-export function resolvePreset(presetName) {
+/**
+ * Resolves the presets per side, flags over the config (ADR 0006).
+ * @param cli The parsed arguments.
+ * @param config The parsed `morg.toml`.
+ * @param from The input's format.
+ * @param to The output's format.
+ * @returns The conversion's preset options.
+ * @throws {CliError} If the names conflict, are unknown or lack a dialect.
+ */
+export function resolvePresets(cli, config, from, to) {
+    const flags = {
+        ...(cli.presetName && { preset: cli.presetName }),
+        ...(cli.inputPresetName && { inputPreset: cli.inputPresetName }),
+        ...(cli.outputPresetName && { outputPreset: cli.outputPresetName })
+    };
     try {
-        return createPreset(presetName);
+        return resolvePresetOptions([flags, config], from, to);
     }
     catch (error) {
         throw new CliError(`Error: ${error.message}`);

package/dist/cli.js

@@ -2,7 +2,7 @@
 import * as fs from "node:fs";
 import { parseArgs } from "./cli/args.js";
 import { loadConfig } from "./cli/configFile.js";
-import { resolvePreset } from "./cli/presets.js";
+import { resolvePresets } from "./cli/presets.js";
 import { inferFormats, validateFormats } from "./cli/formats.js";
 import { convert } from "./cli/conversion.js";
 import { CliError } from "./cli/error.js";
@@ -46,11 +46,10 @@ async function main() {
         return;
     }
     const config = loadConfig(cli.configPath);
-    const preset = resolvePreset(cli.presetName ?? config.preset);
-    const [fromFormat, toFormat] = inferFormats(cli);
-    validateFormats(fromFormat, toFormat, cli.normalize);
+    const [fromFormat, toFormat] = validateFormats(...inferFormats(cli), cli.normalize);
+    const presets = resolvePresets(cli, config, fromFormat, toFormat);
     const inputContent = await readInput(cli.inputFile);
-    const outputContent = convert(inputContent, fromFormat, cli.normalize, cli, config, preset);
+    const outputContent = convert(inputContent, fromFormat, cli.normalize, cli, config, presets);
     if (cli.outputFile) {
         fs.writeFileSync(cli.outputFile, outputContent, "utf8");
     }

package/dist/config.d.ts

@@ -1,15 +1,19 @@
 import type { MarkdownToOrgOptions, OrgToMarkdownOptions } from "./options.js";
+type PresetKey = "preset" | "inputPreset" | "outputPreset";
 /**
  * Shape of `morg.toml`. Sections mirror the library options objects;
- * `preset` and `silent` mirror their CLI flags; `orgismKeys` is shared
- * by both directions. Precedence: CLI > config > defaults.
+ * `preset`, `inputPreset`, `outputPreset` and `silent` mirror their CLI
+ * flags; `orgismKeys` is shared by both directions. Precedence: CLI >
+ * config > defaults, per side for the presets.
  */
 export interface MorgConfig {
     preset?: string;
+    inputPreset?: string;
+    outputPreset?: string;
     silent?: boolean;
     orgismKeys?: Record<string, string>;
-    markdownToOrg?: Omit<MarkdownToOrgOptions, "preset" | "onWarning">;
-    orgToMarkdown?: Omit<OrgToMarkdownOptions, "preset" | "onWarning" | "orgismKeys">;
+    markdownToOrg?: Omit<MarkdownToOrgOptions, PresetKey | "onWarning">;
+    orgToMarkdown?: Omit<OrgToMarkdownOptions, PresetKey | "onWarning" | "orgismKeys">;
 }
 /**
  * Parses a `morg.toml` source string. Unknown top-level keys are
@@ -18,3 +22,4 @@ export interface MorgConfig {
  * @returns The parsed configuration.
  */
 export declare function parseConfig(source: string): MorgConfig;
+export {};

package/dist/config.js

@@ -1,6 +1,8 @@
 import { parse as parseToml } from "smol-toml";
 const KNOWN_KEYS = new Set([
     "preset",
+    "inputPreset",
+    "outputPreset",
     "silent",
     "orgismKeys",
     "markdownToOrg",

package/dist/conversionOptions.d.ts

@@ -1,6 +1,6 @@
 import type { MorgConfig } from "./config.js";
 import type { MarkdownStyleOptions, MarkdownToOrgOptions, OrgToMarkdownOptions, Toggle } from "./options.js";
-import type { Preset } from "./presets/types.js";
+import { type Format, type PresetOptions } from "./presets/sides.js";
 /** Explicitly requested option values; `undefined` leaves it to config. */
 export interface ConversionOverrides {
     taskCheckboxes?: boolean;
@@ -10,8 +10,7 @@ export interface ConversionOverrides {
     markdownStyle?: MarkdownStyleOptions;
 }
 /** Values that apply to both directions. */
-export interface SharedConversionOptions {
-    preset?: Preset;
+export interface SharedConversionOptions extends PresetOptions {
     onWarning?: (message: string) => void;
     orgismKeys?: Record<string, string>;
 }
@@ -30,3 +29,20 @@ export declare function buildConversionOptions(overrides: ConversionOverrides, c
         markdownStyle: MarkdownStyleOptions;
     };
 };
+/** Preset names as one layer (CLI, form or config) sets them. */
+export interface PresetNames {
+    preset?: string;
+    inputPreset?: string;
+    outputPreset?: string;
+}
+/**
+ * Resolves the presets of a conversion over layers of names (ADR 0006):
+ * 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.
+ * @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.
+ */
+export declare function resolvePresetOptions(layers: PresetNames[], from: Format, to: Format): PresetOptions;

package/dist/conversionOptions.js

@@ -1,3 +1,5 @@
+import { resolveSide } from "./presets/sides.js";
+import { createPreset } from "./presets/registry.js";
 /**
  * Layers explicit overrides over the config file, per direction. Used by
  * both adapters (CLI and Web UI) so the documented precedence (CLI or
@@ -32,3 +34,62 @@ export function buildConversionOptions(overrides, config, shared) {
     };
     return { mdToOrgOptions, orgToMdOptions };
 }
+function sideName(layers, key) {
+    for (const layer of layers) {
+        if (layer[key]) {
+            return { name: layer[key], shorthand: false };
+        }
+        if (layer.preset) {
+            return { name: layer.preset, shorthand: true };
+        }
+    }
+    return undefined;
+}
+// across layers the higher one wins; within one, two names conflict
+function rejectConflict(layer) {
+    for (const key of ["inputPreset", "outputPreset"]) {
+        const side = layer[key];
+        if (layer.preset && side && side !== layer.preset) {
+            throw new Error(`preset '${layer.preset}' conflicts with ${key} '${side}'`);
+        }
+    }
+}
+function sidePreset(name, format, side) {
+    const preset = createPreset(name?.name);
+    return name?.shorthand
+        ? 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
+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}'`);
+    }
+    const preset = createPreset(input);
+    return preset ? { preset } : {};
+}
+/**
+ * Resolves the presets of a conversion over layers of names (ADR 0006):
+ * 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.
+ * @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.
+ */
+export function resolvePresetOptions(layers, from, to) {
+    layers.forEach(rejectConflict);
+    if (from === to) {
+        return normalizePresetOptions(layers);
+    }
+    const input = sidePreset(sideName(layers, "inputPreset"), from, "input");
+    const output = sidePreset(sideName(layers, "outputPreset"), to, "output");
+    return {
+        ...(input && { inputPreset: input }),
+        ...(output && { outputPreset: output })
+    };
+}

package/dist/core/frontmatterBlock.d.ts

@@ -1,5 +1,6 @@
 import type { OrgData } from "uniorg";
 import { type Scalar } from "yaml";
+export declare const FRONTMATTER_BLOCK_BEGIN = "#+begin_comment morg_frontmatter";
 export interface FrontmatterNode {
     type: "morg-frontmatter";
     yaml: string;
@@ -15,6 +16,12 @@ export declare function isFrontmatterNode(node: {
  * @param uniorgAst The document.
  */
 export declare function renderFileHeader(uniorgAst: OrgData): void;
+/**
+ * The Frontmatter Block carrying YAML through org (ADR 0005).
+ * @param yaml The YAML source, without its `---` fences.
+ * @returns The block's org text.
+ */
+export declare function frontmatterBlock(yaml: string): string;
 /**
  * md→org: takes the top-level entries `take` maps to keywords out of
  * the frontmatter; the rest stays verbatim, comments included.

package/dist/core/frontmatterBlock.js

@@ -4,7 +4,7 @@ import { CST, isMap, isScalar, isSeq, Lexer, parseDocument, visit } from "yaml";
 // frontmatter travels verbatim in a comment block marked as morg's
 // (ADR 0005); uniorg keeps neither the block's parameter nor its
 // unescaped value, so the block is rendered as raw text
-const FRONTMATTER_BLOCK_BEGIN = "#+begin_comment morg_frontmatter";
+export const FRONTMATTER_BLOCK_BEGIN = "#+begin_comment morg_frontmatter";
 export function isFrontmatterNode(node) {
     return node.type === "morg-frontmatter";
 }
@@ -51,7 +51,12 @@ function detachLeadingKeywords(uniorgAst) {
         }
     }
 }
-function frontmatterBlock(yaml) {
+/**
+ * The Frontmatter Block carrying YAML through org (ADR 0005).
+ * @param yaml The YAML source, without its `---` fences.
+ * @returns The block's org text.
+ */
+export function frontmatterBlock(yaml) {
     const body = yaml ? `${escapeBlockLines(yaml)}\n` : "";
     return `${FRONTMATTER_BLOCK_BEGIN}\n${body}#+end_comment\n`;
 }

package/dist/core/lineSyntax.d.ts

@@ -1,5 +1,18 @@
 import type { Parent } from "unist";
 import { type Node } from "./render.js";
+/**
+ * Whether a line, indented or not, may start org line syntax: false
+ * where org surely reads it as text.
+ * @param line The line, without its line break.
+ * @returns Whether it may start an element other than a paragraph.
+ */
+export declare function mayBeLineSyntax(line: string): boolean;
+/**
+ * Whether org reads a line as anything but a plain paragraph.
+ * @param line The line, without its line break.
+ * @returns Whether it reads as org line syntax.
+ */
+export declare function readsAsLineSyntax(line: string): boolean;
 /**
  * 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

package/dist/core/lineSyntax.js

@@ -9,8 +9,21 @@ import { delimiters, isInline, locate, positionParser, renderInline, tryParse }
 // `:` (`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) {
+/**
+ * Whether a line, indented or not, may start org line syntax: false
+ * where org surely reads it as text.
+ * @param line The line, without its line break.
+ * @returns Whether it may start an element other than a paragraph.
+ */
+export function mayBeLineSyntax(line) {
+    return MAY_BE_LINE_SYNTAX_RE.test(line.trimStart());
+}
+/**
+ * Whether org reads a line as anything but a plain paragraph.
+ * @param line The line, without its line break.
+ * @returns Whether it reads as org line syntax.
+ */
+export function readsAsLineSyntax(line) {
     if (!MAY_BE_LINE_SYNTAX_RE.test(line)) {
         return false;
     }

package/dist/core/mdastToUniorg/blocks.js

@@ -43,15 +43,29 @@ function transformMdastTableRow(ctx, row) {
         }))
     };
 }
+// lines without the indentation all non-blank ones share
+function dedentLines(text) {
+    const lines = text.split("\n");
+    const indent = Math.min(...lines
+        .filter(line => line.trim())
+        .map(line => /^[ \t]*/.exec(line)?.[0].length ?? 0));
+    return Number.isFinite(indent)
+        ? lines.map(line => line.slice(indent)).join("\n")
+        : text;
+}
 export function transformMdastHtml(ctx, node) {
     // html comments are markdown's comment idiom and map natively to
     // org comments (not an md-ism)
     const comment = /^<!--([\s\S]*?)-->\s*$/.exec(node.value);
     if (comment) {
+        const body = comment[1] ?? "";
+        // a multi-line comment's own line breaks frame its lines, so an
+        // empty first or last line is the comment's, not padding
+        const lines = /^[ \t]*\n([\s\S]*)\n[ \t]*$/.exec(body);
         return {
             type: "comment",
             // inverse of the escaping applied when the comment was emitted
-            value: (comment[1] ?? "").trim().replaceAll("--&gt;", "-->")
+            value: (lines ? dedentLines(lines[1] ?? "") : body.trim()).replaceAll("--&gt;", "-->")
         };
     }
     if (ctx.options.interpretHtml) {

package/dist/index.d.ts

@@ -8,5 +8,5 @@ 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 { FragmentConverter, Preset } from "./presets/types.js";
+export type { ConversionContext, FragmentConverter, MarkdownDialect, OrgDialect, Preset } from "./presets/types.js";
 export type { Toggle, MarkdownToOrgOptions, OrgToMarkdownOptions, MarkdownStyleOptions } from "./options.js";

package/dist/markdownToOrg.js

@@ -15,6 +15,8 @@ import { escapeBackslashCommands } from "./core/backslashCommands.js";
 import { escapeTablePipes } from "./core/tablePipes.js";
 import { requireBracedScripts } from "./core/bracedScripts.js";
 import { keepPassthroughSource } from "./core/passthroughSource.js";
+import { conversionContext, fragmentSides, readMarkdownWriteOrg, takeOver } from "./presets/hooks.js";
+import { resolveSides } from "./presets/sides.js";
 import { keyValueEntries } from "./core/keyValueLines.js";
 /**
  * Converts a Markdown string to an Org-mode string.
@@ -23,19 +25,18 @@ import { keyValueEntries } from "./core/keyValueLines.js";
  * @returns The converted Org-mode string.
  */
 export function convertMarkdownToOrg(markdown, options = {}) {
-    const convertMarkdown = options.preset?.convertMarkdown;
-    return convertMarkdown
+    return convertMarkdownSides(markdown, options, resolveSides(options, "markdown", "org"));
+}
+function convertMarkdownSides(markdown, options, sides) {
+    const over = takeOver(sides, "convertMarkdown");
+    return over
         ? // a fragment's style is the preset's, not one to record
-            convertMarkdown(markdown, (fragment, preset) => convertMarkdownToOrg(fragment, {
-                ...options,
-                preset,
-                recordStyle: false
-            }))
-        : convertMarkdownDocument(markdown, options);
+            over.preset.convertMarkdown(markdown, (fragment, preset, carried) => convertMarkdownSides(fragment, { ...options, recordStyle: false }, fragmentSides(sides, over.side, preset, carried)), conversionContext(over, options))
+        : convertMarkdownDocument(markdown, options, sides);
 }
-function convertMarkdownDocument(markdown, options) {
+function convertMarkdownDocument(markdown, options, sides) {
     // Phase 1: Parse Markdown to mdast
-    const mdast = parseMarkdown(markdown, options.preset);
+    const mdast = parseMarkdown(markdown, sides.input);
     // Phase 2: Generic mdast to uniorg-ast transformation
     let uniorgAst = transformMdastToUniorgDraft(mdast, {
         ...(options.preserveMdisms !== undefined && {
@@ -63,10 +64,9 @@ function convertMarkdownDocument(markdown, options) {
     if (options.recordStyle) {
         recordStyleKeyword(uniorgAst, detectMarkdownStyle(mdast, markdown, options.onWarning));
     }
-    // Phase 3: Apply dialect preset, if any
-    if (options.preset?.applyToUniorg) {
-        uniorgAst = options.preset.applyToUniorg(uniorgAst);
-    }
+    // Phase 3: Apply dialect preset, if any: read the md dialect, then
+    // write the org dialect
+    uniorgAst = readMarkdownWriteOrg(uniorgAst, sides);
     // Phase 3b: literal footnote references, paragraph lines org would
     // read as line syntax, literal markers org would read as markup, and
     // markup touching a word character, need a zero-width space escape;
@@ -87,10 +87,28 @@ function convertMarkdownDocument(markdown, options) {
     // a marked comment block; raw text, past every pass that rewrites text
     renderFileHeader(uniorgAst);
     // Phase 4: Render uniorg-ast to Org-mode string
-    const processor = unified().use(uniorgStringify);
-    const orgContent = processor.stringify(uniorgAst);
-    return orgContent;
+    const orgContent = String(stringifier.stringify(uniorgAst));
+    return orgContent.replaceAll(SPACE_KEEPER, "");
+}
+// uniorg-stringify trims a headline's line, and the document's end, but
+// Emacs reads stars without a space after them as text; the space ends
+// in a character no trim takes, removed after. null leaves the rest to
+// uniorg-stringify
+const SPACE_KEEPER = "\u0000";
+function emptyHeadline(node) {
+    const empty = !node.children.length &&
+        !node.todoKeyword &&
+        !node.priority &&
+        !node.commented &&
+        !node.tags.length;
+    return empty ? `${"*".repeat(node.level)} ${SPACE_KEEPER}\n` : null;
 }
+// built once: a preset converts a page block by block
+const stringifier = unified()
+    .use(uniorgStringify, {
+    handlers: { headline: emptyHeadline }
+})
+    .freeze();
 // a preset's dialect conventions that need the Markdown source apply
 // to the parse, before the generic transform
 function parseMarkdown(markdown, preset) {
@@ -101,7 +119,7 @@ function parseMarkdown(markdown, preset) {
         .use(remarkMath)
         .parse(markdown);
     keepPassthroughSource(mdast, markdown);
-    preset?.applyToMdast?.(mdast, markdown);
+    preset?.markdown?.read?.mdast?.(mdast, markdown);
     return mdast;
 }
 // leads the document, ahead of restored keywords and the frontmatter block