@remigius42/morg 0.6.0 → 0.7.0

package/dist/core/keyValueLines.js

@@ -0,0 +1,18 @@
+// a `key:: value` line, Logseq's property syntax; an empty `key::` too
+const KEY_VALUE_LINE_RE = /^([\w-]+)::(?: (.*))?$/;
+/**
+ * The key, value pairs of a block of `key:: value` lines.
+ * @param text The block's text.
+ * @returns The pairs in order, or null if a line is none.
+ */
+export function keyValueEntries(text) {
+    const entries = [];
+    for (const line of text.replace(/\r?\n$/, "").split(/\r?\n/)) {
+        const match = KEY_VALUE_LINE_RE.exec(line);
+        if (!match) {
+            return null;
+        }
+        entries.push([match[1] ?? "", match[2] ?? ""]);
+    }
+    return entries;
+}

package/dist/core/lineSyntax.d.ts

@@ -1,10 +1,19 @@
 import type { Parent } from "unist";
+import { type Node } from "./render.js";
 /**
  * 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;
+/**
+ * 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.
+ * @param node The node.
+ * @param index Its index in its parent.
+ * @param parent Its parent.
+ */
+export declare function isPassthroughParagraph(node: Node | Parent, index: number, parent: Parent | undefined): boolean;
 /**
  * org→md: drops the line-start zero-width spaces `escapeLineSyntax`
  * inserts.

package/dist/core/lineSyntax.js

@@ -139,6 +139,21 @@ function isPassthrough(starts) {
     const [only, ...rest] = tryParse(`${lines.join("\n")}\n`)?.children ?? [];
     return !rest.length && PASSTHROUGH_TYPES.has(only?.type ?? "");
 }
+/**
+ * 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.
+ * @param node The node.
+ * @param index Its index in its parent.
+ * @param parent Its parent.
+ */
+export function isPassthroughParagraph(node, index, parent) {
+    if (node.type !== "paragraph") {
+        return false;
+    }
+    const context = contextOf(node, index, parent);
+    const children = node.children;
+    return (!context.afterBullet && isPassthrough(lineStarts(children, context).starts));
+}
 // line syntax spanning lines (`#+begin_src`…`#+end_src`, a drawer) or
 // depending on context (planning below a headline) shows only in the
 // whole content as org reads it; each round escapes the first line of

package/dist/core/mdastToUniorg/blocks.d.ts

@@ -1,7 +1,6 @@
 import type { RootContent, PhrasingContent } from "mdast";
 import type { ElementType } from "uniorg";
 import { type TransformContext } from "./context.js";
-export declare function frontmatterToKeywords(yamlValue: string): ElementType[];
 export declare function transformMdastTable(ctx: TransformContext, node: Extract<RootContent, {
     type: "table";
 }>): ElementType;

package/dist/core/mdastToUniorg/blocks.js

@@ -1,35 +1,7 @@
 import { toString } from "orgast-util-to-string";
-import { parse as parseYaml } from "yaml";
 import { mdismEnabled } from "./context.js";
 import { transformPhrasingChildren } from "./phrasing.js";
-// a keyword is a single line, so anything that is not a single-line
-// scalar is JSON-encoded and restored by JSON.parse on the way back
-function keywordValue(value) {
-    if (value !== null && typeof value === "object") {
-        return JSON.stringify(value);
-    }
-    const text = String(value);
-    return text.includes("\n") ? JSON.stringify(text) : text;
-}
-// frontmatter entries become #+KEY: value keywords; scalar values as-is,
-// structured values JSON-encoded on a single line (see ADR 0002)
-export function frontmatterToKeywords(yamlValue) {
-    const data = parseYaml(yamlValue);
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
-        return [];
-    }
-    return Object.entries(data).flatMap(([key, value]) => {
-        // a sequence becomes repeated keywords -- org's own way of carrying
-        // several values for one key, and what they read back as
-        const values = Array.isArray(value) && value.length ? value : [value];
-        return values.map(item => ({
-            type: "keyword",
-            affiliated: {},
-            key: key.toUpperCase(),
-            value: keywordValue(item)
-        }));
-    });
-}
+import { KEYWORD_NAME } from "../frontmatterBlock.js";
 export function transformMdastTable(ctx, node) {
     const [headerRow, ...bodyRows] = node.children;
     // GFM column alignment maps to an org alignment cookie row
@@ -196,7 +168,7 @@ export function transformMdastHeading(ctx, node) {
         children: transformPhrasingChildren(ctx, node.children)
     };
 }
-const KEYWORD_LINE_RE = /^#\+\S+: /;
+const KEYWORD_LINE_RE = new RegExp(String.raw `^#\+${KEYWORD_NAME}: `);
 export function keywordOnlyLines(node) {
     if (!node.children.every(child => child.type === "text")) {
         return null;
@@ -204,7 +176,7 @@ export function keywordOnlyLines(node) {
     const lines = node.children
         .map(child => child.value)
         .join("")
-        .split("\n");
+        .split(/\r?\n/);
     return lines.length && lines.every(line => KEYWORD_LINE_RE.test(line))
         ? lines
         : null;

package/dist/core/mdastToUniorg/index.d.ts

@@ -10,4 +10,10 @@ import type { MdastToUniorgOptions } from "./context.js";
  * @returns The transformed uniorg AST.
  */
 export declare function transformMdastToUniorgAst(mdast: MdastRoot, options?: MdastToUniorgOptions): OrgData;
+/**
+ * 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 declare function transformMdastToUniorgDraft(mdast: MdastRoot, options?: MdastToUniorgOptions): OrgData;
 export declare function transformMdastNodeToUniorgNode(ctx: TransformContext, node: RootContent | PhrasingContent): GreaterElementType | ElementType | Text | null;

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/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) {

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";
@@ -41,15 +41,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}`);
 }