@remigius42/morg 0.7.0 → 0.9.0

package/README.md

@@ -17,8 +17,8 @@ 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 `heading::` properties and outline
-nesting, are supported via presets.
+[Logseq](https://docs.logseq.com/)'s outline of blocks and page
+properties, are supported via presets.
 
 ## Round-trip convergence
 
@@ -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"
@@ -198,28 +204,36 @@ preset })`: `preserveOrgisms` default `true`; `useHtml` (default
   `- [x]`); headings become list items and do not restore on the
   return trip; anything with priority, tags or content keeps its
   heading and reports via `onWarning`
-- `logseq({ nestUnderHeadings })`: default `true`; content following a
-  heading nests as child blocks of that heading: paragraphs become child
-  headlines one level deeper (in Logseq org every outline block is a
-  headline), other constructs stay in the preceding block's body. The
-  reverse direction restores headings from `:heading:` properties and
-  turns plain block headlines back into paragraphs. Hiccup blocks
-  (`[:div …]`) pass through as plain text and are emitted unescaped in
-  Markdown. Page properties map both directions: a first block of
+- `logseq()`: a page is Logseq's outline of blocks, converted block by
+  block: a headline (stars, a space, the block's content, an empty
+  block as the bare stars) ↔ a `-` bullet indented one tab per level,
+  its lines below the first two spaces further in. A block's content
+  is one fragment, so a code block or table that starts on the
+  headline line converts as a whole. `:heading: N` ↔ `- ## …`, a
+  block's property drawer ↔ `key:: value` lines; planning lines and
+  other drawers (`:LOGBOOK:`) stay as written. A heading outside the
+  bullets is a top-level block, as Logseq writes a page's first one.
+  Page properties map both directions: a first block of
   `key:: value` lines and flat frontmatter entries ↔ leading
   `#+key: value` lines, which Logseq reads as page properties;
   frontmatter keys that act in Emacs (`todo`, `include`, …) stay inert.
-  Logseq's own syntax maps both directions: `TODO`/`DONE`
-  text markers and `[#A]` priorities ↔ org keywords/priorities, page
+  Task markers and `[#A]` priorities stay text, page
   references `[[page]]` and labeled forms `[label]([[page]])` ↔ org
   fuzzy links `[[page][label]]`, block refs `[label](((uuid)))` ↔
   `[[((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).
@@ -245,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),
@@ -260,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/bracedScripts.d.ts

@@ -4,6 +4,13 @@ import type { OrgData } from "uniorg";
  * holds a bare underscore or caret org would read as a script.
  */
 export declare function requireBracedScripts(uniorgAst: OrgData): void;
+/**
+ * Whether org→md would consume a `^:{}` setting at the head of `org`:
+ * its text reads a script org would otherwise take for one.
+ * @param org The org text, the setting included.
+ * @returns Whether the setting is taken as the one md→org adds.
+ */
+export declare function consumesBracedScripts(org: string): boolean;
 /**
  * org→md: parses org, honoring its `^:` setting, and consuming `^:{}`
  * where the text needs it: md→org adds it only then, so anywhere else

package/dist/core/bracedScripts.js

@@ -135,6 +135,16 @@ function takeBracedScripts(uniorgAst) {
         return node.value !== "";
     });
 }
+/**
+ * Whether org→md would consume a `^:{}` setting at the head of `org`:
+ * its text reads a script org would otherwise take for one.
+ * @param org The org text, the setting included.
+ * @returns Whether the setting is taken as the one md→org adds.
+ */
+export function consumesBracedScripts(org) {
+    // text without a bare script candidate skips the parse
+    return (BARE_SCRIPT_RE.test(org) && readsBareScripts(bracedScriptsParser.parse(org)));
+}
 /**
  * org→md: parses org, honoring its `^:` setting, and consuming `^:{}`
  * where the text needs it: md→org adds it only then, so anywhere else

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,11 +1,24 @@
 import type { Parent } from "unist";
 import { type Node } from "./render.js";
+/**
+ * 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
  * space, or it would turn into a list item, headline, comment or table.
  */
 export declare function escapeLineSyntax(tree: Parent): void;
+/**
+ * Whether org reads a text as just one passthrough element.
+ * @param text The org text.
+ * @returns Whether it is one block, drawer, keyword … org→md writes as
+ * its org text.
+ */
+export declare function readsAsPassthrough(text: string): boolean;
 /**
  * md→org: whether a node is a paragraph org→md wrote as the org text of
  * one passthrough element, which goes back as it is.

package/dist/core/lineSyntax.js

@@ -9,8 +9,12 @@ 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 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;
     }
@@ -135,8 +139,16 @@ function isPassthrough(starts) {
     if (!first || !MAY_BE_LINE_SYNTAX_RE.test(first.line)) {
         return false;
     }
-    const lines = starts.map(({ line }) => line);
-    const [only, ...rest] = tryParse(`${lines.join("\n")}\n`)?.children ?? [];
+    return readsAsPassthrough(starts.map(({ line }) => line).join("\n"));
+}
+/**
+ * Whether org reads a text as just one passthrough element.
+ * @param text The org text.
+ * @returns Whether it is one block, drawer, keyword … org→md writes as
+ * its org text.
+ */
+export function readsAsPassthrough(text) {
+    const [only, ...rest] = tryParse(`${text}\n`)?.children ?? [];
     return !rest.length && PASSTHROUGH_TYPES.has(only?.type ?? "");
 }
 /**

package/dist/core/mdastToUniorg/blocks.js

@@ -125,8 +125,11 @@ export function transformMdastCode(node) {
             value: `${node.value}\n`
         };
     }
+    // the fence's meta is the block's switches and header arguments,
+    // which uniorg-stringify writes after the language
+    const language = [node.lang, node.meta].filter(Boolean).join(" ");
     return (node.lang
-        ? { type: "src-block", language: node.lang, value: node.value }
+        ? { type: "src-block", language, value: node.value }
         : {
             type: "example-block",
             value: node.value

package/dist/core/passthroughSource.d.ts

@@ -0,0 +1,21 @@
+import type { Root } from "mdast";
+/** Whether a line opens an org block (`#+begin_name`). */
+export declare function isOrgBlockStart(line: string): boolean;
+/** Whether a line opens an org drawer (`:NAME:`). */
+export declare function isDrawerStart(line: string): boolean;
+/**
+ * The line that ends the org block or drawer a line opens.
+ * @param lines The lines.
+ * @param start The index of the opening line.
+ * @returns The index of the `#+end_name` or `:END:` line, or -1.
+ */
+export declare function orgElementEnd(lines: string[], start: number): number;
+/**
+ * md→org: a passthrough element's org text may hold lines Markdown reads
+ * as syntax of its own (a blank line and an indented one, a `#`, `-`
+ * or `>` line); the top-level nodes it parsed into become one paragraph
+ * of the source text again, which goes back to org as it is.
+ * @param mdast The parsed Markdown.
+ * @param markdown Its source.
+ */
+export declare function keepPassthroughSource(mdast: Root, markdown: string): void;