@fiduswriter/document 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/exporter/pandoc/convert.js

@@ -0,0 +1,886 @@
+import { convertContributor, convertText } from "./tools.js";
+export class PandocExporterConvert {
+    exporter;
+    settings;
+    imageDB;
+    bibDB;
+    imageIds;
+    usedBibDB;
+    internalLinks;
+    categoryCounter;
+    metaData;
+    constructor(exporter, imageDB, bibDB, settings) {
+        this.exporter = exporter;
+        this.settings = settings;
+        this.imageDB = imageDB;
+        this.bibDB = bibDB;
+        this.imageIds = [];
+        this.usedBibDB = {};
+        this.internalLinks = [];
+        this.categoryCounter = {}; // counters for each type of figure (figure/table/photo)
+        this.metaData = {
+            toc: []
+        };
+    }
+    init(doc) {
+        this.preWalkJson(doc);
+        const meta = {
+            lang: {
+                t: "MetaInlines",
+                c: [{ t: "Str", c: this.settings.language.split("-")[0] }]
+            }
+        };
+        const json = {
+            "pandoc-api-version": [1, 23, 1],
+            meta,
+            blocks: this.convertContent(doc.content, meta)
+        };
+        const returnObject = {
+            json,
+            imageIds: this.imageIds,
+            usedBibDB: this.usedBibDB
+        };
+        return returnObject;
+    }
+    // Find information for meta tags in header
+    preWalkJson(node) {
+        switch (node.type) {
+            case "heading1":
+            case "heading2":
+            case "heading3":
+            case "heading4":
+            case "heading5":
+            case "heading6": {
+                const level = Number.parseInt(node.type.slice(-1));
+                this.metaData.toc.push({
+                    t: "Header",
+                    c: [
+                        level,
+                        [node.attrs.id || "", [], []],
+                        this.convertContent(node.content || [], {})
+                    ]
+                });
+                break;
+            }
+            default:
+                break;
+        }
+        if (node.content) {
+            node.content.forEach((child) => this.preWalkJson(child));
+        }
+    }
+    // Function to convert Fidus Writer content to Pandoc format
+    convertContent(docContent, meta, options = { inFootnote: false, inCode: false }) {
+        const pandocContent = [];
+        for (const node of docContent) {
+            switch (node.type) {
+                case "doc":
+                    // We only handle doc children
+                    break;
+                case "blockquote": {
+                    pandocContent.push({
+                        t: "BlockQuote",
+                        c: this.convertContent(node.content, meta, options)
+                    });
+                    break;
+                }
+                case "bullet_list": {
+                    const c = [];
+                    pandocContent.push({
+                        t: "BulletList",
+                        c
+                    });
+                    if (node.content) {
+                        node.content.forEach((listItem) => c.push(this.convertContent(listItem.content || [], meta, options)));
+                    }
+                    break;
+                }
+                case "citation": {
+                    if (options.inFootnote) {
+                        // TODO: handle citations in footnotes
+                        break;
+                    }
+                    const cit = this.exporter.citations.pmCits.shift();
+                    const pandocReferences = node.attrs.references
+                        .map((reference) => {
+                        const bibDBEntry = this.bibDB.db[reference.id];
+                        if (!bibDBEntry) {
+                            // Not present in bibliography database, skip it.
+                            return false;
+                        }
+                        if (!this.usedBibDB[reference.id]) {
+                            const citationKey = this.createUniqueCitationKey(bibDBEntry.entry_key);
+                            this.usedBibDB[reference.id] = Object.assign({}, bibDBEntry);
+                            this.usedBibDB[reference.id].entry_key =
+                                citationKey;
+                        }
+                        return {
+                            citationId: this.usedBibDB[reference.id].entry_key,
+                            citationPrefix: convertText(reference.prefix || ""),
+                            citationSuffix: convertText(reference.locator || ""),
+                            citationMode: {
+                                t: node.attrs.format === "textcite"
+                                    ? "AuthorInText"
+                                    : "NormalCitation"
+                            },
+                            citationNoteNum: 1,
+                            citationHash: 0
+                        };
+                    })
+                        .filter((reference) => reference);
+                    if (!pandocReferences.length) {
+                        break;
+                    }
+                    const pandocRendering = this.convertContent(cit.content, meta, options);
+                    const pandocElement = {
+                        t: "Cite",
+                        c: [pandocReferences, pandocRendering]
+                    };
+                    if (node.content) {
+                        this.convertContent(node.content, meta, options).forEach((el) => pandocElement.c.push(el));
+                    }
+                    pandocContent.push(pandocElement);
+                    break;
+                }
+                case "code_block": {
+                    options = Object.assign({}, options);
+                    options.inCode = true;
+                    const classes = node.attrs.language
+                        ? [node.attrs.language]
+                        : [];
+                    const keyValuePairs = [];
+                    // Add caption if title is present
+                    if (node.attrs.title) {
+                        keyValuePairs.push(["caption", node.attrs.title]);
+                    }
+                    // Add category as custom attribute for round-trip fidelity
+                    if (node.attrs.category) {
+                        keyValuePairs.push(["category", node.attrs.category]);
+                    }
+                    // Use id if present, otherwise empty string
+                    const id = node.attrs.id || "";
+                    const attrs = [id, classes, keyValuePairs];
+                    pandocContent.push({
+                        t: "CodeBlock",
+                        c: [
+                            attrs,
+                            this.convertContent(node.content, meta, options)
+                                .map((item) => {
+                                if (item.t === "Str") {
+                                    return item.c;
+                                }
+                                else if (item.t === "Space") {
+                                    return " ";
+                                }
+                                else if (item.t === "SoftBreak" ||
+                                    item.t === "LineBreak") {
+                                    return "\n";
+                                }
+                                return "";
+                            })
+                                .join("")
+                        ]
+                    });
+                    break;
+                }
+                case "contributor":
+                    // dealt with in contributors_part
+                    break;
+                case "contributors_part": {
+                    if (!node.content || !node.content.length) {
+                        break;
+                    }
+                    if (node.attrs.metadata === "authors") {
+                        if (!meta.author) {
+                            meta.author = { t: "MetaList", c: [] };
+                        }
+                        const convertedContributors = node.content
+                            .map((contributor) => convertContributor(contributor.attrs))
+                            .filter((convertedContributor) => convertedContributor);
+                        convertedContributors.forEach((contributor) => meta.author.c.push(contributor));
+                    }
+                    else {
+                        pandocContent.push({
+                            t: "Div",
+                            c: [
+                                [
+                                    node.attrs.id || "",
+                                    [
+                                        "doc-part",
+                                        "doc-contributors",
+                                        node.attrs.id
+                                            ? `doc-${node.attrs.id}`
+                                            : "doc-div",
+                                        `doc-${node.attrs.metadata || "other"}`
+                                    ],
+                                    []
+                                ],
+                                [
+                                    {
+                                        t: "Para",
+                                        c: convertText(node.content
+                                            .map((contributor) => `${contributor.attrs.firstname} ${contributor.attrs.lastname}, ${contributor.attrs.institution}, ${contributor.attrs.email}`)
+                                            .join("; "))
+                                    }
+                                ]
+                            ]
+                        });
+                    }
+                    break;
+                }
+                case "cross_reference": {
+                    // TODO: use real cross reference instead of link.
+                    pandocContent.push({
+                        t: "Link",
+                        c: [
+                            ["", ["reference"], []],
+                            convertText(node.attrs.title || "MISSING TARGET"),
+                            [`#${node.attrs.id || ""}`, ""]
+                        ]
+                    });
+                    break;
+                }
+                case "heading_part": {
+                    if (!node.content || !node.content.length) {
+                        break;
+                    }
+                    if (node.attrs?.metadata === "subtitle" && !meta.subtitle) {
+                        if (node.content?.length && node.content[0].content) {
+                            meta.subtitle = {
+                                t: "MetaInlines",
+                                c: this.convertContent(node.content[0].content, meta, options)
+                            };
+                        }
+                    }
+                    else {
+                        const pandocElement = {
+                            t: "Header",
+                            c: [2, [node.attrs?.metadata || "", [], []]]
+                        };
+                        if (node.content) {
+                            this.convertContent(node.content, meta, options).forEach((el) => pandocElement.c.push(el));
+                        }
+                        pandocContent.push({
+                            t: "Div",
+                            c: [
+                                [
+                                    node.attrs.id || "",
+                                    [
+                                        "doc-part",
+                                        "doc-heading",
+                                        node.attrs.id
+                                            ? `doc-${node.attrs.id}`
+                                            : "doc-div",
+                                        `doc-${node.attrs.metadata || "other"}`
+                                    ],
+                                    []
+                                ],
+                                [pandocElement]
+                            ]
+                        });
+                    }
+                    break;
+                }
+                case "equation": {
+                    pandocContent.push({
+                        t: "Span",
+                        c: [
+                            ["", ["equation"], []],
+                            [
+                                {
+                                    t: "Math",
+                                    c: [{ t: "InlineMath" }, node.attrs.equation]
+                                }
+                            ]
+                        ]
+                    });
+                    break;
+                }
+                case "figure": {
+                    const image = node.content.find((node) => node.type === "image")
+                        ?.attrs.image || false;
+                    const caption = node.attrs.caption
+                        ? node.content.find((node) => node.type === "figure_caption")?.content || []
+                        : [];
+                    const equation = node.content.find((node) => node.type === "figure_equation")?.attrs.equation;
+                    if (image !== false) {
+                        this.imageIds.push(image);
+                        const imageDBEntry = this.imageDB.db[image], filePathName = imageDBEntry.image;
+                        const copyright = imageDBEntry.copyright;
+                        const imageFilename = filePathName.toString().split("/").pop();
+                        if (node.attrs.category === "none" &&
+                            imageFilename &&
+                            !caption.length &&
+                            (!copyright || !copyright.holder)) {
+                            pandocContent.push({
+                                t: "Plain",
+                                c: [
+                                    {
+                                        t: "Image",
+                                        c: [
+                                            [
+                                                node.attrs.id || "",
+                                                [],
+                                                [
+                                                    [
+                                                        "data-width",
+                                                        String(node.attrs.width)
+                                                    ],
+                                                    [
+                                                        "width",
+                                                        `${node.attrs.width}%`
+                                                    ]
+                                                ]
+                                            ],
+                                            [],
+                                            [imageFilename, ""]
+                                        ]
+                                    }
+                                ]
+                            });
+                        }
+                        else {
+                            pandocContent.push({
+                                t: "Figure",
+                                c: [
+                                    [
+                                        node.attrs.id || "",
+                                        [
+                                            `aligned-${node.attrs.aligned}`,
+                                            `image-width-${node.attrs.width}`
+                                        ],
+                                        [
+                                            ["aligned", node.attrs.aligned],
+                                            [
+                                                "data-width",
+                                                String(node.attrs.width)
+                                            ],
+                                            ["width", `${node.attrs.width}%`],
+                                            ["category", node.attrs.category]
+                                        ]
+                                    ],
+                                    [
+                                        null,
+                                        caption.length
+                                            ? [
+                                                {
+                                                    t: "Para",
+                                                    c: this.convertContent(caption, meta, options)
+                                                }
+                                            ]
+                                            : []
+                                    ],
+                                    [
+                                        {
+                                            t: "Plain",
+                                            c: [
+                                                {
+                                                    t: "Image",
+                                                    c: [
+                                                        [
+                                                            "",
+                                                            [],
+                                                            [
+                                                                [
+                                                                    "width",
+                                                                    `${node.attrs.width}%`
+                                                                ]
+                                                            ]
+                                                        ],
+                                                        [],
+                                                        [imageFilename, ""]
+                                                    ]
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                ]
+                            });
+                        }
+                    }
+                    else if (equation) {
+                        pandocContent.push({
+                            t: "Figure",
+                            c: [
+                                [
+                                    node.attrs.id || "",
+                                    [
+                                        `aligned-${node.attrs.aligned}`,
+                                        `image-width-${node.attrs.width}`
+                                    ],
+                                    [
+                                        ["aligned", node.attrs.aligned],
+                                        [
+                                            "data-width",
+                                            String(node.attrs.width)
+                                        ],
+                                        ["width", `${node.attrs.width}%`],
+                                        ["category", node.attrs.category]
+                                    ]
+                                ],
+                                [
+                                    null,
+                                    caption.length
+                                        ? [
+                                            {
+                                                t: "Para",
+                                                c: this.convertContent(caption, meta, options)
+                                            }
+                                        ]
+                                        : []
+                                ],
+                                [
+                                    {
+                                        t: "Math",
+                                        c: [
+                                            { t: "DisplayMath" },
+                                            node.attrs.equation
+                                        ]
+                                    }
+                                ]
+                            ]
+                        });
+                    }
+                    // TODO: figure attributes like copyright info etc.
+                    break;
+                }
+                case "figure_caption":
+                case "figure_equation":
+                    // Dealt with in figure
+                    break;
+                case "footnote": {
+                    options = Object.assign({}, options);
+                    options.inFootnote = true;
+                    pandocContent.push({
+                        t: "Note",
+                        c: this.convertContent(node.attrs.footnote, meta, options)
+                    });
+                    break;
+                }
+                case "footnotecontainer":
+                    // Dealt with in footnote
+                    break;
+                case "hard_break":
+                    pandocContent.push({ t: "LineBreak" });
+                    break;
+                case "heading1":
+                case "heading2":
+                case "heading3":
+                case "heading4":
+                case "heading5":
+                case "heading6": {
+                    const level = Number.parseInt(node.type.slice(-1));
+                    pandocContent.push({
+                        t: "Header",
+                        c: [
+                            level,
+                            [node.attrs.id || "", [], []],
+                            this.convertContent(node.content || [], meta, options)
+                        ]
+                    });
+                    break;
+                }
+                case "image":
+                    // Handled by figure
+                    break;
+                case "list_item":
+                    // handled by ordered_list and bullet_list
+                    break;
+                case "ordered_list": {
+                    const c = [];
+                    pandocContent.push({
+                        t: "OrderedList",
+                        c: [
+                            [
+                                node.attrs?.order || 1,
+                                { t: "DefaultStyle" },
+                                { t: "DefaultDelim" }
+                            ], // list attributes
+                            c
+                        ]
+                    });
+                    if (node.content) {
+                        node.content.forEach((listItem) => c.push(this.convertContent(listItem.content || [], meta, options)));
+                    }
+                    break;
+                }
+                case "paragraph": {
+                    pandocContent.push({
+                        t: "Para",
+                        c: node.content
+                            ? this.convertContent(node.content, meta, options)
+                            : []
+                    });
+                    break;
+                }
+                case "richtext_part": {
+                    if (!node.content || !node.content.length) {
+                        break;
+                    }
+                    if (node.attrs?.metadata === "abstract" && !meta.abstract) {
+                        meta.abstract = {
+                            t: "MetaBlocks",
+                            c: this.convertContent(node.content, meta, options)
+                        };
+                    }
+                    else {
+                        pandocContent.push({
+                            t: "Div",
+                            c: [
+                                [
+                                    node.attrs.id || "",
+                                    [
+                                        "doc-part",
+                                        "doc-richtext",
+                                        node.attrs.id
+                                            ? `doc-${node.attrs.id}`
+                                            : "doc-div",
+                                        `doc-${node.attrs.metadata || "other"}`
+                                    ],
+                                    []
+                                ],
+                                this.convertContent(node.content, meta, options)
+                            ]
+                        });
+                    }
+                    break;
+                }
+                case "separator_part":
+                    pandocContent.push({
+                        t: "HorizontalRule",
+                        c: [
+                            [
+                                node.attrs.id || "",
+                                [
+                                    "doc-part",
+                                    "doc-separator",
+                                    node.attrs.id
+                                        ? `doc-${node.attrs.id}`
+                                        : "doc-hr",
+                                    `doc-${node.attrs.metadata || "other"}`
+                                ],
+                                []
+                            ],
+                            []
+                        ]
+                    });
+                    break;
+                case "tag":
+                    // Handled by tags_part
+                    break;
+                case "tags_part": {
+                    if (!node.content || !node.content.length) {
+                        break;
+                    }
+                    pandocContent.push({
+                        t: "Div",
+                        c: [
+                            [
+                                node.attrs.id || "",
+                                [
+                                    "doc-part",
+                                    "doc-tags",
+                                    node.attrs.id
+                                        ? `doc-${node.attrs.id}`
+                                        : "doc-div",
+                                    `doc-${node.attrs.metadata || "other"}`
+                                ],
+                                []
+                            ],
+                            [
+                                {
+                                    t: "Para",
+                                    c: convertText(node.content
+                                        .map((tag) => tag.attrs.tag)
+                                        .join("; "))
+                                }
+                            ]
+                        ]
+                    });
+                    break;
+                }
+                case "table": {
+                    // Tables seem to have this structure in pandoc json:
+                    // If table has no rows with content, skip.
+                    const tableBodyNode = node.content.find((childNode) => childNode.type === "table_body" &&
+                        childNode.content &&
+                        childNode.content.length);
+                    const tableFirstRow = tableBodyNode
+                        ? tableBodyNode.content.find((childNode) => childNode.type === "table_row" &&
+                            childNode.content &&
+                            childNode.content.length)
+                        : false;
+                    if (!tableFirstRow) {
+                        break;
+                    }
+                    const c = [];
+                    pandocContent.push({
+                        t: "Table",
+                        c
+                    });
+                    // child 0: attributes of the table.
+                    c.push([
+                        node.attrs.id || "",
+                        [
+                            `table-${node.attrs.width}`,
+                            `table-${node.attrs.aligned}`,
+                            `table-${node.attrs.layout}`
+                        ],
+                        [
+                            ["data-width", String(node.attrs.width)],
+                            ["width", `${node.attrs.width}%`],
+                            ["aligned", node.attrs.aligned],
+                            ["layout", node.attrs.layout],
+                            ["category", node.attrs.category]
+                        ]
+                    ]);
+                    // child 1: table caption
+                    const tableCaptionNode = node.content.find((childNode) => childNode.type === "table_caption" &&
+                        childNode.content &&
+                        childNode.content.length);
+                    if (tableCaptionNode) {
+                        c.push([
+                            null,
+                            [
+                                {
+                                    t: "Plain",
+                                    c: this.convertContent(tableCaptionNode.content, meta, options)
+                                }
+                            ]
+                        ]);
+                    }
+                    else {
+                        c.push([null, []]);
+                    }
+                    // child 2: settings for each column
+                    c.push(tableFirstRow.content.map((_column) => [
+                        { t: "AlignDefault" },
+                        { t: "ColWidthDefault" }
+                    ]));
+                    // child 3: ?
+                    c.push([["", [], []], []]);
+                    // child 4: Each child represents one table row
+                    const tableHead = [];
+                    const tableBody = [];
+                    c.push([["", [], []], 0, tableHead, tableBody]);
+                    let currentTablePart = tableHead;
+                    this.convertContent(tableBodyNode.content, meta, options).forEach((row, index) => {
+                        if (currentTablePart === tableHead &&
+                            tableBodyNode.content[index].content?.find((node) => node.type === "table_cell")) {
+                            // If at least one regular table cell is found in the row, we assume the table header hs finished.
+                            currentTablePart = tableBody;
+                        }
+                        currentTablePart.push(row);
+                    });
+                    // last child: Unclear meaning
+                    c.push([["", [], []], []]);
+                    // Don't process content as we do that by calling convertContent above already.
+                    //processContent = false
+                    break;
+                }
+                case "table_body":
+                case "table_caption":
+                    // Handled directly through table tag.
+                    break;
+                case "table_cell":
+                case "table_header": {
+                    if (node.content) {
+                        pandocContent.push([
+                            ["", [], []],
+                            { t: "AlignDefault" },
+                            node.attrs?.rowspan || 1,
+                            node.attrs?.colspan || 1,
+                            this.convertContent(node.content, meta, options)
+                        ]);
+                    }
+                    break;
+                }
+                case "table_part":
+                    pandocContent.push({
+                        t: "Div",
+                        c: [
+                            [
+                                node.attrs.id || "",
+                                [
+                                    "doc-part",
+                                    "doc-table",
+                                    node.attrs.id
+                                        ? `doc-${node.attrs.id}`
+                                        : "doc-div",
+                                    `doc-${node.attrs.metadata || "other"}`
+                                ],
+                                []
+                            ],
+                            this.convertContent(node.content, meta, options)
+                        ]
+                    });
+                    break;
+                case "table_of_contents": {
+                    pandocContent.push({
+                        t: "Div",
+                        c: [
+                            [
+                                node.attrs.id || "",
+                                [
+                                    "doc-part",
+                                    "doc-table-of-contents",
+                                    node.attrs.id
+                                        ? `doc-${node.attrs.id}`
+                                        : "doc-div",
+                                    `doc-${node.attrs.metadata || "other"}`
+                                ],
+                                []
+                            ],
+                            [
+                                {
+                                    t: "Header",
+                                    c: [
+                                        1,
+                                        ["", ["toc"], []],
+                                        convertText(node.attrs.title)
+                                    ]
+                                }
+                            ].concat(this.metaData.toc)
+                        ]
+                    });
+                    break;
+                }
+                case "table_row": {
+                    pandocContent.push([
+                        ["", [], []],
+                        this.convertContent(node.content, meta, options)
+                    ]);
+                    break;
+                }
+                case "text": {
+                    if (node.text) {
+                        let containerContent = pandocContent;
+                        let strong, em, underline, hyperlink, anchor, sup, sub, code;
+                        if (node.marks) {
+                            strong = node.marks.find((mark) => mark.type === "strong");
+                            em = node.marks.find((mark) => mark.type === "em");
+                            underline = node.marks.find((mark) => mark.type === "underline");
+                            hyperlink = node.marks.find((mark) => mark.type === "link");
+                            anchor = node.marks.find((mark) => mark.type === "anchor");
+                            sup = node.marks.find((mark) => mark.type === "sup");
+                            sub = node.marks.find((mark) => mark.type === "sub");
+                            code = node.marks.find((mark) => mark.type === "code");
+                        }
+                        if (em) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Emph",
+                                c
+                            });
+                            containerContent = c;
+                        }
+                        if (strong) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Strong",
+                                c
+                            });
+                            containerContent = c;
+                        }
+                        if (underline) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Underline",
+                                c
+                            });
+                            containerContent = c;
+                        }
+                        if (sup) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Superscript",
+                                c
+                            });
+                            containerContent = c;
+                        }
+                        if (sub) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Subscript",
+                                c
+                            });
+                            containerContent = c;
+                        }
+                        if (code && !options.inCode) {
+                            containerContent.push({
+                                t: "Code",
+                                c: [["", [], []], node.text]
+                            });
+                            break;
+                        }
+                        if (hyperlink) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Link",
+                                c: [["", [], []], c, [hyperlink.attrs.href, ""]]
+                            });
+                            containerContent = c;
+                        }
+                        if (anchor) {
+                            const c = [];
+                            containerContent.push({
+                                t: "Span",
+                                c: [[anchor.attrs.id, [], []], c]
+                            });
+                            containerContent = c;
+                        }
+                        if (options.inCode) {
+                            containerContent.push({
+                                t: "Code",
+                                c: [["", [], []], node.text]
+                            });
+                        }
+                        else {
+                            containerContent.push(...convertText(node.text || ""));
+                        }
+                    }
+                    break;
+                }
+                case "title": {
+                    if (!node.content || !node.content.length) {
+                        break;
+                    }
+                    if (!meta.title) {
+                        meta.title = {
+                            t: "MetaInlines",
+                            c: this.convertContent(node.content, meta, options)
+                        };
+                    }
+                    else {
+                        const pandocElement = {
+                            t: "Header",
+                            c: [1, ["title", [], []]]
+                        };
+                        if (node.content) {
+                            this.convertContent(node.content, meta, options).forEach((el) => pandocElement.c.push(el));
+                        }
+                        pandocContent.push(pandocElement);
+                    }
+                    break;
+                }
+                default: {
+                    console.warn(`Not handled: ${node.type}`, { node });
+                    break;
+                }
+            }
+        }
+        return pandocContent;
+    }
+    createUniqueCitationKey(suggestedKey) {
+        suggestedKey = suggestedKey || "key";
+        const usedKeys = Object.keys(this.usedBibDB).map(key => this.usedBibDB[key].entry_key);
+        if (usedKeys.includes(suggestedKey)) {
+            suggestedKey += "X";
+            return this.createUniqueCitationKey(suggestedKey);
+        }
+        else {
+            return suggestedKey;
+        }
+    }
+}
+//# sourceMappingURL=convert.js.map