@remigius42/morg 0.6.0 → 0.8.0

package/dist/core/mdastToUniorg/index.js

@@ -1,6 +1,7 @@
 import { visit } from "unist-util-visit";
 import { warn } from "./context.js";
-import { frontmatterToKeywords, keywordOnlyLines, transformMdastCode, transformMdastHeading, transformMdastHtml, transformMdastMath, transformMdastTable } from "./blocks.js";
+import { fitsKeywordLine, fitsPropertyLine, markModeLine, renderFileHeader, takeMorgEntry, takesMorgEntries } from "../frontmatterBlock.js";
+import { keywordOnlyLines, transformMdastCode, transformMdastHeading, transformMdastHtml, transformMdastMath, transformMdastTable } from "./blocks.js";
 import { transformMdastList } from "./lists.js";
 import { transformPhrasingChildren } from "./phrasing.js";
 /**
@@ -10,6 +11,16 @@ import { transformPhrasingChildren } from "./phrasing.js";
  * @returns The transformed uniorg AST.
  */
 export function transformMdastToUniorgAst(mdast, options = {}) {
+    const orgAst = transformMdastToUniorgDraft(mdast, options);
+    renderFileHeader(orgAst);
+    return orgAst;
+}
+/**
+ * md→org pipeline: like `transformMdastToUniorgAst`, but the frontmatter
+ * stays a `morg-frontmatter` node a preset can still take entries out
+ * of; `renderFileHeader` turns it into the block.
+ */
+export function transformMdastToUniorgDraft(mdast, options = {}) {
     const ctx = { options, definitions: new Map() };
     visit(mdast, "definition", (definition) => {
         ctx.definitions.set(definition.identifier, {
@@ -17,13 +28,20 @@ export function transformMdastToUniorgAst(mdast, options = {}) {
             ...(definition.title != null && { title: definition.title })
         });
     });
+    const firstBody = mdast.children.find(child => child.type !== "yaml");
     const children = mdast.children
-        .flatMap(child => 
-    // frontmatter maps to org keywords, a native construct (one mdast
-    // node fans out to one keyword per entry)
-    child.type === "yaml"
-        ? frontmatterToKeywords(child.value)
-        : [transformMdastNodeToUniorgNode(ctx, child)])
+        .flatMap(child => {
+        // frontmatter is passive data, org keywords can act; it travels
+        // inert in a marked comment block (ADR 0005)
+        if (child.type === "yaml") {
+            return transformFrontmatter(child.value);
+        }
+        const node = transformMdastNodeToUniorgNode(ctx, child);
+        if (child === firstBody) {
+            markModeLine(node);
+        }
+        return [node];
+    })
         .filter(Boolean);
     const orgAst = {
         type: "org-data",
@@ -101,3 +119,50 @@ function quotedHeadingAsText(ctx, node) {
     warn(ctx, "heading inside a blockquote became text");
     return { type: "paragraph", children: node.children };
 }
+// morg's own entries, both or neither: one left in the YAML would keep
+// the other from joining it again on the way back
+function takeMorgEntries(yaml) {
+    // most frontmatter holds neither: no need to parse it
+    if (!yaml.includes("morg_")) {
+        return { keywords: [], properties: [], yaml };
+    }
+    const taken = takeMorgEntry(yaml, "morg_keywords", fitsKeywordLine);
+    const rest = takeMorgEntry(taken.yaml, "morg_properties", fitsPropertyLine);
+    return takesMorgEntries(rest.yaml)
+        ? { keywords: taken.keywords, properties: rest.keywords, yaml: rest.yaml }
+        : { keywords: [], properties: [], yaml };
+}
+function keywordNodes(keywords) {
+    return keywords.map(([key, value]) => ({
+        type: "keyword",
+        affiliated: {},
+        key,
+        value
+    }));
+}
+// org's own keywords go back to keywords; the rest of the frontmatter
+// stays inert data in the block
+function transformFrontmatter(value) {
+    // in the org file's line endings, which are LF
+    const lf = value.replaceAll("\r\n", "\n");
+    const { keywords, properties, yaml } = takeMorgEntries(lf);
+    const drawer = properties.length
+        ? [
+            {
+                type: "property-drawer",
+                children: properties.map(([key, propertyValue]) => ({
+                    type: "node-property",
+                    key,
+                    value: propertyValue
+                }))
+            }
+        ]
+        : [];
+    const nodes = keywordNodes(keywords);
+    // an empty frontmatter stays a block
+    if (yaml || !(keywords.length || properties.length)) {
+        const node = { type: "morg-frontmatter", yaml };
+        nodes.push(node);
+    }
+    return [...drawer, ...nodes];
+}

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;

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/tablePipes.d.ts

@@ -2,7 +2,16 @@ import type { Parent } from "unist";
 /**
  * md→org: a `|` in a table cell's text (md `\|`) would end the cell; org
  * has no escaped `|`, but renders the `\vert` entity as one, `{}` ending
- * its name before any letter. Runs after the preset, whose wikilink
- * aliases (`[[Page|alias]]`) are no text.
+ * its name before any letter. In code, where the entity would be
+ * literal, the lookalike stands in, which is reported. Runs after the
+ * preset, whose wikilink aliases (`[[Page|alias]]`) are no text.
+ * @param tree The document.
+ * @param onWarning Reports a lookalike written.
  */
-export declare function escapeTablePipes(tree: Parent): void;
+export declare function escapeTablePipes(tree: Parent, onWarning?: (message: string) => void): void;
+/**
+ * org→md: the lookalike in code in a table cell back to the `|` it
+ * stands in for.
+ * @param tree The document.
+ */
+export declare function unescapeTablePipes(tree: Parent): void;

package/dist/core/tablePipes.js

@@ -1,14 +1,47 @@
 import { visit } from "unist-util-visit";
+// org has no escape inside ~code~ or =verbatim=: a `|` there would end
+// the cell, so a lookalike (U+2223 DIVIDES) stands in for it
+const LOOKALIKE = "∣";
 /**
  * md→org: a `|` in a table cell's text (md `\|`) would end the cell; org
  * has no escaped `|`, but renders the `\vert` entity as one, `{}` ending
- * its name before any letter. Runs after the preset, whose wikilink
- * aliases (`[[Page|alias]]`) are no text.
+ * its name before any letter. In code, where the entity would be
+ * literal, the lookalike stands in, which is reported. Runs after the
+ * preset, whose wikilink aliases (`[[Page|alias]]`) are no text.
+ * @param tree The document.
+ * @param onWarning Reports a lookalike written.
  */
-export function escapeTablePipes(tree) {
+export function escapeTablePipes(tree, onWarning) {
+    let replaced = false;
     visit(tree, "table-cell", (cell) => {
-        visit(cell, "text", (node) => {
-            node.value = node.value?.replaceAll("|", "\\vert{}");
+        visit(cell, (node) => {
+            if (node.type === "text") {
+                node.value = node.value?.replaceAll("|", "\\vert{}");
+            }
+            else if (isCode(node) && node.value?.includes("|")) {
+                node.value = node.value.replaceAll("|", LOOKALIKE);
+                replaced = true;
+            }
         });
     });
+    if (replaced) {
+        onWarning?.("a | in code in a table cell becomes ∣ (U+2223) in org");
+    }
+}
+/**
+ * org→md: the lookalike in code in a table cell back to the `|` it
+ * stands in for.
+ * @param tree The document.
+ */
+export function unescapeTablePipes(tree) {
+    visit(tree, "table-cell", (cell) => {
+        visit(cell, (node) => {
+            if (isCode(node)) {
+                node.value = node.value?.replaceAll(LOOKALIKE, "|");
+            }
+        });
+    });
+}
+function isCode(node) {
+    return node.type === "code" || node.type === "verbatim";
 }

package/dist/core/uniorgToMdast/elements.js

@@ -180,7 +180,7 @@ function transformPropertyDrawer(ctx, node) {
     }
     const isms = (node.children || [])
         .filter(child => child.type === "node-property")
-        .map(property => `${property.key}:: ${property.value}`);
+        .map(({ key, value }) => (value ? `${key}:: ${value}` : `${key}::`));
     return isms.length ? keyValueParagraph(isms) : null;
 }
 function transformParagraph(ctx, node) {
@@ -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/index.d.ts

@@ -1,11 +1,12 @@
 import type { Root as MdastRoot } from "mdast";
 import type { OrgData } from "uniorg";
-import type { UniorgToMdastOptions } from "./shared.js";
+import { type UniorgToMdastOptions } from "./shared.js";
 export type { UniorgToMdastOptions } from "./shared.js";
 /**
  * Transforms a uniorg AST to a mdast (Markdown AST).
  * @param uniorgAst The uniorg AST to transform.
- * @param options Controls org-ism serialization (`key:: value` lines).
+ * @param options Controls org-ism serialization (`key:: value` lines);
+ * `org`, the text a tree was parsed from, finds its frontmatter block.
  * @returns The transformed mdast.
  */
 export declare function transformUniorgAstToMdast(uniorgAst: OrgData, options?: UniorgToMdastOptions): MdastRoot;

package/dist/core/uniorgToMdast/index.js

@@ -1,13 +1,27 @@
 import { stringify as stringifyYaml } from "yaml";
+import { warn } from "./shared.js";
+import { isModeLineComment, takeFileHeader, takeRenderedFileHeader } from "../frontmatterBlock.js";
 import { collectFootnoteLabels } from "./footnotes.js";
 import { transformNodes } from "./elements.js";
 /**
  * Transforms a uniorg AST to a mdast (Markdown AST).
  * @param uniorgAst The uniorg AST to transform.
- * @param options Controls org-ism serialization (`key:: value` lines).
+ * @param options Controls org-ism serialization (`key:: value` lines);
+ * `org`, the text a tree was parsed from, finds its frontmatter block.
  * @returns The transformed mdast.
  */
 export function transformUniorgAstToMdast(uniorgAst, options = {}) {
+    // called on its own, not by convertOrgToMarkdown, which takes the
+    // header off the org text: the header of the org text the tree was
+    // parsed from, or else the one transformMdastToUniorgAst built, from a
+    // copy, so the caller's tree stays as it is
+    if (options.takesMorgEntries === undefined) {
+        uniorgAst = { ...uniorgAst, children: [...uniorgAst.children] };
+        const header = options.org === undefined
+            ? takeRenderedFileHeader(uniorgAst)
+            : takeFileHeader(uniorgAst, options.org, options.onWarning);
+        options = { ...options, ...header };
+    }
     const ctx = {
         options,
         inlineFootnotes: [],
@@ -15,36 +29,15 @@ export function transformUniorgAstToMdast(uniorgAst, options = {}) {
     };
     collectFootnoteLabels(ctx, uniorgAst);
     const nodes = uniorgAst.children || [];
-    // leading #+KEY: value keywords map to md frontmatter, a native
-    // construct; JSON-encoded values restore their structure (ADR 0002)
-    const collected = new Map();
-    let first = 0;
-    while (nodes[first]?.type === "keyword") {
-        const keyword = nodes[first];
-        const key = keyword.key.toLowerCase();
-        // a keyword may legally repeat; collect the values instead of
-        // letting the last one win
-        collected.set(key, [
-            ...(collected.get(key) ?? []),
-            parseKeywordValue(keyword.value)
-        ]);
-        first++;
-    }
-    const frontmatter = Object.fromEntries([...collected].map(([key, values]) => [
-        key,
-        values.length === 1 ? values[0] : values
-    ]));
-    const children = transformNodes(ctx, nodes.slice(first));
+    const { yaml, rest } = takeFrontmatter(ctx, nodes);
+    const children = transformNodes(ctx, rest);
     // adjacent single-item task lists (one per converted TODO section)
     // merge into one list, or the output would not be a fixed point
     if (options.taskCheckboxes) {
         mergeAdjacentTaskLists(children);
     }
-    if (first > 0) {
-        children.unshift({
-            type: "yaml",
-            value: stringifyYaml(frontmatter).trimEnd()
-        });
+    if (yaml !== undefined) {
+        children.unshift({ type: "yaml", value: yaml });
     }
     for (const footnote of ctx.inlineFootnotes) {
         children.push({
@@ -56,12 +49,88 @@ export function transformUniorgAstToMdast(uniorgAst, options = {}) {
     }
     return { type: "root", children: children };
 }
-function parseKeywordValue(value) {
-    try {
-        return JSON.parse(value);
+// the frontmatter: the block's YAML, and the leading #+KEY: value
+// keywords, which can act in Emacs, in order, repeats included, as
+// morg's own entry (ADR 0005); where they cannot join it, they stay
+// keyword lines. Returns the YAML and the nodes left
+function takeFrontmatter(ctx, nodes) {
+    const block = ctx.options.frontmatter;
+    // set by the caller or transformUniorgAstToMdast, never undefined
+    const joins = ctx.options.takesMorgEntries === true;
+    const start = leadingKeywordsStart(nodes);
+    warnAboutFrontmatter(ctx, block, joins ? [] : nodes.slice(start));
+    const keywords = inertModeLineGuard(ctx, nodes, joins ? leadingKeywords(nodes.slice(start)) : [], start);
+    const entries = morgEntries(ctx.options.fileProperties ?? [], keywords);
+    const rest = [
+        ...nodes.slice(0, start),
+        ...nodes.slice(start + keywords.length)
+    ];
+    // an empty block adds nothing next to the entries
+    // on a line of their own: a keep-chomped (`|+`) scalar at the end of
+    // the block holds a newline already there
+    const yaml = entries && block
+        ? `${block.replace(/(?<!\n)$/, "\n")}${entries}`
+        : (entries ?? block);
+    // leading the Markdown body, with or without frontmatter above it
+    if (isInertModeLine(ctx, rest[0])) {
+        warn(ctx, "a -*- comment below the first line becomes the mode line in org");
+    }
+    return { yaml, rest };
+}
+// leading keywords may sit below a -*- comment, which leads the
+// Markdown body and so becomes the mode line (warned if it was none);
+// below another comment, they would come back above it
+function leadingKeywordsStart(nodes) {
+    return nodes[0] && isModeLineComment(nodes[0]) ? 1 : 0;
+}
+// a -*- comment below the file's first line, which Emacs ignores
+function isInertModeLine(ctx, node) {
+    return !ctx.options.startsWithModeLine && !!node && isModeLineComment(node);
+}
+// md→org makes a -*- comment that leads the Markdown body the file's
+// mode line: leading keywords directly above one stay lines, so it
+// does not lead it
+function inertModeLineGuard(ctx, nodes, keywords, start) {
+    if (!keywords.length ||
+        start !== 0 ||
+        !isInertModeLine(ctx, nodes[keywords.length])) {
+        return keywords;
+    }
+    warn(ctx, "leading keywords stay lines: a -*- comment below them is no mode line");
+    return [];
+}
+function leadingKeywords(nodes) {
+    const keywords = [];
+    while (nodes[keywords.length]?.type === "keyword") {
+        const keyword = nodes[keywords.length];
+        keywords.push([keyword.key, keyword.value]);
+    }
+    return keywords;
+}
+// morg's own entries as YAML text, or undefined without any
+function morgEntries(fileProperties, keywords) {
+    // an empty value as `KEY:`, as it reads back, not as `KEY: ""`
+    const items = (pairs) => pairs.map(([key, value]) => ({ [key]: value || null }));
+    const entries = {
+        ...(fileProperties.length && { morg_properties: items(fileProperties) }),
+        ...(keywords.length && { morg_keywords: items(keywords) })
+    };
+    // unfolded: a value folded over lines fits no keyword line again
+    return Object.keys(entries).length
+        ? stringifyYaml(entries, { lineWidth: 0, nullStr: "" }).trimEnd()
+        : undefined;
+}
+// `left`: the leading nodes the frontmatter could not take
+function warnAboutFrontmatter(ctx, block, left) {
+    if (block && /^---[ \t]*$/m.test(block)) {
+        warn(ctx, "frontmatter holds a --- line, which ends it early in Markdown");
+    }
+    const drawer = left[0]?.type === "property-drawer";
+    if (drawer) {
+        warn(ctx, "file-level drawer stays text: the frontmatter cannot take it");
     }
-    catch {
-        return value;
+    if (left[drawer ? 1 : 0]?.type === "keyword") {
+        warn(ctx, "leading keywords stay lines: the frontmatter cannot take them");
     }
 }
 function isTaskList(node) {

package/dist/core/uniorgToMdast/lists.js

@@ -61,7 +61,7 @@ function transformUniorgList(ctx, node) {
         return {
             type: "list",
             ordered,
-            start: ordered ? parseInt(firstBullet, 10) || 1 : null,
+            start: ordered ? parseInt(firstBullet, 10) : null,
             spread: false,
             children: run.map(item => transformUniorgListItem(ctx, item))
         };

package/dist/core/uniorgToMdast/objects.js

@@ -5,6 +5,12 @@ import { unescapeOrgPath } from "../orgPath.js";
 const IMAGE_EXTENSION_RE = /\.(png|jpe?g|gif|svg|webp|avif|bmp|ico)$/i;
 export function transformUniorgObjects(ctx, children) {
     return (children || [])
+        .map((child, index) => 
+    // uniorg keeps the continuation line's indentation after a line
+    // break; md would render it as leading whitespace
+    child.type === "text" && children?.[index - 1]?.type === "line-break"
+        ? { ...child, value: child.value.replace(/^[ \t]+/, "") }
+        : child)
         .flatMap(child => transformUniorgObjectToMdastPhrasingContent(ctx, child))
         .filter(Boolean);
 }

package/dist/core/uniorgToMdast/shared.d.ts

@@ -6,6 +6,11 @@ export interface UniorgToMdastOptions {
     taskCheckboxes?: boolean;
     orgismKeys?: Record<string, string>;
     onWarning?: (message: string) => void;
+    frontmatter?: string;
+    fileProperties?: [string, string][];
+    takesMorgEntries?: boolean;
+    startsWithModeLine?: boolean;
+    org?: string;
 }
 export interface TransformContext {
     options: UniorgToMdastOptions;

package/dist/core/uniorgToMdast/shared.js

@@ -1,4 +1,4 @@
-import { toString as orgastToString } from "orgast-util-to-string";
+import { affiliatedEntries } from "../affiliated.js";
 import { unified } from "unified";
 import { uniorgStringify } from "uniorg-stringify";
 import { toggleEnabled } from "../../options.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],
@@ -41,15 +46,6 @@ export function trimTrailingNewline(value) {
 // affiliated keywords (#+CAPTION:, #+NAME:, #+ATTR_*) precede their
 // element as verbatim lines so the return trip re-attaches them natively
 export function affiliatedLines(node) {
-    const affiliated = node
-        .affiliated;
-    return Object.entries(affiliated ?? {}).flatMap(([key, value]) => {
-        const entries = Array.isArray(value) ? value : [value];
-        return entries.map(entry => {
-            const text = Array.isArray(entry)
-                ? entry.map(child => orgastToString(child)).join("")
-                : String(entry);
-            return `#+${key}: ${text}`;
-        });
-    });
+    const affiliated = node.affiliated;
+    return affiliatedEntries(affiliated).map(([key, value]) => `#+${key}: ${value}`);
 }

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