@remigius42/morg 0.7.0 → 0.9.0

package/dist/core/passthroughSource.js

@@ -0,0 +1,94 @@
+import { readsAsPassthrough } from "./lineSyntax.js";
+// the first line of an org block or drawer
+const BLOCK_START_RE = /^#\+begin_(\S+)/i;
+const DRAWER_START_RE = /^:[\w-]+:$/;
+/** Whether a line opens an org block (`#+begin_name`). */
+export function isOrgBlockStart(line) {
+    return BLOCK_START_RE.test(line);
+}
+/** Whether a line opens an org drawer (`:NAME:`). */
+export function isDrawerStart(line) {
+    return DRAWER_START_RE.test(line);
+}
+/**
+ * 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 function orgElementEnd(lines, start) {
+    const end = endPattern(lines[start] ?? "");
+    return end ? lines.findIndex((other, i) => i > start && end.test(other)) : -1;
+}
+// the pattern of the line that ends the block or drawer `line` opens
+function endPattern(line) {
+    const block = BLOCK_START_RE.exec(line)?.[1];
+    if (block) {
+        return new RegExp(`^#\\+end_${block.replace(/\W/g, "\\$&")}\\s*$`, "i");
+    }
+    return DRAWER_START_RE.test(line) ? /^:end:\s*$/i : null;
+}
+// the text from `offset` through the line that ends the block or
+// drawer opening there, read line by line rather than splitting the
+// rest of the document (a page may hold thousands of drawers)
+function elementSource(markdown, offset) {
+    const lineEnd = (from) => {
+        const index = markdown.indexOf("\n", from);
+        return index === -1 ? markdown.length : index;
+    };
+    let end = lineEnd(offset);
+    const pattern = endPattern(markdown.slice(offset, end));
+    while (pattern && end < markdown.length) {
+        const next = lineEnd(end + 1);
+        if (pattern.test(markdown.slice(end + 1, next))) {
+            return markdown.slice(offset, next);
+        }
+        end = next;
+    }
+    return null;
+}
+// the source offset where the passthrough element starting at a node
+// ends, or -1
+function passthroughEnd(node, markdown) {
+    const start = node.position?.start;
+    if (start?.column !== 1 || start.offset === undefined) {
+        return -1;
+    }
+    const source = elementSource(markdown, start.offset);
+    return source !== null && readsAsPassthrough(source)
+        ? start.offset + source.length
+        : -1;
+}
+// the index of the last node ending at `end`, from `i` on, or -1
+function lastNodeAt(nodes, i, end) {
+    let j = i;
+    while ((nodes[j]?.position?.end.offset ?? end) < end) {
+        j++;
+    }
+    return nodes[j]?.position?.end.offset === end ? j : -1;
+}
+/**
+ * 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 function keepPassthroughSource(mdast, markdown) {
+    const children = [];
+    const nodes = mdast.children;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const end = passthroughEnd(node, markdown);
+        const last = end === -1 ? -1 : lastNodeAt(nodes, i, end);
+        if (last === -1) {
+            children.push(node);
+            continue;
+        }
+        const value = markdown.slice(node.position?.start.offset, end);
+        children.push({ type: "paragraph", children: [{ type: "text", value }] });
+        i = last;
+    }
+    mdast.children = children;
+}

package/dist/core/uniorgToMdast/elements.js

@@ -253,9 +253,14 @@ function transformQuoteBlock(ctx, node) {
     };
 }
 function transformSrcBlock(node) {
+    // switches and header arguments (`-n :results output`) are the
+    // fence's meta, after the language
+    const { switches, parameters } = node;
+    const meta = [switches, parameters].filter(Boolean).join(" ");
     return {
         type: "code",
         lang: node.language || null,
+        meta: node.language && meta ? meta : null,
         value: trimTrailingNewline(node.value)
     };
 }

package/dist/core/uniorgToMdast/shared.js

@@ -24,7 +24,12 @@ export function keyValueParagraph(lines) {
 // trailing newline), for verbatim passthrough of org-only constructs
 export function orgNodeToText(node) {
     const orgText = unified()
-        .use(uniorgStringify)
+        // a preset's verbatim-inline text is org text already
+        .use(uniorgStringify, {
+        handlers: {
+            "verbatim-inline": (inline) => inline.value
+        }
+    })
         .stringify({
         type: "org-data",
         children: [node],

package/dist/index.d.ts

@@ -8,6 +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 { Preset } from "./presets/types.js";
-export type { LogseqPresetOptions } from "./presets/logseq.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

@@ -14,6 +14,9 @@ import { escapeFootnoteReferences } from "./core/footnoteReferences.js";
 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.
@@ -22,8 +25,18 @@ import { keyValueEntries } from "./core/keyValueLines.js";
  * @returns The converted Org-mode string.
  */
 export function convertMarkdownToOrg(markdown, options = {}) {
+    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
+            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, 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 && {
@@ -51,10 +64,9 @@ export function convertMarkdownToOrg(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;
@@ -88,7 +100,8 @@ function parseMarkdown(markdown, preset) {
         .use(remarkFrontmatter)
         .use(remarkMath)
         .parse(markdown);
-    preset?.applyToMdast?.(mdast, markdown);
+    keepPassthroughSource(mdast, markdown);
+    preset?.markdown?.read?.mdast?.(mdast, markdown);
     return mdast;
 }
 // leads the document, ahead of restored keywords and the frontmatter block

package/dist/normalize.js

@@ -10,7 +10,8 @@ import { convertOrgToMarkdown } from "./orgToMarkdown.js";
  * @returns The canonical-form Markdown string.
  */
 export function normalizeMarkdown(markdown, options = {}) {
-    return convertOrgToMarkdown(convertMarkdownToOrg(markdown, options), options);
+    const single = onePreset(options);
+    return convertOrgToMarkdown(convertMarkdownToOrg(markdown, single), single);
 }
 /**
  * Normalizes an Org string to morg's canonical form: one full round trip
@@ -20,5 +21,18 @@ export function normalizeMarkdown(markdown, options = {}) {
  * @returns The canonical-form Org string.
  */
 export function normalizeOrg(org, options = {}) {
-    return convertMarkdownToOrg(convertOrgToMarkdown(org, options), options);
+    const single = onePreset(options);
+    return convertMarkdownToOrg(convertOrgToMarkdown(org, single), single);
+}
+// normalizing canonicalizes within one dialect (ADR 0006), so both
+// sides name the same preset, which then sets both ways of the trip
+function onePreset(options) {
+    const { preset, inputPreset, outputPreset, ...rest } = options;
+    const input = inputPreset ?? preset;
+    const output = outputPreset ?? preset;
+    if (input?.name !== output?.name) {
+        const name = (key, side) => `${key} '${side?.name ?? "vanilla"}'`;
+        throw new Error(`normalize takes one preset; got ${name("inputPreset", input)} and ${name("outputPreset", output)}`);
+    }
+    return input ? { ...rest, preset: input } : rest;
 }

package/dist/options.d.ts

@@ -1,4 +1,4 @@
-import type { Preset } from "./presets/types.js";
+import type { PresetOptions } from "./presets/sides.js";
 /**
  * A feature toggle: `true`/`false` switches everything on/off, a record
  * toggles individual constructs by name. Unlisted keys fall back to the
@@ -6,7 +6,7 @@ import type { Preset } from "./presets/types.js";
  */
 export type Toggle = boolean | Record<string, boolean>;
 export declare function toggleEnabled(toggle: Toggle | undefined, key: string, defaultValue?: boolean): boolean;
-export interface MarkdownToOrgOptions {
+export interface MarkdownToOrgOptions extends PresetOptions {
     /**
      * Preserve Markdown constructs without a native Org equivalent (e.g.
      * raw HTML as export blocks/snippets, see ADR 0002). Default: `true`.
@@ -38,8 +38,6 @@ export interface MarkdownToOrgOptions {
     orgismKeys?: Record<string, string>;
     /** Called for each construct dropped without an equivalent. */
     onWarning?: (message: string) => void;
-    /** Dialect preset applied on top of the generic conversion. */
-    preset?: Preset;
 }
 /**
  * Markdown stringifier style knobs (subset of remark-stringify options).
@@ -67,7 +65,7 @@ export interface MarkdownStyleOptions {
      */
     ruleRepetition?: number;
 }
-export interface OrgToMarkdownOptions {
+export interface OrgToMarkdownOptions extends PresetOptions {
     /**
      * Serialize Org constructs without a native Markdown equivalent as
      * `key:: value` lines and verbatim passthroughs (see ADR 0002).
@@ -97,6 +95,4 @@ export interface OrgToMarkdownOptions {
     orgismKeys?: Record<string, string>;
     /** Called for each construct dropped without an equivalent. */
     onWarning?: (message: string) => void;
-    /** Dialect preset extracted before the generic conversion. */
-    preset?: Preset;
 }

package/dist/orgToMarkdown.js

@@ -13,6 +13,8 @@ import { unescapeBackslashCommands } from "./core/backslashCommands.js";
 import { unescapeTablePipes } from "./core/tablePipes.js";
 import { parseOrg } from "./core/bracedScripts.js";
 import { dropUnderscoreBulletGuards, guardUnderscoreBullets } from "./core/underscoreBullets.js";
+import { conversionContext, fragmentSides, readOrgWriteMarkdown, takeOver } from "./presets/hooks.js";
+import { resolveSides } from "./presets/sides.js";
 // a list item's paragraph after its nested list needs a blank line, or
 // md reads it as a lazy continuation of the nested list's last item
 function separateTextAfterNestedList(left, right, parent) {
@@ -29,6 +31,15 @@ function separateTextAfterNestedList(left, right, parent) {
  * @returns The converted Markdown string.
  */
 export function convertOrgToMarkdown(org, options = {}) {
+    return convertOrgSides(org, options, resolveSides(options, "org", "markdown"));
+}
+function convertOrgSides(org, options, sides) {
+    const over = takeOver(sides, "convertOrg");
+    return over
+        ? over.preset.convertOrg(org, (fragment, preset, carried) => convertOrgSides(fragment, options, fragmentSides(sides, over.side, preset, carried)), conversionContext(over, options))
+        : convertOrgDocument(org, options, sides);
+}
+function convertOrgDocument(org, options, sides) {
     // Phase 1: Parse Org-mode to uniorg-ast
     // md text has no scripts, so ^:{} is implied there and consumed here
     // (see markdownToOrg); uniorg misreads `_.` lines (see underscoreBullets)
@@ -47,10 +58,9 @@ export function convertOrgToMarkdown(org, options = {}) {
     unescapeFootnoteReferences(uniorgAst);
     unescapeBackslashCommands(uniorgAst);
     unescapeTablePipes(uniorgAst);
-    // Phase 2: Extract dialect preset conventions, if any
-    if (options.preset?.extractFromUniorg) {
-        uniorgAst = options.preset.extractFromUniorg(uniorgAst);
-    }
+    // Phase 2: Extract dialect preset conventions, if any: read the org
+    // dialect, then write the md dialect
+    uniorgAst = readOrgWriteMarkdown(uniorgAst, sides);
     // Phase 3: Generic uniorg-ast to mdast transformation
     const mdast = transformUniorgAstToMdast(uniorgAst, {
         ...(options.preserveOrgisms !== undefined && {

package/dist/presets/hooks.d.ts

@@ -0,0 +1,49 @@
+import type { OrgData } from "uniorg";
+import type { Sides } from "./sides.js";
+import type { ConversionContext, Preset } from "./types.js";
+/**
+ * md→org's dialect step: reads the Markdown dialect out of the generic
+ * tree, then writes the org dialect into it.
+ * @param uniorgAst The tree the generic transform produced.
+ * @param sides The preset per side.
+ * @returns The tree in the org dialect.
+ */
+export declare function readMarkdownWriteOrg(uniorgAst: OrgData, { input, output }: Sides): OrgData;
+/**
+ * org→md's dialect step: reads the org dialect out of the parsed tree,
+ * then writes the Markdown dialect into it.
+ * @param uniorgAst The parsed org tree.
+ * @param sides The preset per side.
+ * @returns The tree, ready for the generic transform.
+ */
+export declare function readOrgWriteMarkdown(uniorgAst: OrgData, { input, output }: Sides): OrgData;
+/** A preset that takes a whole conversion over, and the side it is on. */
+export interface TakeOver {
+    preset: Preset;
+    side: ConversionContext["side"];
+}
+/**
+ * Finds the preset that takes the conversion over, if any: the input's,
+ * else the output's.
+ * @param sides The preset per side.
+ * @param hook The hook that takes this direction over.
+ * @returns The preset and its side, or `undefined` for none.
+ */
+export declare function takeOver({ input, output }: Sides, hook: "convertOrg" | "convertMarkdown"): TakeOver | undefined;
+/**
+ * The sides a fragment converts with: the fragment's preset on the
+ * taking-over preset's side or sides, the other side as it was.
+ * @param sides The conversion's preset per side.
+ * @param side The taking-over preset's side.
+ * @param preset The fragment's preset.
+ * @param carried The preset for the other side where it is Vanilla.
+ * @returns The fragment's preset per side.
+ */
+export declare function fragmentSides(sides: Sides, side: ConversionContext["side"], preset: Preset | undefined, carried?: Preset): Sides;
+/**
+ * The context a taking-over preset converts in.
+ * @param over The taking-over preset and its side.
+ * @param options The conversion's options.
+ * @returns The context.
+ */
+export declare function conversionContext(over: TakeOver, options: Pick<ConversionContext, "onWarning" | "orgismKeys">): ConversionContext;

package/dist/presets/hooks.js

@@ -0,0 +1,72 @@
+/**
+ * md→org's dialect step: reads the Markdown dialect out of the generic
+ * tree, then writes the org dialect into it.
+ * @param uniorgAst The tree the generic transform produced.
+ * @param sides The preset per side.
+ * @returns The tree in the org dialect.
+ */
+export function readMarkdownWriteOrg(uniorgAst, { input, output }) {
+    const read = input?.markdown?.read?.org ?? same;
+    const write = output?.org?.write ?? same;
+    return write(read(uniorgAst));
+}
+/**
+ * org→md's dialect step: reads the org dialect out of the parsed tree,
+ * then writes the Markdown dialect into it.
+ * @param uniorgAst The parsed org tree.
+ * @param sides The preset per side.
+ * @returns The tree, ready for the generic transform.
+ */
+export function readOrgWriteMarkdown(uniorgAst, { input, output }) {
+    const read = input?.org?.read ?? same;
+    const write = output?.markdown?.write ?? same;
+    return write(read(uniorgAst));
+}
+function same(uniorgAst) {
+    return uniorgAst;
+}
+/**
+ * Finds the preset that takes the conversion over, if any: the input's,
+ * else the output's.
+ * @param sides The preset per side.
+ * @param hook The hook that takes this direction over.
+ * @returns The preset and its side, or `undefined` for none.
+ */
+export function takeOver({ input, output }, hook) {
+    if (input?.[hook]) {
+        return {
+            preset: input,
+            side: input.name === output?.name ? "both" : "input"
+        };
+    }
+    return output?.[hook] ? { preset: output, side: "output" } : undefined;
+}
+/**
+ * The sides a fragment converts with: the fragment's preset on the
+ * taking-over preset's side or sides, the other side as it was.
+ * @param sides The conversion's preset per side.
+ * @param side The taking-over preset's side.
+ * @param preset The fragment's preset.
+ * @param carried The preset for the other side where it is Vanilla.
+ * @returns The fragment's preset per side.
+ */
+export function fragmentSides(sides, side, preset, carried) {
+    // only a Vanilla side carries another preset's syntax
+    return {
+        input: side === "output" ? (sides.input ?? carried) : preset,
+        output: side === "input" ? (sides.output ?? carried) : preset
+    };
+}
+/**
+ * The context a taking-over preset converts in.
+ * @param over The taking-over preset and its side.
+ * @param options The conversion's options.
+ * @returns The context.
+ */
+export function conversionContext(over, options) {
+    return {
+        side: over.side,
+        ...(options.onWarning && { onWarning: options.onWarning }),
+        ...(options.orgismKeys && { orgismKeys: options.orgismKeys })
+    };
+}

package/dist/presets/logseq.d.ts

@@ -1,25 +1,6 @@
-import type { OrgData } from "uniorg";
 import type { Preset } from "./types.js";
-export interface LogseqPresetOptions {
-    /**
-     * Content following a heading becomes children of that heading's block
-     * in Logseq's outline: paragraphs turn into child block headlines one
-     * level deeper; other constructs stay in the preceding block's body.
-     * Default: `true`.
-     */
-    nestUnderHeadings?: boolean;
-}
 /**
- * Logseq dialect preset: `heading::` properties and outline nesting.
+ * Logseq dialect preset: the outline of blocks, page properties, page
+ * and block references, highlights and hiccup.
  */
-export declare function logseq(options?: LogseqPresetOptions): Preset;
-/**
- * Applies Logseq-specific conventions to a uniorg AST: every heading gets
- * a `:heading:` property drawer, and with `nestUnderHeadings` following
- * paragraphs become child block headlines (in Logseq's org format every
- * outline block is a headline).
- * @param uniorgAst The uniorg AST to transform.
- * @param nestUnderHeadings Nest content as child blocks. Default: `true`.
- * @returns The Logseq-flavored uniorg AST.
- */
-export declare function applyLogseqSpecificsToUniorgAst(uniorgAst: OrgData, nestUnderHeadings?: boolean): OrgData;
+export declare function logseq(): Preset;