remark-docx 0.1.8 → 0.2.0

package/lib/{index.mjs → index.cjs}

@@ -1,6 +1,8 @@
-import { visit } from 'unist-util-visit';
-import { MathRun, MathRadical, MathFraction, MathSum, MathSubScript, MathSuperScript, AlignmentType, LevelFormat, convertInchesToTwip, Document, Packer, Math, Paragraph, FootnoteReferenceRun, ImageRun, ExternalHyperlink, TextRun, Table, HeadingLevel, CheckBox, TableRow, TableCell } from 'docx';
-import { parseMath } from '@unified-latex/unified-latex-util-parse';
+'use strict';
+
+var unistUtilVisit = require('unist-util-visit');
+var docx = require('docx');
+var unifiedLatexUtilParse = require('@unified-latex/unified-latex-util-parse');
 
 /**
  * @internal
@@ -16,455 +18,128 @@ function invariant(cond, message) {
         throw new Error(message);
 }
 
-const hasSquareBrackets = (arg) => {
-    return !!arg && arg.openMark === "[" && arg.closeMark === "]";
+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();
+    const getId = (id) => {
+        let internalId = idToInternalId.get(id);
+        if (internalId == null) {
+            idToInternalId.set(id, (internalId = idToInternalId.size + 1));
+        }
+        return internalId;
+    };
+    return {
+        ref: (id) => {
+            return getId(id);
+        },
+        def: (id, def) => {
+            const internalId = getId(id);
+            defs.set(internalId, def);
+        },
+        footnotes: () => {
+            return defs.entries().reduce((acc, [key, def]) => {
+                acc[key] = def;
+                return acc;
+            }, {});
+        },
+    };
 };
-const hasCurlyBrackets = (arg) => {
-    return !!arg && arg.openMark === "{" && arg.closeMark === "}";
+const createNumberingRegistry = () => {
+    let counter = 1;
+    return {
+        create: () => {
+            return `${ORDERED_LIST_REF}-${counter++}`;
+        },
+        getAll: () => {
+            return Array.from({ length: counter }, (_, i) => ({
+                reference: `${ORDERED_LIST_REF}-${i}`,
+                levels: DEFAULT_NUMBERINGS,
+            }));
+        },
+    };
 };
-const mapString = (s) => new 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 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 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 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 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 MathRadical({
-                    children: mapGroup(args[0].content),
-                });
-            }
-            if (args.length === 2 &&
-                hasSquareBrackets(args[0]) &&
-                hasCurlyBrackets(args[1])) {
-                return new 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 = 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 ORDERED_LIST_REF = "ordered";
-const INDENT = 0.5;
-const DEFAULT_NUMBERINGS = [
-    {
-        level: 0,
-        format: LevelFormat.DECIMAL,
-        text: "%1.",
-        alignment: AlignmentType.START,
-    },
-    {
-        level: 1,
-        format: LevelFormat.DECIMAL,
-        text: "%2.",
-        alignment: AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: convertInchesToTwip(INDENT * 1) },
-            },
-        },
-    },
-    {
-        level: 2,
-        format: LevelFormat.DECIMAL,
-        text: "%3.",
-        alignment: AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: convertInchesToTwip(INDENT * 2) },
-            },
-        },
-    },
-    {
-        level: 3,
-        format: LevelFormat.DECIMAL,
-        text: "%4.",
-        alignment: AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: convertInchesToTwip(INDENT * 3) },
-            },
-        },
-    },
-    {
-        level: 4,
-        format: LevelFormat.DECIMAL,
-        text: "%5.",
-        alignment: AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: convertInchesToTwip(INDENT * 4) },
-            },
-        },
-    },
-    {
-        level: 5,
-        format: LevelFormat.DECIMAL,
-        text: "%6.",
-        alignment: AlignmentType.START,
-        style: {
-            paragraph: {
-                indent: { start: convertInchesToTwip(INDENT * 5) },
-            },
-        },
-    },
-];
-const createFootnoteRegistry = () => {
-    const idToInternalId = new Map();
-    const defs = new Map();
-    const getId = (id) => {
-        let internalId = idToInternalId.get(id);
-        if (internalId == null) {
-            idToInternalId.set(id, (internalId = idToInternalId.size + 1));
-        }
-        return internalId;
-    };
-    return {
-        ref: (id) => {
-            return getId(id);
-        },
-        def: (id, def) => {
-            const internalId = getId(id);
-            defs.set(internalId, def);
-        },
-        footnotes: () => {
-            return defs.entries().reduce((acc, [key, def]) => {
-                acc[key] = def;
-                return acc;
-            }, {});
-        },
-    };
-};
-const mdastToDocx = async (node, { output = "buffer", title, subject, creator, keywords, description, lastModifiedBy, revision, styles, background, }, images) => {
+const mdastToDocx = async (node, { output = "buffer", title, subject, creator, keywords, description, lastModifiedBy, revision, styles, background, }, images, latex) => {
     const definition = {};
-    visit(node, "definition", (node) => {
+    unistUtilVisit.visit(node, "definition", (node) => {
         definition[node.identifier] = node.url;
     });
     const footnote = createFootnoteRegistry();
+    const numbering = createNumberingRegistry();
     const nodes = convertNodes(node.children, {
         deco: {},
         images,
         indent: 0,
         def: definition,
         footnote,
+        numbering,
+        latex,
     });
-    const doc = new Document({
+    const doc = new docx.Document({
         title,
         subject,
         creator,
@@ -477,23 +152,16 @@ const mdastToDocx = async (node, { output = "buffer", title, subject, creator, k
         footnotes: footnote.footnotes(),
         sections: [{ children: nodes }],
         numbering: {
-            config: [
-                {
-                    reference: ORDERED_LIST_REF,
-                    levels: DEFAULT_NUMBERINGS,
-                },
-            ],
+            config: numbering.getAll(),
         },
     });
     switch (output) {
         case "buffer":
-            const bufOut = await Packer.toBuffer(doc);
-            // feature detection instead of environment detection, but if Buffer exists
-            // it's probably Node. If not, return the Uint8Array that JSZip returns
-            // when it doesn't detect a Node environment.
-            return typeof Buffer === "function" ? Buffer.from(bufOut) : bufOut;
+            return docx.Packer.toBuffer(doc);
+        case "arrayBuffer":
+            return docx.Packer.toArrayBuffer(doc);
         case "blob":
-            return Packer.toBlob(doc);
+            return docx.Packer.toBlob(doc);
     }
 };
 const convertNodes = (nodes, ctx) => {
@@ -585,255 +253,605 @@ const convertNodes = (nodes, ctx) => {
                 }
                 break;
             }
-            case "footnote": {
-                // inline footnote was removed in mdast v5
-                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));
+                break;
+            default:
+                unreachable();
+                break;
+        }
+    }
+    return results;
+};
+const buildParagraph = ({ children }, ctx) => {
+    const list = ctx.list;
+    const nodes = convertNodes(children, ctx);
+    if (list && list.checked != null) {
+        nodes.unshift(new docx.CheckBox({
+            checked: list.checked,
+            checkedState: { value: "2611" },
+            uncheckedState: { value: "2610" },
+        }));
+    }
+    return new docx.Paragraph({
+        children: nodes,
+        indent: ctx.indent > 0
+            ? {
+                start: docx.convertInchesToTwip(INDENT * ctx.indent),
+            }
+            : undefined,
+        ...(list &&
+            (list.ordered
+                ? {
+                    numbering: {
+                        reference: list.reference,
+                        level: list.level,
+                    },
+                }
+                : {
+                    bullet: {
+                        level: list.level,
+                    },
+                })),
+    });
+};
+const buildHeading = ({ children, depth }, ctx) => {
+    let headingLevel;
+    switch (depth) {
+        case 1:
+            headingLevel = docx.HeadingLevel.TITLE;
+            break;
+        case 2:
+            headingLevel = docx.HeadingLevel.HEADING_1;
+            break;
+        case 3:
+            headingLevel = docx.HeadingLevel.HEADING_2;
+            break;
+        case 4:
+            headingLevel = docx.HeadingLevel.HEADING_3;
+            break;
+        case 5:
+            headingLevel = docx.HeadingLevel.HEADING_4;
+            break;
+        case 6:
+            headingLevel = docx.HeadingLevel.HEADING_5;
+            break;
+    }
+    const nodes = convertNodes(children, ctx);
+    return new docx.Paragraph({
+        heading: headingLevel,
+        children: nodes,
+    });
+};
+const buildThematicBreak = (_) => {
+    return new docx.Paragraph({
+        thematicBreak: true,
+    });
+};
+const buildBlockquote = ({ children }, ctx) => {
+    return convertNodes(children, {
+        ...ctx,
+        indent: ctx.indent + 1,
+    });
+};
+const buildList = ({ children, ordered, start: _start, spread: _spread }, ctx) => {
+    var _a;
+    const isTopLevel = !ctx.list;
+    const list = {
+        level: ctx.list ? ctx.list.level + 1 : 0,
+        ordered: !!ordered,
+        reference: isTopLevel && ordered
+            ? ctx.numbering.create()
+            : ((_a = ctx.list) === null || _a === void 0 ? void 0 : _a.reference) || ORDERED_LIST_REF,
+    };
+    return children.flatMap((item) => {
+        return buildListItem(item, {
+            ...ctx,
+            list,
+        });
+    });
+};
+const buildListItem = ({ children, checked, spread: _spread }, ctx) => {
+    return convertNodes(children, {
+        ...ctx,
+        ...(ctx.list && { list: { ...ctx.list, checked: checked !== null && checked !== void 0 ? checked : undefined } }),
+    });
+};
+const buildTable = ({ children, align }, ctx) => {
+    const cellAligns = align === null || align === void 0 ? void 0 : align.map((a) => {
+        switch (a) {
+            case "left":
+                return docx.AlignmentType.LEFT;
+            case "right":
+                return docx.AlignmentType.RIGHT;
+            case "center":
+                return docx.AlignmentType.CENTER;
+            default:
+                return docx.AlignmentType.LEFT;
+        }
+    });
+    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]);
+        }),
+    });
+};
+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({
+        children: [buildText(value, {})],
+    });
+};
+const buildCode = ({ value, lang: _lang, meta: _meta, }) => {
+    // FIXME: transform to text for now
+    return new docx.Paragraph({
+        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,
+        bold: deco.strong,
+        italics: deco.emphasis,
+        strike: deco.delete,
+    });
+};
+const buildBreak = (_) => {
+    return new docx.TextRun({ text: "", break: 1 });
+};
+const buildLink = ({ children, url }, ctx) => {
+    const nodes = convertNodes(children, ctx);
+    return new docx.ExternalHyperlink({
+        link: url,
+        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];
+    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);
+};
+const registerFootnoteDefinition = ({ children, identifier }, ctx) => {
+    const definition = {
+        children: children.map((node) => {
+            // Convert each node and extract the first result as a paragraph
+            const nodes = convertNodes([node], ctx);
+            if (nodes[0] instanceof docx.Paragraph) {
+                return nodes[0];
+            }
+            // For non-paragraph content, wrap in a paragraph
+            return new docx.Paragraph({ children: nodes });
+        }),
+    };
+    ctx.footnote.def(identifier, definition);
+};
+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),
+                });
             }
-            case "footnoteReference":
-                results.push(buildFootnoteReference(node, ctx));
-                break;
-            case "math":
-                results.push(...buildMath(node));
-                break;
-            case "inlineMath":
-                results.push(buildInlineMath(node));
-                break;
-            default:
-                unreachable();
-                break;
+            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 results;
+    return mapString(n.content);
 };
-const buildParagraph = ({ children }, ctx) => {
-    const list = ctx.list;
-    const nodes = convertNodes(children, ctx);
-    if (list && list.checked != null) {
-        nodes.unshift(new CheckBox({
-            checked: list.checked,
-            checkedState: { value: "2611" },
-            uncheckedState: { value: "2610" },
-        }));
+const mapGroup = (nodes) => {
+    const group = [];
+    for (const c of nodes) {
+        group.push(...(mapNode(c, group) || []));
     }
-    return new Paragraph({
-        children: nodes,
-        indent: ctx.indent > 0
-            ? {
-                start: convertInchesToTwip(INDENT * ctx.indent),
-            }
-            : undefined,
-        ...(list &&
-            (list.ordered
-                ? {
-                    numbering: {
-                        reference: ORDERED_LIST_REF,
-                        level: list.level,
-                    },
-                }
-                : {
-                    bullet: {
-                        level: list.level,
-                    },
-                })),
-    });
+    return group;
 };
-const buildHeading = ({ children, depth }, ctx) => {
-    let headingLevel;
-    switch (depth) {
-        case 1:
-            headingLevel = HeadingLevel.TITLE;
+const mapNode = (n, runs) => {
+    switch (n.type) {
+        case "root":
             break;
-        case 2:
-            headingLevel = HeadingLevel.HEADING_1;
+        case "string":
+            return [mapString(n.content)];
+        case "whitespace":
             break;
-        case 3:
-            headingLevel = HeadingLevel.HEADING_2;
+        case "parbreak":
             break;
-        case 4:
-            headingLevel = HeadingLevel.HEADING_3;
+        case "comment":
             break;
-        case 5:
-            headingLevel = HeadingLevel.HEADING_4;
+        case "macro":
+            const run = mapMacro(n, runs);
+            if (!run) {
+                // line break
+                return false;
+            }
+            else {
+                return [run];
+            }
+        case "environment":
+        case "mathenv":
             break;
-        case 6:
-            headingLevel = HeadingLevel.HEADING_5;
+        case "verbatim":
+            break;
+        case "inlinemath":
+            break;
+        case "displaymath":
             break;
+        case "group":
+            return mapGroup(n.content);
+        case "verb":
+            break;
+        default:
+            unreachable();
     }
-    const nodes = convertNodes(children, ctx);
-    return new Paragraph({
-        heading: headingLevel,
-        children: nodes,
-    });
-};
-const buildThematicBreak = (_) => {
-    return new Paragraph({
-        thematicBreak: true,
-    });
-};
-const buildBlockquote = ({ children }, ctx) => {
-    return convertNodes(children, {
-        ...ctx,
-        indent: ctx.indent + 1,
-    });
-};
-const buildList = ({ children, ordered, start: _start, spread: _spread }, ctx) => {
-    const list = {
-        level: ctx.list ? ctx.list.level + 1 : 0,
-        ordered: !!ordered,
-    };
-    return children.flatMap((item) => {
-        return buildListItem(item, {
-            ...ctx,
-            list,
-        });
-    });
-};
-const buildListItem = ({ children, checked, spread: _spread }, ctx) => {
-    return convertNodes(children, {
-        ...ctx,
-        ...(ctx.list && { list: { ...ctx.list, checked: checked !== null && checked !== void 0 ? checked : undefined } }),
-    });
+    return [];
 };
-const buildTable = ({ children, align }, ctx) => {
-    const cellAligns = align === null || align === void 0 ? void 0 : align.map((a) => {
-        switch (a) {
-            case "left":
-                return AlignmentType.LEFT;
-            case "right":
-                return AlignmentType.RIGHT;
-            case "center":
-                return AlignmentType.CENTER;
-            default:
-                return AlignmentType.LEFT;
+/**
+ * @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 new Table({
-        rows: children.map((r) => {
-            return buildTableRow(r, ctx, cellAligns);
-        }),
-    });
-};
-const buildTableRow = ({ children }, ctx, cellAligns) => {
-    return new TableRow({
-        children: children.map((c, i) => {
-            return buildTableCell(c, ctx, cellAligns === null || cellAligns === void 0 ? void 0 : cellAligns[i]);
-        }),
-    });
-};
-const buildTableCell = ({ children }, ctx, align) => {
-    const nodes = convertNodes(children, ctx);
-    return new TableCell({
-        children: [
-            new Paragraph({
-                alignment: align,
-                children: nodes,
-            }),
-        ],
-    });
-};
-const buildHtml = ({ value }) => {
-    // FIXME: transform to text for now
-    return new Paragraph({
-        children: [buildText(value, {})],
-    });
-};
-const buildCode = ({ value, lang: _lang, meta: _meta, }) => {
-    // FIXME: transform to text for now
-    return new Paragraph({
-        children: [buildText(value, {})],
-    });
-};
-const buildMath = ({ value }) => {
-    return parseLatex(value).map((runs) => new Paragraph({
-        children: [
-            new Math({
-                children: runs,
-            }),
-        ],
-    }));
-};
-const buildInlineMath = ({ value }) => {
-    return new Math({
-        children: parseLatex(value).flatMap((runs) => runs),
-    });
-};
-const buildText = (text, deco) => {
-    return new TextRun({
-        text,
-        bold: deco.strong,
-        italics: deco.emphasis,
-        strike: deco.delete,
-    });
-};
-const buildBreak = (_) => {
-    return new TextRun({ text: "", break: 1 });
-};
-const buildLink = ({ children, url }, ctx) => {
-    const nodes = convertNodes(children, ctx);
-    return new ExternalHyperlink({
-        link: url,
-        children: nodes,
-    });
-};
-const buildImage = ({ url }, images) => {
-    const img = images[url];
-    invariant(img, `Fetch image was failed: ${url}`);
-    const { image, width, height } = img;
-    return new ImageRun({
-        data: image,
-        transformation: {
-            width,
-            height,
-        },
-    });
-};
-const buildLinkReference = ({ children, identifier }, ctx) => {
-    const def = ctx.def[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);
-};
-const registerFootnoteDefinition = ({ children, identifier }, ctx) => {
-    const definition = {
-        children: children.map((node) => {
-            // Convert each node and extract the first result as a paragraph
-            const nodes = convertNodes([node], ctx);
-            if (nodes[0] instanceof Paragraph) {
-                return nodes[0];
-            }
-            // For non-paragraph content, wrap in a paragraph
-            return new Paragraph({ children: nodes });
-        }),
-    };
-    ctx.footnote.def(identifier, definition);
-};
-const buildFootnoteReference = ({ identifier }, ctx) => {
-    return new FootnoteReferenceRun(ctx.footnote.ref(identifier));
+    return paragraphs;
 };
 
 const plugin = function (opts = {}) {
     let images = {};
     this.Compiler = (node) => {
-        return mdastToDocx(node, opts, images);
+        return mdastToDocx(node, opts, images, parseLatex);
     };
     return async (node) => {
         const imageList = [];
-        visit(node, "image", (node) => {
+        unistUtilVisit.visit(node, "image", (node) => {
             imageList.push(node);
         });
         const defs = new Map();
-        visit(node, "definition", (node) => {
+        unistUtilVisit.visit(node, "definition", (node) => {
             defs.set(node.identifier, node);
         });
-        visit(node, "imageReference", (node) => {
+        unistUtilVisit.visit(node, "imageReference", (node) => {
             const maybeImage = defs.get(node.identifier);
             if (maybeImage) {
                 imageList.push(maybeImage);
@@ -863,5 +881,5 @@ const plugin = function (opts = {}) {
     };
 };
 
-export { plugin as default };
-//# sourceMappingURL=index.mjs.map
+module.exports = plugin;
+//# sourceMappingURL=index.cjs.map