remark-docx 0.2.1 → 0.3.1

package/lib/index.cjs

@@ -1,88 +1,27 @@
 'use strict';
 
-var unistUtilVisit = require('unist-util-visit');
 var docx = require('docx');
-var unifiedLatexUtilParse = require('@unified-latex/unified-latex-util-parse');
+var mdastUtilDefinitions = require('mdast-util-definitions');
 
 /**
  * @internal
  */
-const unreachable = (_) => {
-    throw new Error("unreachable");
-};
+function invariant(cond, message) {
+    throw new Error(message);
+}
+const alreadyWarned = {};
 /**
  * @internal
  */
-function invariant(cond, message) {
-    if (!cond)
-        throw new Error(message);
+function warnOnce(message, cond = false) {
+    if (!cond && !alreadyWarned[message]) {
+        alreadyWarned[message] = true;
+        console.warn(message);
+    }
 }
 
 const ORDERED_LIST_REF = "ordered";
 const INDENT = 0.5;
-const DEFAULT_NUMBERINGS = [
-    {
-        level: 0,
-        format: docx.LevelFormat.DECIMAL,
-        text: "%1.",
-        alignment: docx.AlignmentType.START,
-    },
-    {
-        level: 1,
-        format: docx.LevelFormat.DECIMAL,
-        text: "%2.",
-        alignment: docx.AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: docx.convertInchesToTwip(INDENT * 1) },
-            },
-        },
-    },
-    {
-        level: 2,
-        format: docx.LevelFormat.DECIMAL,
-        text: "%3.",
-        alignment: docx.AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: docx.convertInchesToTwip(INDENT * 2) },
-            },
-        },
-    },
-    {
-        level: 3,
-        format: docx.LevelFormat.DECIMAL,
-        text: "%4.",
-        alignment: docx.AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: docx.convertInchesToTwip(INDENT * 3) },
-            },
-        },
-    },
-    {
-        level: 4,
-        format: docx.LevelFormat.DECIMAL,
-        text: "%5.",
-        alignment: docx.AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: docx.convertInchesToTwip(INDENT * 4) },
-            },
-        },
-    },
-    {
-        level: 5,
-        format: docx.LevelFormat.DECIMAL,
-        text: "%6.",
-        alignment: docx.AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: docx.convertInchesToTwip(INDENT * 5) },
-            },
-        },
-    },
-];
 const createFootnoteRegistry = () => {
     const idToInternalId = new Map();
     const defs = new Map();
@@ -111,11 +50,74 @@ const createFootnoteRegistry = () => {
 };
 const createNumberingRegistry = () => {
     let counter = 1;
+    const DEFAULT_NUMBERINGS = [
+        {
+            level: 0,
+            format: docx.LevelFormat.DECIMAL,
+            text: "%1.",
+            alignment: docx.AlignmentType.START,
+        },
+        {
+            level: 1,
+            format: docx.LevelFormat.DECIMAL,
+            text: "%2.",
+            alignment: docx.AlignmentType.START,
+            style: {
+                paragraph: {
+                    indent: { start: docx.convertInchesToTwip(INDENT * 1) },
+                },
+            },
+        },
+        {
+            level: 2,
+            format: docx.LevelFormat.DECIMAL,
+            text: "%3.",
+            alignment: docx.AlignmentType.START,
+            style: {
+                paragraph: {
+                    indent: { start: docx.convertInchesToTwip(INDENT * 2) },
+                },
+            },
+        },
+        {
+            level: 3,
+            format: docx.LevelFormat.DECIMAL,
+            text: "%4.",
+            alignment: docx.AlignmentType.START,
+            style: {
+                paragraph: {
+                    indent: { start: docx.convertInchesToTwip(INDENT * 3) },
+                },
+            },
+        },
+        {
+            level: 4,
+            format: docx.LevelFormat.DECIMAL,
+            text: "%5.",
+            alignment: docx.AlignmentType.START,
+            style: {
+                paragraph: {
+                    indent: { start: docx.convertInchesToTwip(INDENT * 4) },
+                },
+            },
+        },
+        {
+            level: 5,
+            format: docx.LevelFormat.DECIMAL,
+            text: "%6.",
+            alignment: docx.AlignmentType.START,
+            style: {
+                paragraph: {
+                    indent: { start: docx.convertInchesToTwip(INDENT * 5) },
+                },
+            },
+        },
+    ];
     return {
         create: () => {
             return `${ORDERED_LIST_REF}-${counter++}`;
         },
-        getAll: () => {
+        numberings: () => {
             return Array.from({ length: counter }, (_, i) => ({
                 reference: `${ORDERED_LIST_REF}-${i}`,
                 levels: DEFAULT_NUMBERINGS,
@@ -123,21 +125,18 @@ const createNumberingRegistry = () => {
         },
     };
 };
-const mdastToDocx = async (node, { output = "buffer", title, subject, creator, keywords, description, lastModifiedBy, revision, styles, background, }, images, latex) => {
-    const definition = {};
-    unistUtilVisit.visit(node, "definition", (node) => {
-        definition[node.identifier] = node.url;
-    });
+const mdastToDocx = async (node, { plugins = [], title, subject, creator, keywords, description, lastModifiedBy, revision, styles, background, }) => {
+    const definition = mdastUtilDefinitions.definitions(node);
     const footnote = createFootnoteRegistry();
     const numbering = createNumberingRegistry();
+    const pluginCtx = { root: node, definition };
     const nodes = convertNodes(node.children, {
+        overrides: (await Promise.all(plugins.map((p) => p(pluginCtx)))).reduceRight((acc, p) => ({ acc, ...p }), {}),
         deco: {},
-        images,
         indent: 0,
-        def: definition,
+        definition: definition,
         footnote,
         numbering,
-        latex,
     });
     const doc = new docx.Document({
         title,
@@ -152,21 +151,25 @@ const mdastToDocx = async (node, { output = "buffer", title, subject, creator, k
         footnotes: footnote.footnotes(),
         sections: [{ children: nodes }],
         numbering: {
-            config: numbering.getAll(),
+            config: numbering.numberings(),
         },
     });
-    switch (output) {
-        case "buffer":
-            return docx.Packer.toBuffer(doc);
-        case "arrayBuffer":
-            return docx.Packer.toArrayBuffer(doc);
-        case "blob":
-            return docx.Packer.toBlob(doc);
-    }
+    return docx.Packer.toArrayBuffer(doc);
 };
 const convertNodes = (nodes, ctx) => {
+    var _a, _b;
     const results = [];
     for (const node of nodes) {
+        const customNodes = (_b = (_a = ctx.overrides)[node.type]) === null || _b === void 0 ? void 0 : _b.call(_a, node, (children) => convertNodes(children, ctx));
+        if (customNodes != null) {
+            if (Array.isArray(customNodes)) {
+                results.push(...customNodes);
+            }
+            else {
+                results.push(customNodes);
+            }
+            continue;
+        }
         switch (node.type) {
             case "paragraph": {
                 results.push(buildParagraph(node, ctx));
@@ -202,12 +205,12 @@ const convertNodes = (nodes, ctx) => {
             case "code":
                 results.push(buildCode(node));
                 break;
-            case "yaml":
-                // FIXME: unimplemented
-                break;
-            case "toml":
-                // FIXME: unimplemented
-                break;
+            // case "yaml":
+            //   // unimplemented
+            //   break;
+            // case "toml":
+            //   // unimplemented
+            //   break;
             case "definition":
                 // noop
                 break;
@@ -240,34 +243,27 @@ const convertNodes = (nodes, ctx) => {
                 results.push(buildLink(node, ctx));
                 break;
             }
-            case "image":
-                results.push(buildImage(node, ctx.images));
-                break;
             case "linkReference":
                 results.push(...buildLinkReference(node, ctx));
                 break;
+            case "image":
             case "imageReference": {
-                const image = buildImageReference(node, ctx);
-                if (image) {
-                    results.push(image);
-                }
-                break;
-            }
-            case "footnote": {
-                // inline footnote was removed in mdast v5
+                warnOnce(`${node.type} node is not rendered since remark-docx/plugins/image is not provided.`);
                 break;
             }
+            // case "footnote": {
+            //   // inline footnote was removed in mdast v5
+            //   break;
+            // }
             case "footnoteReference":
                 results.push(buildFootnoteReference(node, ctx));
                 break;
             case "math":
-                results.push(...buildMath(node, ctx));
-                break;
             case "inlineMath":
-                results.push(buildInlineMath(node, ctx));
+                warnOnce(`${node.type} node is not rendered since remark-docx/plugins/math is not provided.`);
                 break;
             default:
-                unreachable();
+                warnOnce(`${node.type} node is not officially supported.`);
                 break;
         }
     }
@@ -344,7 +340,7 @@ const buildBlockquote = ({ children }, ctx) => {
         indent: ctx.indent + 1,
     });
 };
-const buildList = ({ children, ordered, start: _start, spread: _spread }, ctx) => {
+const buildList = ({ children, ordered }, ctx) => {
     var _a;
     const isTopLevel = !ctx.list;
     const list = {
@@ -361,7 +357,7 @@ const buildList = ({ children, ordered, start: _start, spread: _spread }, ctx) =
         });
     });
 };
-const buildListItem = ({ children, checked, spread: _spread }, ctx) => {
+const buildListItem = ({ children, checked }, ctx) => {
     return convertNodes(children, {
         ...ctx,
         ...(ctx.list && { list: { ...ctx.list, checked: checked !== null && checked !== void 0 ? checked : undefined } }),
@@ -382,28 +378,21 @@ const buildTable = ({ children, align }, ctx) => {
     });
     return new docx.Table({
         rows: children.map((r) => {
-            return buildTableRow(r, ctx, cellAligns);
-        }),
-    });
-};
-const buildTableRow = ({ children }, ctx, cellAligns) => {
-    return new docx.TableRow({
-        children: children.map((c, i) => {
-            return buildTableCell(c, ctx, cellAligns === null || cellAligns === void 0 ? void 0 : cellAligns[i]);
+            return new docx.TableRow({
+                children: r.children.map((c, i) => {
+                    return new docx.TableCell({
+                        children: [
+                            new docx.Paragraph({
+                                alignment: cellAligns === null || cellAligns === void 0 ? void 0 : cellAligns[i],
+                                children: convertNodes(c.children, ctx),
+                            }),
+                        ],
+                    });
+                }),
+            });
         }),
     });
 };
-const buildTableCell = ({ children }, ctx, align) => {
-    const nodes = convertNodes(children, ctx);
-    return new docx.TableCell({
-        children: [
-            new docx.Paragraph({
-                alignment: align,
-                children: nodes,
-            }),
-        ],
-    });
-};
 const buildHtml = ({ value }) => {
     // FIXME: transform to text for now
     return new docx.Paragraph({
@@ -416,20 +405,6 @@ const buildCode = ({ value, lang: _lang, meta: _meta, }) => {
         children: [buildText(value, {})],
     });
 };
-const buildMath = ({ value }, ctx) => {
-    return ctx.latex(value).map((runs) => new docx.Paragraph({
-        children: [
-            new docx.Math({
-                children: runs,
-            }),
-        ],
-    }));
-};
-const buildInlineMath = ({ value }, ctx) => {
-    return new docx.Math({
-        children: ctx.latex(value).flatMap((runs) => runs),
-    });
-};
 const buildText = (text, deco) => {
     return new docx.TextRun({
         text,
@@ -448,32 +423,12 @@ const buildLink = ({ children, url }, ctx) => {
         children: nodes,
     });
 };
-const buildImage = ({ url }, images) => {
-    const img = images[url];
-    invariant(img, `Fetch image was failed: ${url}`);
-    const { image, width, height } = img;
-    return new docx.ImageRun({
-        type: img.type,
-        data: image,
-        transformation: {
-            width,
-            height,
-        },
-    });
-};
 const buildLinkReference = ({ children, identifier }, ctx) => {
-    const def = ctx.def[identifier];
+    const def = ctx.definition(identifier);
     if (def == null) {
         return convertNodes(children, ctx);
     }
-    return [buildLink({ children, url: def }, ctx)];
-};
-const buildImageReference = ({ identifier }, ctx) => {
-    const def = ctx.def[identifier];
-    if (def == null) {
-        return;
-    }
-    return buildImage({ url: def }, ctx.images);
+    return [buildLink({ children, url: def.url }, ctx)];
 };
 const registerFootnoteDefinition = ({ children, identifier }, ctx) => {
     const definition = {
@@ -493,391 +448,9 @@ const buildFootnoteReference = ({ identifier }, ctx) => {
     return new docx.FootnoteReferenceRun(ctx.footnote.ref(identifier));
 };
 
-const hasSquareBrackets = (arg) => {
-    return !!arg && arg.openMark === "[" && arg.closeMark === "]";
-};
-const hasCurlyBrackets = (arg) => {
-    return !!arg && arg.openMark === "{" && arg.closeMark === "}";
-};
-const mapString = (s) => new docx.MathRun(s);
-const mapMacro = (n, runs) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    switch (n.content) {
-        case "#":
-            return mapString("#");
-        case "$":
-            return mapString("$");
-        case "%":
-            return mapString("%");
-        case "&":
-            return mapString("&");
-        case "textasciitilde":
-            return mapString("~");
-        case "textasciicircum":
-            return mapString("^");
-        case "textbackslash":
-            return mapString("∖");
-        case "{":
-            return mapString("{");
-        case "}":
-            return mapString("}");
-        case "textbar":
-            return mapString("|");
-        case "textless":
-            return mapString("<");
-        case "textgreater":
-            return mapString(">");
-        case "neq":
-            return mapString("≠");
-        case "sim":
-            return mapString("∼");
-        case "simeq":
-            return mapString("≃");
-        case "approx":
-            return mapString("≈");
-        case "fallingdotseq":
-            return mapString("≒");
-        case "risingdotseq":
-            return mapString("≓");
-        case "equiv":
-            return mapString("≡");
-        case "geq":
-            return mapString("≥");
-        case "geqq":
-            return mapString("≧");
-        case "leq":
-            return mapString("≤");
-        case "leqq":
-            return mapString("≦");
-        case "gg":
-            return mapString("≫");
-        case "ll":
-            return mapString("≪");
-        case "times":
-            return mapString("×");
-        case "div":
-            return mapString("÷");
-        case "pm":
-            return mapString("±");
-        case "mp":
-            return mapString("∓");
-        case "oplus":
-            return mapString("⊕");
-        case "ominus":
-            return mapString("⊖");
-        case "otimes":
-            return mapString("⊗");
-        case "oslash":
-            return mapString("⊘");
-        case "circ":
-            return mapString("∘");
-        case "cdot":
-            return mapString("⋅");
-        case "bullet":
-            return mapString("∙");
-        case "ltimes":
-            return mapString("⋉");
-        case "rtimes":
-            return mapString("⋊");
-        case "in":
-            return mapString("∈");
-        case "ni":
-            return mapString("∋");
-        case "notin":
-            return mapString("∉");
-        case "subset":
-            return mapString("⊂");
-        case "supset":
-            return mapString("⊃");
-        case "subseteq":
-            return mapString("⊆");
-        case "supseteq":
-            return mapString("⊇");
-        case "nsubseteq":
-            return mapString("⊈");
-        case "nsupseteq":
-            return mapString("⊉");
-        case "subsetneq":
-            return mapString("⊊");
-        case "supsetneq":
-            return mapString("⊋");
-        case "cap":
-            return mapString("∩");
-        case "cup":
-            return mapString("∪");
-        case "emptyset":
-            return mapString("∅");
-        case "infty":
-            return mapString("∞");
-        case "partial":
-            return mapString("∂");
-        case "aleph":
-            return mapString("ℵ");
-        case "hbar":
-            return mapString("ℏ");
-        case "wp":
-            return mapString("℘");
-        case "Re":
-            return mapString("ℜ");
-        case "Im":
-            return mapString("ℑ");
-        case "alpha":
-            return mapString("α");
-        case "beta":
-            return mapString("β");
-        case "gamma":
-            return mapString("γ");
-        case "delta":
-            return mapString("δ");
-        case "epsilon":
-            return mapString("ϵ");
-        case "zeta":
-            return mapString("ζ");
-        case "eta":
-            return mapString("η");
-        case "theta":
-            return mapString("θ");
-        case "iota":
-            return mapString("ι");
-        case "kappa":
-            return mapString("κ");
-        case "lambda":
-            return mapString("λ");
-        case "eta":
-            return mapString("η");
-        case "mu":
-            return mapString("μ");
-        case "nu":
-            return mapString("ν");
-        case "xi":
-            return mapString("ξ");
-        case "pi":
-            return mapString("π");
-        case "rho":
-            return mapString("ρ");
-        case "sigma":
-            return mapString("σ");
-        case "tau":
-            return mapString("τ");
-        case "upsilon":
-            return mapString("υ");
-        case "phi":
-            return mapString("ϕ");
-        case "chi":
-            return mapString("χ");
-        case "psi":
-            return mapString("ψ");
-        case "omega":
-            return mapString("ω");
-        case "varepsilon":
-            return mapString("ε");
-        case "vartheta":
-            return mapString("ϑ");
-        case "varrho":
-            return mapString("ϱ");
-        case "varsigma":
-            return mapString("ς");
-        case "varphi":
-            return mapString("φ");
-        case "Gamma":
-            return mapString("Γ");
-        case "Delta":
-            return mapString("Δ");
-        case "Theta":
-            return mapString("Θ");
-        case "Lambda":
-            return mapString("Λ");
-        case "Xi":
-            return mapString("Ξ");
-        case "Pi":
-            return mapString("Π");
-        case "Sigma":
-            return mapString("Σ");
-        case "Upsilon":
-            return mapString("Υ");
-        case "Phi":
-            return mapString("Φ");
-        case "Psi":
-            return mapString("Ψ");
-        case "Omega":
-            return mapString("Ω");
-        case "newline":
-        case "\\":
-            // line break
-            return false;
-        case "^": {
-            const prev = runs.pop();
-            if (!prev)
-                break;
-            return new docx.MathSuperScript({
-                children: [prev],
-                superScript: mapGroup((_c = (_b = (_a = n.args) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) !== null && _c !== void 0 ? _c : []),
-            });
-        }
-        case "_": {
-            const prev = runs.pop();
-            if (!prev)
-                break;
-            return new docx.MathSubScript({
-                children: [prev],
-                subScript: mapGroup((_f = (_e = (_d = n.args) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.content) !== null && _f !== void 0 ? _f : []),
-            });
-        }
-        case "hat":
-            // TODO: implement
-            break;
-        case "widehat":
-            // TODO: implement
-            break;
-        case "sum": {
-            // TODO: support superscript and subscript
-            return new docx.MathSum({
-                children: [],
-            });
-        }
-        case "int":
-            return mapString("∫");
-        case "frac":
-        case "tfrac":
-        case "dfrac": {
-            const args = (_g = n.args) !== null && _g !== void 0 ? _g : [];
-            if (args.length === 2 &&
-                hasCurlyBrackets(args[0]) &&
-                hasCurlyBrackets(args[1])) {
-                return new docx.MathFraction({
-                    numerator: mapGroup(args[0].content),
-                    denominator: mapGroup(args[1].content),
-                });
-            }
-            break;
-        }
-        case "sqrt": {
-            const args = (_h = n.args) !== null && _h !== void 0 ? _h : [];
-            if (args.length === 1 && hasCurlyBrackets(args[0])) {
-                return new docx.MathRadical({
-                    children: mapGroup(args[0].content),
-                });
-            }
-            if (args.length === 2 &&
-                hasSquareBrackets(args[0]) &&
-                hasCurlyBrackets(args[1])) {
-                return new docx.MathRadical({
-                    children: mapGroup(args[1].content),
-                    degree: mapGroup(args[0].content),
-                });
-            }
-            break;
-        }
-    }
-    return mapString(n.content);
-};
-const mapGroup = (nodes) => {
-    const group = [];
-    for (const c of nodes) {
-        group.push(...(mapNode(c, group) || []));
-    }
-    return group;
-};
-const mapNode = (n, runs) => {
-    switch (n.type) {
-        case "root":
-            break;
-        case "string":
-            return [mapString(n.content)];
-        case "whitespace":
-            break;
-        case "parbreak":
-            break;
-        case "comment":
-            break;
-        case "macro":
-            const run = mapMacro(n, runs);
-            if (!run) {
-                // line break
-                return false;
-            }
-            else {
-                return [run];
-            }
-        case "environment":
-        case "mathenv":
-            break;
-        case "verbatim":
-            break;
-        case "inlinemath":
-            break;
-        case "displaymath":
-            break;
-        case "group":
-            return mapGroup(n.content);
-        case "verb":
-            break;
-        default:
-            unreachable();
-    }
-    return [];
-};
-/**
- * @internal
- */
-const parseLatex = (value) => {
-    const parsed = unifiedLatexUtilParse.parseMath(value);
-    const paragraphs = [[]];
-    let runs = paragraphs[0];
-    for (const n of parsed) {
-        const res = mapNode(n, runs);
-        if (!res) {
-            // line break
-            paragraphs.push((runs = []));
-        }
-        else {
-            runs.push(...res);
-        }
-    }
-    return paragraphs;
-};
-
 const plugin = function (opts = {}) {
-    let images = {};
-    this.Compiler = (node) => {
-        return mdastToDocx(node, opts, images, parseLatex);
-    };
-    return async (node) => {
-        const imageList = [];
-        unistUtilVisit.visit(node, "image", (node) => {
-            imageList.push(node);
-        });
-        const defs = new Map();
-        unistUtilVisit.visit(node, "definition", (node) => {
-            defs.set(node.identifier, node);
-        });
-        unistUtilVisit.visit(node, "imageReference", (node) => {
-            const maybeImage = defs.get(node.identifier);
-            if (maybeImage) {
-                imageList.push(maybeImage);
-            }
-        });
-        if (imageList.length === 0) {
-            return node;
-        }
-        const imageResolver = opts.imageResolver;
-        invariant(imageResolver, "options.imageResolver is not defined.");
-        const resolved = new Set();
-        const promises = [];
-        imageList.forEach(({ url }) => {
-            if (!resolved.has(url)) {
-                resolved.add(url);
-                promises.push((async () => {
-                    const img = await imageResolver(url);
-                    return { img, url };
-                })());
-            }
-        });
-        images = (await Promise.all(promises)).reduce((acc, { img, url }) => {
-            acc[url] = img;
-            return acc;
-        }, {});
-        return node;
+    this.compiler = (node) => {
+        return mdastToDocx(node, opts);
     };
 };