remark-docx 0.0.7 → 0.1.0

package/lib/index.js

@@ -1,7 +1,9 @@
 'use strict';
 
+var tslib = require('tslib');
 var unistUtilVisit = require('unist-util-visit');
 var docx = require('docx');
+var unifiedLatexUtilParse = require('@unified-latex/unified-latex-util-parse');
 
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
@@ -23,73 +25,358 @@ function _interopNamespace(e) {
 
 var docx__namespace = /*#__PURE__*/_interopNamespace(docx);
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+const unreachable = (_) => {
+    throw new Error("unreachable");
+};
+function invariant(cond, message) {
+    if (!cond)
+        throw new Error(message);
 }
 
-var ORDERED_LIST_REF = "ordered";
-var INDENT = 0.5;
-var DEFAULT_NUMBERINGS = [
+const hasSquareBracket = (arg) => {
+    return !!arg && arg.openMark === "[" && arg.closeMark === "]";
+};
+const hasCurlyBracket = (arg) => {
+    return !!arg && arg.openMark === "{" && arg.closeMark === "}";
+};
+const mapString = (s) => new docx__namespace.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__namespace.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__namespace.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__namespace.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 &&
+                hasCurlyBracket(args[0]) &&
+                hasCurlyBracket(args[1])) {
+                return new docx__namespace.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 && hasCurlyBracket(args[0])) {
+                return new docx__namespace.MathRadical({
+                    children: mapGroup(args[0].content),
+                });
+            }
+            if (args.length === 2 &&
+                hasSquareBracket(args[0]) &&
+                hasCurlyBracket(args[1])) {
+                return new docx__namespace.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 [];
+};
+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 ORDERED_LIST_REF = "ordered";
+const INDENT = 0.5;
+const DEFAULT_NUMBERINGS = [
     {
         level: 0,
         format: docx__namespace.LevelFormat.DECIMAL,
@@ -152,25 +439,21 @@ var DEFAULT_NUMBERINGS = [
         },
     },
 ];
-var error = function (message) {
-    throw new Error(message);
-};
-function mdastToDocx(node, _a, images) {
-    var output = _a.output, title = _a.title, subject = _a.subject, creator = _a.creator, keywords = _a.keywords, description = _a.description, lastModifiedBy = _a.lastModifiedBy, revision = _a.revision, styles = _a.styles, background = _a.background;
-    var nodes = convertNodes(node.children, {
+function mdastToDocx(node, { output, title, subject, creator, keywords, description, lastModifiedBy, revision, styles, background, }, images) {
+    const nodes = convertNodes(node.children, {
         deco: {},
-        images: images,
+        images,
     });
-    var doc = new docx__namespace.Document({
-        title: title,
-        subject: subject,
-        creator: creator,
-        keywords: keywords,
-        description: description,
-        lastModifiedBy: lastModifiedBy,
-        revision: revision,
-        styles: styles,
-        background: background,
+    const doc = new docx__namespace.Document({
+        title,
+        subject,
+        creator,
+        keywords,
+        description,
+        lastModifiedBy,
+        revision,
+        styles,
+        background,
         sections: [{ children: nodes }],
         numbering: {
             config: [
@@ -189,10 +472,8 @@ function mdastToDocx(node, _a, images) {
     }
 }
 function convertNodes(nodes, ctx) {
-    var _a;
-    var results = [];
-    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-        var node = nodes_1[_i];
+    const results = [];
+    for (const node of nodes) {
         switch (node.type) {
             case "paragraph":
                 results.push(buildParagraph(node, ctx));
@@ -201,26 +482,23 @@ function convertNodes(nodes, ctx) {
                 results.push(buildHeading(node, ctx));
                 break;
             case "thematicBreak":
-                results.push(buildThematicBreak(node));
+                results.push(buildThematicBreak());
                 break;
             case "blockquote":
-                results.push.apply(results, buildBlockquote(node, ctx));
+                results.push(...buildBlockquote(node, ctx));
                 break;
             case "list":
-                results.push.apply(results, buildList(node, ctx));
+                results.push(...buildList(node, ctx));
                 break;
             case "listItem":
-                error("unreachable");
-                break;
+                invariant(false, "unreachable");
             case "table":
                 results.push(buildTable(node, ctx));
                 break;
             case "tableRow":
-                error("unreachable");
-                break;
+                invariant(false, "unreachable");
             case "tableCell":
-                error("unreachable");
-                break;
+                invariant(false, "unreachable");
             case "html":
                 results.push(buildHtml(node));
                 break;
@@ -245,8 +523,8 @@ function convertNodes(nodes, ctx) {
             case "emphasis":
             case "strong":
             case "delete": {
-                var type = node.type, children = node.children;
-                results.push.apply(results, convertNodes(children, __assign(__assign({}, ctx), { deco: __assign(__assign({}, ctx.deco), (_a = {}, _a[type] = true, _a)) })));
+                const { type, children } = node;
+                results.push(...convertNodes(children, Object.assign(Object.assign({}, ctx), { deco: Object.assign(Object.assign({}, ctx.deco), { [type]: true }) })));
                 break;
             }
             case "inlineCode":
@@ -254,7 +532,7 @@ function convertNodes(nodes, ctx) {
                 results.push(buildText(node.value, ctx.deco));
                 break;
             case "break":
-                results.push(buildBreak(node));
+                results.push(buildBreak());
                 break;
             case "link":
                 results.push(buildLink(node, ctx));
@@ -275,19 +553,21 @@ function convertNodes(nodes, ctx) {
                 // FIXME: unimplemented
                 break;
             case "math":
-                results.push(buildMath(node));
+                results.push(...buildMath(node));
                 break;
             case "inlineMath":
                 results.push(buildInlineMath(node));
                 break;
+            default:
+                unreachable();
+                break;
         }
     }
     return results;
 }
-function buildParagraph(_a, ctx) {
-    _a.type; var children = _a.children;
-    var list = ctx.list;
-    return new docx__namespace.Paragraph(__assign({ children: convertNodes(children, ctx) }, (list &&
+function buildParagraph({ children }, ctx) {
+    const list = ctx.list;
+    return new docx__namespace.Paragraph(Object.assign({ children: convertNodes(children, ctx) }, (list &&
         (list.ordered
             ? {
                 numbering: {
@@ -301,9 +581,8 @@ function buildParagraph(_a, ctx) {
                 },
             }))));
 }
-function buildHeading(_a, ctx) {
-    _a.type; var children = _a.children, depth = _a.depth;
-    var heading;
+function buildHeading({ children, depth }, ctx) {
+    let heading;
     switch (depth) {
         case 1:
             heading = docx__namespace.HeadingLevel.TITLE;
@@ -325,39 +604,34 @@ function buildHeading(_a, ctx) {
             break;
     }
     return new docx__namespace.Paragraph({
-        heading: heading,
+        heading,
         children: convertNodes(children, ctx),
     });
 }
-function buildThematicBreak(_a) {
-    _a.type;
+function buildThematicBreak(_) {
     return new docx__namespace.Paragraph({
         thematicBreak: true,
     });
 }
-function buildBlockquote(_a, ctx) {
-    _a.type; var children = _a.children;
+function buildBlockquote({ children }, ctx) {
     // FIXME: do nothing for now
     return convertNodes(children, ctx);
 }
-function buildList(_a, ctx) {
-    _a.type; var children = _a.children, ordered = _a.ordered; _a.start; _a.spread;
-    var list = {
+function buildList({ children, ordered, start: _start, spread: _spread }, ctx) {
+    const list = {
         level: ctx.list ? ctx.list.level + 1 : 0,
         ordered: !!ordered,
     };
-    return children.reduce(function (acc, item) {
-        acc.push.apply(acc, buildListItem(item, __assign(__assign({}, ctx), { list: list })));
+    return children.reduce((acc, item) => {
+        acc.push(...buildListItem(item, Object.assign(Object.assign({}, ctx), { list })));
         return acc;
     }, []);
 }
-function buildListItem(_a, ctx) {
-    _a.type; var children = _a.children; _a.checked; _a.spread;
+function buildListItem({ children, checked: _checked, spread: _spread }, ctx) {
     return convertNodes(children, ctx);
 }
-function buildTable(_a, ctx) {
-    _a.type; var children = _a.children, align = _a.align;
-    var cellAligns = align === null || align === void 0 ? void 0 : align.map(function (a) {
+function buildTable({ children, align }, ctx) {
+    const cellAligns = align === null || align === void 0 ? void 0 : align.map((a) => {
         switch (a) {
             case "left":
                 return docx__namespace.AlignmentType.LEFT;
@@ -370,21 +644,19 @@ function buildTable(_a, ctx) {
         }
     });
     return new docx__namespace.Table({
-        rows: children.map(function (r) {
+        rows: children.map((r) => {
             return buildTableRow(r, ctx, cellAligns);
         }),
     });
 }
-function buildTableRow(_a, ctx, cellAligns) {
-    _a.type; var children = _a.children;
+function buildTableRow({ children }, ctx, cellAligns) {
     return new docx__namespace.TableRow({
-        children: children.map(function (c, i) {
+        children: children.map((c, i) => {
             return buildTableCell(c, ctx, cellAligns === null || cellAligns === void 0 ? void 0 : cellAligns[i]);
         }),
     });
 }
-function buildTableCell(_a, ctx, align) {
-    _a.type; var children = _a.children;
+function buildTableCell({ children }, ctx, align) {
     return new docx__namespace.TableCell({
         children: [
             new docx__namespace.Paragraph({
@@ -394,110 +666,91 @@ function buildTableCell(_a, ctx, align) {
         ],
     });
 }
-function buildHtml(_a) {
-    _a.type; var value = _a.value;
+function buildHtml({ value }) {
     // FIXME: transform to text for now
     return new docx__namespace.Paragraph({
         children: [buildText(value, {})],
     });
 }
-function buildCode(_a) {
-    _a.type; var value = _a.value; _a.lang; _a.meta;
+function buildCode({ value, lang: _lang, meta: _meta }) {
     // FIXME: transform to text for now
     return new docx__namespace.Paragraph({
         children: [buildText(value, {})],
     });
 }
-function buildMath(_a) {
-    _a.type; var value = _a.value;
-    // FIXME: transform to text for now
-    return new docx__namespace.Paragraph({
-        children: [new docx__namespace.TextRun(value)],
-    });
+function buildMath({ value }) {
+    return parseLatex(value).map((runs) => new docx__namespace.Paragraph({
+        children: [
+            new docx__namespace.Math({
+                children: runs,
+            }),
+        ],
+    }));
 }
-function buildInlineMath(_a) {
-    _a.type; var value = _a.value;
-    // FIXME: transform to text for now
-    return new docx__namespace.TextRun(value);
+function buildInlineMath({ value }) {
+    return new docx__namespace.Math({
+        children: parseLatex(value).flatMap((runs) => runs),
+    });
 }
 function buildText(text, deco) {
     return new docx__namespace.TextRun({
-        text: text,
+        text,
         bold: deco.strong,
         italics: deco.emphasis,
         strike: deco.delete,
     });
 }
-function buildBreak(_a) {
-    _a.type;
+function buildBreak(_) {
     return new docx__namespace.TextRun({ text: "", break: 1 });
 }
-function buildLink(_a, ctx) {
-    _a.type; var children = _a.children, url = _a.url; _a.title;
+function buildLink({ children, url, title: _title }, ctx) {
     return new docx__namespace.ExternalHyperlink({
         link: url,
         children: convertNodes(children, ctx),
     });
 }
-function buildImage(_a, images) {
-    _a.type; var url = _a.url; _a.title; _a.alt;
-    if (!images[url]) {
-        return error("Fetch image was failed: ".concat(url));
-    }
-    var _b = images[url], image = _b.image, width = _b.width, height = _b.height;
+function buildImage({ url, title: _title, alt: _alt }, images) {
+    const img = images[url];
+    invariant(img, `Fetch image was failed: ${url}`);
+    const { image, width, height } = img;
     return new docx__namespace.ImageRun({
         data: image,
         transformation: {
-            width: width,
-            height: height,
+            width,
+            height,
         },
     });
 }
-function buildFootnote(_a, ctx) {
-    _a.type; var children = _a.children;
+function buildFootnote({ children }, ctx) {
     // FIXME: transform to paragraph for now
     return new docx__namespace.Paragraph({
         children: convertNodes(children, ctx),
     });
 }
 
-var plugin = function (opts) {
-    var _this = this;
-    if (opts === void 0) { opts = {}; }
-    var images = {};
-    this.Compiler = function (node) {
+const plugin = function (opts = {}) {
+    let images = {};
+    this.Compiler = (node) => {
         return mdastToDocx(node, opts, images);
     };
-    return function (node) { return __awaiter(_this, void 0, void 0, function () {
-        var imageList, imageResolver, imageDatas;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    imageList = [];
-                    unistUtilVisit.visit(node, "image", function (node) {
-                        imageList.push(node);
-                    });
-                    if (imageList.length === 0) {
-                        return [2 /*return*/, node];
-                    }
-                    imageResolver = opts.imageResolver;
-                    if (!imageResolver) {
-                        throw new Error("options.imageResolver is not defined.");
-                    }
-                    return [4 /*yield*/, Promise.all(imageList.map(function (_a) {
-                            var url = _a.url;
-                            return imageResolver(url);
-                        }))];
-                case 1:
-                    imageDatas = _a.sent();
-                    images = imageList.reduce(function (acc, img, i) {
-                        acc[img.url] = imageDatas[i];
-                        return acc;
-                    }, {});
-                    return [2 /*return*/, node];
-            }
+    return (node) => tslib.__awaiter(this, void 0, void 0, function* () {
+        const imageList = [];
+        unistUtilVisit.visit(node, "image", (node) => {
+            imageList.push(node);
         });
-    }); };
+        if (imageList.length === 0) {
+            return node;
+        }
+        const imageResolver = opts.imageResolver;
+        invariant(imageResolver, "options.imageResolver is not defined.");
+        const imageDatas = yield Promise.all(imageList.map(({ url }) => imageResolver(url)));
+        images = imageList.reduce((acc, img, i) => {
+            acc[img.url] = imageDatas[i];
+            return acc;
+        }, {});
+        return node;
+    });
 };
 
 module.exports = plugin;
+//# sourceMappingURL=index.js.map