@bnsights/bbsf-utilities 1.0.31 → 1.0.33

package/esm2015/lib/shared/config/word/helpers/xml-builder.js

@@ -0,0 +1,1765 @@
+import { __awaiter, __rest } from "tslib";
+/* eslint-disable no-await-in-loop */
+/* eslint-disable radix */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-case-declarations */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-else-return */
+import { fragment } from 'xmlbuilder2';
+import isVNode from 'virtual-dom/vnode/is-vnode';
+import isVText from 'virtual-dom/vnode/is-vtext';
+import colorNames from 'color-name';
+import { cloneDeep } from 'lodash';
+import imageToBase64 from 'image-to-base64';
+import mimeTypes from 'mime-types';
+import sizeOf from 'image-size';
+import namespaces from '../namespaces';
+import { rgbToHex, hslToHex, hslRegex, rgbRegex, hexRegex, hex3Regex, hex3ToHex, } from '../utils/color-conversion';
+import { pixelToEMU, pixelRegex, TWIPToEMU, percentageRegex, pointRegex, pointToHIP, HIPToTWIP, pointToTWIP, pixelToHIP, pixelToTWIP, pixelToEIP, pointToEIP, cmToTWIP, cmRegex, inchRegex, inchToTWIP, } from '../utils/unit-conversion';
+// FIXME: remove the cyclic dependency
+// eslint-disable-next-line import/no-cycle
+import { buildImage, buildList } from './render-document-file';
+import { defaultFont, hyperlinkType, paragraphBordersObject, colorlessColors, verticalAlignValues, imageType, internalRelationship, } from '../constants';
+import { vNodeHasChildren } from '../utils/vnode';
+import { isValidUrl } from '../utils/url';
+// eslint-disable-next-line consistent-return
+const fixupColorCode = (colorCodeString) => {
+    if (Object.prototype.hasOwnProperty.call(colorNames, colorCodeString.toLowerCase())) {
+        const [red, green, blue] = colorNames[colorCodeString.toLowerCase()];
+        return rgbToHex(red, green, blue);
+    }
+    else if (rgbRegex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(rgbRegex);
+        const red = matchedParts[1];
+        const green = matchedParts[2];
+        const blue = matchedParts[3];
+        return rgbToHex(red, green, blue);
+    }
+    else if (hslRegex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(hslRegex);
+        const hue = matchedParts[1];
+        const saturation = matchedParts[2];
+        const luminosity = matchedParts[3];
+        return hslToHex(hue, saturation, luminosity);
+    }
+    else if (hexRegex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(hexRegex);
+        return matchedParts[1];
+    }
+    else if (hex3Regex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(hex3Regex);
+        const red = matchedParts[1];
+        const green = matchedParts[2];
+        const blue = matchedParts[3];
+        return hex3ToHex(red, green, blue);
+    }
+    else {
+        return '000000';
+    }
+};
+const ɵ0 = fixupColorCode;
+const buildRunFontFragment = (fontName = defaultFont) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'rFonts')
+    .att('@w', 'ascii', fontName)
+    .att('@w', 'hAnsi', fontName)
+    .up();
+const ɵ1 = buildRunFontFragment;
+const buildRunStyleFragment = (type = 'Hyperlink') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'rStyle')
+    .att('@w', 'val', type)
+    .up();
+const ɵ2 = buildRunStyleFragment;
+const buildTableRowHeight = (tableRowHeight) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'trHeight')
+    .att('@w', 'val', tableRowHeight)
+    .att('@w', 'hRule', 'atLeast')
+    .up();
+const ɵ3 = buildTableRowHeight;
+const buildVerticalAlignment = (verticalAlignment) => {
+    if (verticalAlignment.toLowerCase() === 'middle') {
+        verticalAlignment = 'center';
+    }
+    return fragment({ namespaceAlias: { w: namespaces.w } })
+        .ele('@w', 'vAlign')
+        .att('@w', 'val', verticalAlignment)
+        .up();
+};
+const ɵ4 = buildVerticalAlignment;
+const buildVerticalMerge = (verticalMerge = 'continue') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'vMerge')
+    .att('@w', 'val', verticalMerge)
+    .up();
+const ɵ5 = buildVerticalMerge;
+const buildColor = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'color')
+    .att('@w', 'val', colorCode)
+    .up();
+const ɵ6 = buildColor;
+const buildFontSize = (fontSize) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'sz')
+    .att('@w', 'val', fontSize)
+    .up();
+const ɵ7 = buildFontSize;
+const buildShading = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'shd')
+    .att('@w', 'val', 'clear')
+    .att('@w', 'fill', colorCode)
+    .up();
+const ɵ8 = buildShading;
+const buildHighlight = (color = 'yellow') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'highlight')
+    .att('@w', 'val', color)
+    .up();
+const ɵ9 = buildHighlight;
+const buildVertAlign = (type = 'baseline') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'vertAlign')
+    .att('@w', 'val', type)
+    .up();
+const ɵ10 = buildVertAlign;
+const buildStrike = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'strike')
+    .att('@w', 'val', true)
+    .up();
+const ɵ11 = buildStrike;
+const buildBold = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'b')
+    .up();
+const ɵ12 = buildBold;
+const buildItalics = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'i')
+    .up();
+const ɵ13 = buildItalics;
+const buildUnderline = (type = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'u')
+    .att('@w', 'val', type)
+    .up();
+const ɵ14 = buildUnderline;
+const buildLineBreak = (type = 'textWrapping') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'br')
+    .att('@w', 'type', type)
+    .up();
+const ɵ15 = buildLineBreak;
+const buildBorder = (borderSide = 'top', borderSize = 0, borderSpacing = 0, borderColor = fixupColorCode('black'), borderStroke = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', borderSide)
+    .att('@w', 'val', borderStroke)
+    .att('@w', 'sz', borderSize)
+    .att('@w', 'space', borderSpacing)
+    .att('@w', 'color', borderColor)
+    .up();
+const ɵ16 = buildBorder;
+const buildTextElement = (text) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 't')
+    .att('@xml', 'space', 'preserve')
+    .txt(text)
+    .up();
+const ɵ17 = buildTextElement;
+// eslint-disable-next-line consistent-return
+const fixupLineHeight = (lineHeight, fontSize) => {
+    // FIXME: If line height is anything other than a number
+    // eslint-disable-next-line no-restricted-globals
+    if (!isNaN(lineHeight)) {
+        if (fontSize) {
+            const actualLineHeight = +lineHeight * fontSize;
+            return HIPToTWIP(actualLineHeight);
+        }
+        else {
+            // 240 TWIP or 12 point is default line height
+            return +lineHeight * 240;
+        }
+    }
+    else {
+        // 240 TWIP or 12 point is default line height
+        return 240;
+    }
+};
+const ɵ18 = fixupLineHeight;
+// eslint-disable-next-line consistent-return
+const fixupFontSize = (fontSizeString) => {
+    if (pointRegex.test(fontSizeString)) {
+        const matchedParts = fontSizeString.match(pointRegex);
+        // convert point to half point
+        return pointToHIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(fontSizeString)) {
+        const matchedParts = fontSizeString.match(pixelRegex);
+        // convert pixels to half point
+        return pixelToHIP(matchedParts[1]);
+    }
+};
+const ɵ19 = fixupFontSize;
+// eslint-disable-next-line consistent-return
+const fixupRowHeight = (rowHeightString) => {
+    if (pointRegex.test(rowHeightString)) {
+        const matchedParts = rowHeightString.match(pointRegex);
+        // convert point to half point
+        return pointToTWIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(rowHeightString)) {
+        const matchedParts = rowHeightString.match(pixelRegex);
+        // convert pixels to half point
+        return pixelToTWIP(matchedParts[1]);
+    }
+    else if (cmRegex.test(rowHeightString)) {
+        const matchedParts = rowHeightString.match(cmRegex);
+        return cmToTWIP(matchedParts[1]);
+    }
+    else if (inchRegex.test(rowHeightString)) {
+        const matchedParts = rowHeightString.match(inchRegex);
+        return inchToTWIP(matchedParts[1]);
+    }
+};
+const ɵ20 = fixupRowHeight;
+// eslint-disable-next-line consistent-return
+const fixupColumnWidth = (columnWidthString) => {
+    if (pointRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(pointRegex);
+        return pointToTWIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(pixelRegex);
+        return pixelToTWIP(matchedParts[1]);
+    }
+    else if (cmRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(cmRegex);
+        return cmToTWIP(matchedParts[1]);
+    }
+    else if (inchRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(inchRegex);
+        return inchToTWIP(matchedParts[1]);
+    }
+};
+const ɵ21 = fixupColumnWidth;
+// eslint-disable-next-line consistent-return
+const fixupMargin = (marginString) => {
+    if (pointRegex.test(marginString)) {
+        const matchedParts = marginString.match(pointRegex);
+        // convert point to half point
+        return pointToTWIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(marginString)) {
+        const matchedParts = marginString.match(pixelRegex);
+        // convert pixels to half point
+        return pixelToTWIP(matchedParts[1]);
+    }
+};
+const ɵ22 = fixupMargin;
+const modifiedStyleAttributesBuilder = (vNode, attributes, options) => {
+    const modifiedAttributes = Object.assign({}, attributes);
+    // styles
+    if (isVNode(vNode) && vNode.properties && vNode.properties.style) {
+        if (vNode.properties.style.color && !colorlessColors.includes(vNode.properties.style.color)) {
+            modifiedAttributes.color = fixupColorCode(vNode.properties.style.color);
+        }
+        if (vNode.properties.style['background-color'] &&
+            !colorlessColors.includes(vNode.properties.style['background-color'])) {
+            modifiedAttributes.backgroundColor = fixupColorCode(vNode.properties.style['background-color']);
+        }
+        if (vNode.properties.style['vertical-align'] &&
+            verticalAlignValues.includes(vNode.properties.style['vertical-align'])) {
+            modifiedAttributes.verticalAlign = vNode.properties.style['vertical-align'];
+        }
+        if (vNode.properties.style['text-align'] &&
+            ['left', 'right', 'center', 'justify'].includes(vNode.properties.style['text-align'])) {
+            modifiedAttributes.textAlign = vNode.properties.style['text-align'];
+        }
+        // FIXME: remove bold check when other font weights are handled.
+        if (vNode.properties.style['font-weight'] && vNode.properties.style['font-weight'] === 'bold') {
+            modifiedAttributes.strong = vNode.properties.style['font-weight'];
+        }
+        if (vNode.properties.style['font-size']) {
+            modifiedAttributes.fontSize = fixupFontSize(vNode.properties.style['font-size']);
+        }
+        if (vNode.properties.style['line-height']) {
+            modifiedAttributes.lineHeight = fixupLineHeight(vNode.properties.style['line-height'], vNode.properties.style['font-size']
+                ? fixupFontSize(vNode.properties.style['font-size'])
+                : null);
+        }
+        if (vNode.properties.style['margin-left'] || vNode.properties.style['margin-right']) {
+            const leftMargin = fixupMargin(vNode.properties.style['margin-left']);
+            const rightMargin = fixupMargin(vNode.properties.style['margin-right']);
+            const indentation = {};
+            if (leftMargin) {
+                indentation.left = leftMargin;
+            }
+            if (rightMargin) {
+                indentation.right = rightMargin;
+            }
+            if (leftMargin || rightMargin) {
+                modifiedAttributes.indentation = indentation;
+            }
+        }
+        if (vNode.properties.style.display) {
+            modifiedAttributes.display = vNode.properties.style.display;
+        }
+        if (vNode.properties.style.width) {
+            modifiedAttributes.width = vNode.properties.style.width;
+        }
+    }
+    // paragraph only
+    if (options && options.isParagraph) {
+        if (isVNode(vNode) && vNode.tagName === 'blockquote') {
+            modifiedAttributes.indentation = { left: 284 };
+            modifiedAttributes.textAlign = 'justify';
+        }
+        else if (isVNode(vNode) && vNode.tagName === 'code') {
+            modifiedAttributes.highlightColor = 'lightGray';
+        }
+        else if (isVNode(vNode) && vNode.tagName === 'pre') {
+            modifiedAttributes.font = 'Courier';
+        }
+    }
+    return modifiedAttributes;
+};
+const ɵ23 = modifiedStyleAttributesBuilder;
+// html tag to formatting function
+// options are passed to the formatting function if needed
+const buildFormatting = (htmlTag, options) => {
+    switch (htmlTag) {
+        case 'strong':
+        case 'b':
+            return buildBold();
+        case 'em':
+        case 'i':
+            return buildItalics();
+        case 'ins':
+        case 'u':
+            return buildUnderline();
+        case 'strike':
+        case 'del':
+        case 's':
+            return buildStrike();
+        case 'sub':
+            return buildVertAlign('subscript');
+        case 'sup':
+            return buildVertAlign('superscript');
+        case 'mark':
+            return buildHighlight();
+        case 'code':
+            return buildHighlight('lightGray');
+        case 'highlightColor':
+            return buildHighlight(options && options.color ? options.color : 'lightGray');
+        case 'font':
+        case 'pre':
+            return buildRunFontFragment('Courier');
+        case 'color':
+            return buildColor(options && options.color ? options.color : 'black');
+        case 'backgroundColor':
+            return buildShading(options && options.color ? options.color : 'black');
+        case 'fontSize':
+            // does this need a unit of measure?
+            return buildFontSize(options && options.fontSize ? options.fontSize : 10);
+        case 'hyperlink':
+            return buildRunStyleFragment('Hyperlink');
+    }
+    return null;
+};
+const ɵ24 = buildFormatting;
+const buildRunProperties = (attributes) => {
+    const runPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'rPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            const options = {};
+            if (key === 'color' || key === 'backgroundColor' || key === 'highlightColor') {
+                options.color = attributes[key];
+            }
+            if (key === 'fontSize') {
+                options.fontSize = attributes[key];
+            }
+            const formattingFragment = buildFormatting(key, options);
+            if (formattingFragment) {
+                runPropertiesFragment.import(formattingFragment);
+            }
+        });
+    }
+    runPropertiesFragment.up();
+    return runPropertiesFragment;
+};
+const ɵ25 = buildRunProperties;
+const buildRun = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const runFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
+    const runPropertiesFragment = buildRunProperties(cloneDeep(attributes));
+    // case where we have recursive spans representing font changes
+    if (isVNode(vNode) && vNode.tagName === 'span') {
+        // eslint-disable-next-line no-use-before-define
+        return buildRunOrRuns(vNode, attributes, docxDocumentInstance);
+    }
+    if (isVNode(vNode) &&
+        [
+            'strong',
+            'b',
+            'em',
+            'i',
+            'u',
+            'ins',
+            'strike',
+            'del',
+            's',
+            'sub',
+            'sup',
+            'mark',
+            'blockquote',
+            'code',
+            'pre',
+        ].includes(vNode.tagName)) {
+        const runFragmentsArray = [];
+        let vNodes = [vNode];
+        // create temp run fragments to split the paragraph into different runs
+        let tempAttributes = cloneDeep(attributes);
+        let tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
+        while (vNodes.length) {
+            const tempVNode = vNodes.shift();
+            if (isVText(tempVNode)) {
+                const textFragment = buildTextElement(tempVNode.text);
+                const tempRunPropertiesFragment = buildRunProperties(Object.assign(Object.assign({}, attributes), tempAttributes));
+                tempRunFragment.import(tempRunPropertiesFragment);
+                tempRunFragment.import(textFragment);
+                runFragmentsArray.push(tempRunFragment);
+                // re initialize temp run fragments with new fragment
+                tempAttributes = cloneDeep(attributes);
+                tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
+            }
+            else if (isVNode(tempVNode)) {
+                if ([
+                    'strong',
+                    'b',
+                    'em',
+                    'i',
+                    'u',
+                    'ins',
+                    'strike',
+                    'del',
+                    's',
+                    'sub',
+                    'sup',
+                    'mark',
+                    'code',
+                    'pre',
+                ].includes(tempVNode.tagName)) {
+                    tempAttributes = {};
+                    switch (tempVNode.tagName) {
+                        case 'strong':
+                        case 'b':
+                            tempAttributes.strong = true;
+                            break;
+                        case 'i':
+                            tempAttributes.i = true;
+                            break;
+                        case 'u':
+                            tempAttributes.u = true;
+                            break;
+                        case 'sub':
+                            tempAttributes.sub = true;
+                            break;
+                        case 'sup':
+                            tempAttributes.sup = true;
+                            break;
+                    }
+                    const formattingFragment = buildFormatting(tempVNode);
+                    if (formattingFragment) {
+                        runPropertiesFragment.import(formattingFragment);
+                    }
+                    // go a layer deeper if there is a span somewhere in the children
+                }
+                else if (tempVNode.tagName === 'span') {
+                    // eslint-disable-next-line no-use-before-define
+                    const spanFragment = yield buildRunOrRuns(tempVNode, Object.assign(Object.assign({}, attributes), tempAttributes), docxDocumentInstance);
+                    // if spanFragment is an array, we need to add each fragment to the runFragmentsArray. If the fragment is an array, perform a depth first search on the array to add each fragment to the runFragmentsArray
+                    if (Array.isArray(spanFragment)) {
+                        spanFragment.flat(Infinity);
+                        runFragmentsArray.push(...spanFragment);
+                    }
+                    else {
+                        runFragmentsArray.push(spanFragment);
+                    }
+                    // do not slice and concat children since this is already accounted for in the buildRunOrRuns function
+                    // eslint-disable-next-line no-continue
+                    continue;
+                }
+            }
+            if (tempVNode.children && tempVNode.children.length) {
+                if (tempVNode.children.length > 1) {
+                    attributes = Object.assign(Object.assign({}, attributes), tempAttributes);
+                }
+                vNodes = tempVNode.children.slice().concat(vNodes);
+            }
+        }
+        if (runFragmentsArray.length) {
+            return runFragmentsArray;
+        }
+    }
+    runFragment.import(runPropertiesFragment);
+    if (isVText(vNode)) {
+        const textFragment = buildTextElement(vNode.text);
+        runFragment.import(textFragment);
+    }
+    else if (attributes && attributes.type === 'picture') {
+        let response = null;
+        const base64Uri = decodeURIComponent(vNode.properties.src);
+        if (base64Uri) {
+            response = docxDocumentInstance.createMediaFile(base64Uri);
+        }
+        if (response) {
+            docxDocumentInstance.zip
+                .folder('word')
+                .folder('media')
+                .file(response.fileNameWithExtension, Buffer.from(response.fileContent, 'base64'), {
+                createFolders: false,
+            });
+            const documentRelsId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, imageType, `media/${response.fileNameWithExtension}`, internalRelationship);
+            attributes.inlineOrAnchored = true;
+            attributes.relationshipId = documentRelsId;
+            attributes.id = response.id;
+            attributes.fileContent = response.fileContent;
+            attributes.fileNameWithExtension = response.fileNameWithExtension;
+        }
+        const { type, inlineOrAnchored } = attributes, otherAttributes = __rest(attributes, ["type", "inlineOrAnchored"]);
+        // eslint-disable-next-line no-use-before-define
+        const imageFragment = buildDrawing(inlineOrAnchored, type, otherAttributes);
+        runFragment.import(imageFragment);
+    }
+    else if (isVNode(vNode) && vNode.tagName === 'br') {
+        const lineBreakFragment = buildLineBreak();
+        runFragment.import(lineBreakFragment);
+    }
+    runFragment.up();
+    return runFragment;
+});
+const ɵ26 = buildRun;
+const buildRunOrRuns = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isVNode(vNode) && vNode.tagName === 'span') {
+        let runFragments = [];
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes);
+            const tempRunFragments = yield buildRun(childVNode, modifiedAttributes, docxDocumentInstance);
+            runFragments = runFragments.concat(Array.isArray(tempRunFragments) ? tempRunFragments : [tempRunFragments]);
+        }
+        return runFragments;
+    }
+    else {
+        const tempRunFragments = yield buildRun(vNode, attributes, docxDocumentInstance);
+        return tempRunFragments;
+    }
+});
+const ɵ27 = buildRunOrRuns;
+const buildRunOrHyperLink = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isVNode(vNode) && vNode.tagName === 'a') {
+        const relationshipId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, hyperlinkType, vNode.properties && vNode.properties.href ? vNode.properties.href : '');
+        const hyperlinkFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })
+            .ele('@w', 'hyperlink')
+            .att('@r', 'id', `rId${relationshipId}`);
+        const modifiedAttributes = Object.assign({}, attributes);
+        modifiedAttributes.hyperlink = true;
+        const runFragments = yield buildRunOrRuns(vNode.children[0], modifiedAttributes, docxDocumentInstance);
+        if (Array.isArray(runFragments)) {
+            for (let index = 0; index < runFragments.length; index++) {
+                const runFragment = runFragments[index];
+                hyperlinkFragment.import(runFragment);
+            }
+        }
+        else {
+            hyperlinkFragment.import(runFragments);
+        }
+        hyperlinkFragment.up();
+        return hyperlinkFragment;
+    }
+    const runFragments = yield buildRunOrRuns(vNode, attributes, docxDocumentInstance);
+    return runFragments;
+});
+const ɵ28 = buildRunOrHyperLink;
+const buildNumberingProperties = (levelId, numberingId) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'numPr')
+    .ele('@w', 'ilvl')
+    .att('@w', 'val', String(levelId))
+    .up()
+    .ele('@w', 'numId')
+    .att('@w', 'val', String(numberingId))
+    .up()
+    .up();
+const ɵ29 = buildNumberingProperties;
+const buildNumberingInstances = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'num')
+    .ele('@w', 'abstractNumId')
+    .up()
+    .up();
+const ɵ30 = buildNumberingInstances;
+const buildSpacing = (lineSpacing, beforeSpacing, afterSpacing) => {
+    const spacingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'spacing');
+    if (lineSpacing) {
+        spacingFragment.att('@w', 'line', lineSpacing);
+    }
+    if (beforeSpacing) {
+        spacingFragment.att('@w', 'before', beforeSpacing);
+    }
+    if (afterSpacing) {
+        spacingFragment.att('@w', 'after', afterSpacing);
+    }
+    spacingFragment.att('@w', 'lineRule', 'auto').up();
+    return spacingFragment;
+};
+const ɵ31 = buildSpacing;
+const buildIndentation = ({ left, right }) => {
+    const indentationFragment = fragment({
+        namespaceAlias: { w: namespaces.w },
+    }).ele('@w', 'ind');
+    if (left) {
+        indentationFragment.att('@w', 'left', left);
+    }
+    if (right) {
+        indentationFragment.att('@w', 'right', right);
+    }
+    indentationFragment.up();
+    return indentationFragment;
+};
+const ɵ32 = buildIndentation;
+const buildPStyle = (style = 'Normal') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'pStyle')
+    .att('@w', 'val', style)
+    .up();
+const ɵ33 = buildPStyle;
+const buildHorizontalAlignment = (horizontalAlignment) => {
+    if (horizontalAlignment === 'justify') {
+        horizontalAlignment = 'both';
+    }
+    return fragment({ namespaceAlias: { w: namespaces.w } })
+        .ele('@w', 'jc')
+        .att('@w', 'val', horizontalAlignment)
+        .up();
+};
+const ɵ34 = buildHorizontalAlignment;
+const buildParagraphBorder = () => {
+    const paragraphBorderFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'pBdr');
+    const bordersObject = cloneDeep(paragraphBordersObject);
+    Object.keys(bordersObject).forEach((borderName) => {
+        if (bordersObject[borderName]) {
+            const { size, spacing, color } = bordersObject[borderName];
+            const borderFragment = buildBorder(borderName, size, spacing, color);
+            paragraphBorderFragment.import(borderFragment);
+        }
+    });
+    paragraphBorderFragment.up();
+    return paragraphBorderFragment;
+};
+const ɵ35 = buildParagraphBorder;
+const buildParagraphProperties = (attributes) => {
+    const paragraphPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'pPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'numbering':
+                    const { levelId, numberingId } = attributes[key];
+                    const numberingPropertiesFragment = buildNumberingProperties(levelId, numberingId);
+                    paragraphPropertiesFragment.import(numberingPropertiesFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.numbering;
+                    break;
+                case 'textAlign':
+                    const horizontalAlignmentFragment = buildHorizontalAlignment(attributes[key]);
+                    paragraphPropertiesFragment.import(horizontalAlignmentFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.textAlign;
+                    break;
+                case 'backgroundColor':
+                    // Add shading to Paragraph Properties only if display is block
+                    // Essentially if background color needs to be across the row
+                    if (attributes.display === 'block') {
+                        const shadingFragment = buildShading(attributes[key]);
+                        paragraphPropertiesFragment.import(shadingFragment);
+                        // FIXME: Inner padding in case of shaded paragraphs.
+                        const paragraphBorderFragment = buildParagraphBorder();
+                        paragraphPropertiesFragment.import(paragraphBorderFragment);
+                        // eslint-disable-next-line no-param-reassign
+                        delete attributes.backgroundColor;
+                    }
+                    break;
+                case 'paragraphStyle':
+                    const pStyleFragment = buildPStyle(attributes.paragraphStyle);
+                    paragraphPropertiesFragment.import(pStyleFragment);
+                    delete attributes.paragraphStyle;
+                    break;
+                case 'indentation':
+                    const indentationFragment = buildIndentation(attributes[key]);
+                    paragraphPropertiesFragment.import(indentationFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.indentation;
+                    break;
+            }
+        });
+        const spacingFragment = buildSpacing(attributes.lineHeight, attributes.beforeSpacing, attributes.afterSpacing);
+        // eslint-disable-next-line no-param-reassign
+        delete attributes.lineHeight;
+        // eslint-disable-next-line no-param-reassign
+        delete attributes.beforeSpacing;
+        // eslint-disable-next-line no-param-reassign
+        delete attributes.afterSpacing;
+        paragraphPropertiesFragment.import(spacingFragment);
+    }
+    paragraphPropertiesFragment.up();
+    return paragraphPropertiesFragment;
+};
+const ɵ36 = buildParagraphProperties;
+const computeImageDimensions = (vNode, attributes) => {
+    const { maximumWidth, originalWidth, originalHeight } = attributes;
+    const aspectRatio = originalWidth / originalHeight;
+    const maximumWidthInEMU = TWIPToEMU(maximumWidth);
+    let originalWidthInEMU = pixelToEMU(originalWidth);
+    let originalHeightInEMU = pixelToEMU(originalHeight);
+    if (originalWidthInEMU > maximumWidthInEMU) {
+        originalWidthInEMU = maximumWidthInEMU;
+        originalHeightInEMU = Math.round(originalWidthInEMU / aspectRatio);
+    }
+    let modifiedHeight;
+    let modifiedWidth;
+    if (vNode.properties && vNode.properties.style) {
+        if (vNode.properties.style.width) {
+            if (vNode.properties.style.width !== 'auto') {
+                if (pixelRegex.test(vNode.properties.style.width)) {
+                    modifiedWidth = pixelToEMU(vNode.properties.style.width.match(pixelRegex)[1]);
+                }
+                else if (percentageRegex.test(vNode.properties.style.width)) {
+                    const percentageValue = vNode.properties.style.width.match(percentageRegex)[1];
+                    modifiedWidth = Math.round((percentageValue / 100) * originalWidthInEMU);
+                }
+            }
+            else {
+                // eslint-disable-next-line no-lonely-if
+                if (vNode.properties.style.height && vNode.properties.style.height === 'auto') {
+                    modifiedWidth = originalWidthInEMU;
+                    modifiedHeight = originalHeightInEMU;
+                }
+            }
+        }
+        if (vNode.properties.style.height) {
+            if (vNode.properties.style.height !== 'auto') {
+                if (pixelRegex.test(vNode.properties.style.height)) {
+                    modifiedHeight = pixelToEMU(vNode.properties.style.height.match(pixelRegex)[1]);
+                }
+                else if (percentageRegex.test(vNode.properties.style.height)) {
+                    const percentageValue = vNode.properties.style.width.match(percentageRegex)[1];
+                    modifiedHeight = Math.round((percentageValue / 100) * originalHeightInEMU);
+                    if (!modifiedWidth) {
+                        modifiedWidth = Math.round(modifiedHeight * aspectRatio);
+                    }
+                }
+            }
+            else {
+                // eslint-disable-next-line no-lonely-if
+                if (modifiedWidth) {
+                    if (!modifiedHeight) {
+                        modifiedHeight = Math.round(modifiedWidth / aspectRatio);
+                    }
+                }
+                else {
+                    modifiedHeight = originalHeightInEMU;
+                    modifiedWidth = originalWidthInEMU;
+                }
+            }
+        }
+        if (modifiedWidth && !modifiedHeight) {
+            modifiedHeight = Math.round(modifiedWidth / aspectRatio);
+        }
+        else if (modifiedHeight && !modifiedWidth) {
+            modifiedWidth = Math.round(modifiedHeight * aspectRatio);
+        }
+    }
+    else {
+        modifiedWidth = originalWidthInEMU;
+        modifiedHeight = originalHeightInEMU;
+    }
+    // eslint-disable-next-line no-param-reassign
+    attributes.width = modifiedWidth;
+    // eslint-disable-next-line no-param-reassign
+    attributes.height = modifiedHeight;
+};
+const ɵ37 = computeImageDimensions;
+const buildParagraph = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'p');
+    const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes, {
+        isParagraph: true,
+    });
+    const paragraphPropertiesFragment = buildParagraphProperties(modifiedAttributes);
+    paragraphFragment.import(paragraphPropertiesFragment);
+    if (isVNode(vNode) && vNodeHasChildren(vNode)) {
+        if ([
+            'span',
+            'strong',
+            'b',
+            'em',
+            'i',
+            'u',
+            'ins',
+            'strike',
+            'del',
+            's',
+            'sub',
+            'sup',
+            'mark',
+            'a',
+            'code',
+            'pre',
+        ].includes(vNode.tagName)) {
+            const runOrHyperlinkFragments = yield buildRunOrHyperLink(vNode, modifiedAttributes, docxDocumentInstance);
+            if (Array.isArray(runOrHyperlinkFragments)) {
+                for (let iteratorIndex = 0; iteratorIndex < runOrHyperlinkFragments.length; iteratorIndex++) {
+                    const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];
+                    paragraphFragment.import(runOrHyperlinkFragment);
+                }
+            }
+            else {
+                paragraphFragment.import(runOrHyperlinkFragments);
+            }
+        }
+        else if (vNode.tagName === 'blockquote') {
+            const runFragmentOrFragments = yield buildRun(vNode, attributes);
+            if (Array.isArray(runFragmentOrFragments)) {
+                for (let index = 0; index < runFragmentOrFragments.length; index++) {
+                    paragraphFragment.import(runFragmentOrFragments[index]);
+                }
+            }
+            else {
+                paragraphFragment.import(runFragmentOrFragments);
+            }
+        }
+        else {
+            for (let index = 0; index < vNode.children.length; index++) {
+                const childVNode = vNode.children[index];
+                if (childVNode.tagName === 'img') {
+                    let base64String;
+                    const imageSource = childVNode.properties.src;
+                    if (isValidUrl(imageSource)) {
+                        base64String = yield imageToBase64(imageSource).catch((error) => {
+                            // eslint-disable-next-line no-console
+                            console.warning(`skipping image download and conversion due to ${error}`);
+                        });
+                        if (base64String && mimeTypes.lookup(imageSource)) {
+                            childVNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    else {
+                        // eslint-disable-next-line no-useless-escape, prefer-destructuring
+                        base64String = imageSource.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/)[2];
+                    }
+                    const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');
+                    const imageProperties = sizeOf(imageBuffer);
+                    modifiedAttributes.maximumWidth =
+                        modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;
+                    modifiedAttributes.originalWidth = imageProperties.width;
+                    modifiedAttributes.originalHeight = imageProperties.height;
+                    computeImageDimensions(childVNode, modifiedAttributes);
+                }
+                const runOrHyperlinkFragments = yield buildRunOrHyperLink(childVNode, isVNode(childVNode) && childVNode.tagName === 'img'
+                    ? Object.assign(Object.assign({}, modifiedAttributes), { type: 'picture' }) : modifiedAttributes, docxDocumentInstance);
+                if (Array.isArray(runOrHyperlinkFragments)) {
+                    for (let iteratorIndex = 0; iteratorIndex < runOrHyperlinkFragments.length; iteratorIndex++) {
+                        const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];
+                        paragraphFragment.import(runOrHyperlinkFragment);
+                    }
+                }
+                else {
+                    paragraphFragment.import(runOrHyperlinkFragments);
+                }
+            }
+        }
+    }
+    else {
+        // In case paragraphs has to be rendered where vText is present. Eg. table-cell
+        // Or in case the vNode is something like img
+        if (isVNode(vNode) && vNode.tagName === 'img') {
+            const imageSource = vNode.properties.src;
+            let base64String = imageSource;
+            if (isValidUrl(imageSource)) {
+                base64String = yield imageToBase64(imageSource).catch((error) => {
+                    // eslint-disable-next-line no-console
+                    console.warning(`skipping image download and conversion due to ${error}`);
+                });
+                if (base64String && mimeTypes.lookup(imageSource)) {
+                    vNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
+                }
+                else {
+                    paragraphFragment.up();
+                    return paragraphFragment;
+                }
+            }
+            else {
+                // eslint-disable-next-line no-useless-escape, prefer-destructuring
+                base64String = base64String.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/)[2];
+            }
+            const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');
+            const imageProperties = sizeOf(imageBuffer);
+            modifiedAttributes.maximumWidth =
+                modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;
+            modifiedAttributes.originalWidth = imageProperties.width;
+            modifiedAttributes.originalHeight = imageProperties.height;
+            computeImageDimensions(vNode, modifiedAttributes);
+        }
+        const runFragments = yield buildRunOrRuns(vNode, modifiedAttributes, docxDocumentInstance);
+        if (Array.isArray(runFragments)) {
+            for (let index = 0; index < runFragments.length; index++) {
+                const runFragment = runFragments[index];
+                paragraphFragment.import(runFragment);
+            }
+        }
+        else {
+            paragraphFragment.import(runFragments);
+        }
+    }
+    paragraphFragment.up();
+    return paragraphFragment;
+});
+const ɵ38 = buildParagraph;
+const buildGridSpanFragment = (spanValue) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'gridSpan')
+    .att('@w', 'val', spanValue)
+    .up();
+const ɵ39 = buildGridSpanFragment;
+const buildTableCellSpacing = (cellSpacing = 0) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'tblCellSpacing')
+    .att('@w', 'w', cellSpacing)
+    .att('@w', 'type', 'dxa')
+    .up();
+const ɵ40 = buildTableCellSpacing;
+const buildTableCellBorders = (tableCellBorder) => {
+    const tableCellBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcBorders');
+    const { color, stroke } = tableCellBorder, borders = __rest(tableCellBorder, ["color", "stroke"]);
+    Object.keys(borders).forEach((border) => {
+        if (tableCellBorder[border]) {
+            const borderFragment = buildBorder(border, tableCellBorder[border], 0, color, stroke);
+            tableCellBordersFragment.import(borderFragment);
+        }
+    });
+    tableCellBordersFragment.up();
+    return tableCellBordersFragment;
+};
+const ɵ41 = buildTableCellBorders;
+const buildTableCellWidth = (tableCellWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'tcW')
+    .att('@w', 'w', fixupColumnWidth(tableCellWidth))
+    .att('@w', 'type', 'dxa')
+    .up();
+const ɵ42 = buildTableCellWidth;
+const buildTableCellProperties = (attributes) => {
+    const tableCellPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'backgroundColor':
+                    const shadingFragment = buildShading(attributes[key]);
+                    tableCellPropertiesFragment.import(shadingFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.backgroundColor;
+                    break;
+                case 'verticalAlign':
+                    const verticalAlignmentFragment = buildVerticalAlignment(attributes[key]);
+                    tableCellPropertiesFragment.import(verticalAlignmentFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.verticalAlign;
+                    break;
+                case 'colSpan':
+                    const gridSpanFragment = buildGridSpanFragment(attributes[key]);
+                    tableCellPropertiesFragment.import(gridSpanFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.colSpan;
+                    break;
+                case 'tableCellBorder':
+                    const tableCellBorderFragment = buildTableCellBorders(attributes[key]);
+                    tableCellPropertiesFragment.import(tableCellBorderFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableCellBorder;
+                    break;
+                case 'rowSpan':
+                    const verticalMergeFragment = buildVerticalMerge(attributes[key]);
+                    tableCellPropertiesFragment.import(verticalMergeFragment);
+                    delete attributes.rowSpan;
+                    break;
+                case 'width':
+                    const widthFragment = buildTableCellWidth(attributes[key]);
+                    tableCellPropertiesFragment.import(widthFragment);
+                    delete attributes.width;
+                    break;
+            }
+        });
+    }
+    tableCellPropertiesFragment.up();
+    return tableCellPropertiesFragment;
+};
+const ɵ43 = buildTableCellProperties;
+const fixupTableCellBorder = (vNode, attributes) => {
+    if (Object.prototype.hasOwnProperty.call(vNode.properties.style, 'border')) {
+        if (vNode.properties.style.border === 'none' || vNode.properties.style.border === 0) {
+            attributes.tableCellBorder = {};
+        }
+        else {
+            // eslint-disable-next-line no-use-before-define
+            const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style.border);
+            attributes.tableCellBorder = {
+                top: borderSize,
+                left: borderSize,
+                bottom: borderSize,
+                right: borderSize,
+                color: borderColor,
+                stroke: borderStroke,
+            };
+        }
+    }
+    if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { top: 0 });
+    }
+    else if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-top']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { top: borderSize, color: borderColor, stroke: borderStroke });
+    }
+    if (vNode.properties.style['border-left'] && vNode.properties.style['border-left'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { left: 0 });
+    }
+    else if (vNode.properties.style['border-left'] &&
+        vNode.properties.style['border-left'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-left']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { left: borderSize, color: borderColor, stroke: borderStroke });
+    }
+    if (vNode.properties.style['border-bottom'] && vNode.properties.style['border-bottom'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { bottom: 0 });
+    }
+    else if (vNode.properties.style['border-bottom'] &&
+        vNode.properties.style['border-bottom'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-bottom']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { bottom: borderSize, color: borderColor, stroke: borderStroke });
+    }
+    if (vNode.properties.style['border-right'] && vNode.properties.style['border-right'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: 0 });
+    }
+    else if (vNode.properties.style['border-right'] &&
+        vNode.properties.style['border-right'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-right']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: borderSize, color: borderColor, stroke: borderStroke });
+    }
+};
+const ɵ44 = fixupTableCellBorder;
+const buildTableCell = (vNode, attributes, rowSpanMap, columnIndex, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
+    let modifiedAttributes = Object.assign({}, attributes);
+    if (isVNode(vNode) && vNode.properties) {
+        if (vNode.properties.rowSpan) {
+            rowSpanMap.set(columnIndex.index, { rowSpan: vNode.properties.rowSpan - 1, colSpan: 0 });
+            modifiedAttributes.rowSpan = 'restart';
+        }
+        else {
+            const previousSpanObject = rowSpanMap.get(columnIndex.index);
+            rowSpanMap.set(columnIndex.index, 
+            // eslint-disable-next-line prefer-object-spread
+            Object.assign({}, previousSpanObject, {
+                rowSpan: 0,
+                colSpan: (previousSpanObject && previousSpanObject.colSpan) || 0,
+            }));
+        }
+        if (vNode.properties.colSpan ||
+            (vNode.properties.style && vNode.properties.style['column-span'])) {
+            modifiedAttributes.colSpan =
+                vNode.properties.colSpan ||
+                    (vNode.properties.style && vNode.properties.style['column-span']);
+            const previousSpanObject = rowSpanMap.get(columnIndex.index);
+            rowSpanMap.set(columnIndex.index, 
+            // eslint-disable-next-line prefer-object-spread
+            Object.assign({}, previousSpanObject, {
+                colSpan: parseInt(modifiedAttributes.colSpan) || 0,
+            }));
+            columnIndex.index += parseInt(modifiedAttributes.colSpan) - 1;
+        }
+        if (vNode.properties.style) {
+            modifiedAttributes = Object.assign(Object.assign({}, modifiedAttributes), modifiedStyleAttributesBuilder(vNode, attributes));
+            fixupTableCellBorder(vNode, modifiedAttributes);
+        }
+    }
+    const tableCellPropertiesFragment = buildTableCellProperties(modifiedAttributes);
+    tableCellFragment.import(tableCellPropertiesFragment);
+    if (vNodeHasChildren(vNode)) {
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            if (isVNode(childVNode) && childVNode.tagName === 'img') {
+                const imageFragment = yield buildImage(docxDocumentInstance, childVNode, modifiedAttributes.maximumWidth);
+                if (imageFragment) {
+                    tableCellFragment.import(imageFragment);
+                }
+            }
+            else if (isVNode(childVNode) && childVNode.tagName === 'figure') {
+                if (vNodeHasChildren(childVNode)) {
+                    // eslint-disable-next-line no-plusplus
+                    for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
+                        const grandChildVNode = childVNode.children[iteratorIndex];
+                        if (grandChildVNode.tagName === 'img') {
+                            const imageFragment = yield buildImage(docxDocumentInstance, grandChildVNode, modifiedAttributes.maximumWidth);
+                            if (imageFragment) {
+                                tableCellFragment.import(imageFragment);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (isVNode(childVNode) && ['ul', 'ol'].includes(childVNode.tagName)) {
+                // render list in table
+                if (vNodeHasChildren(childVNode)) {
+                    yield buildList(childVNode, docxDocumentInstance, tableCellFragment);
+                }
+            }
+            else {
+                const paragraphFragment = yield buildParagraph(childVNode, modifiedAttributes, docxDocumentInstance);
+                tableCellFragment.import(paragraphFragment);
+            }
+        }
+    }
+    else {
+        // TODO: Figure out why building with buildParagraph() isn't working
+        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+            .ele('@w', 'p')
+            .up();
+        tableCellFragment.import(paragraphFragment);
+    }
+    tableCellFragment.up();
+    return tableCellFragment;
+});
+const ɵ45 = buildTableCell;
+const buildRowSpanCell = (rowSpanMap, columnIndex, attributes) => {
+    const rowSpanCellFragments = [];
+    let spanObject = rowSpanMap.get(columnIndex.index);
+    while (spanObject && spanObject.rowSpan) {
+        const rowSpanCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
+        const tableCellPropertiesFragment = buildTableCellProperties(Object.assign(Object.assign({}, attributes), { rowSpan: 'continue', colSpan: spanObject.colSpan ? spanObject.colSpan : 0 }));
+        rowSpanCellFragment.import(tableCellPropertiesFragment);
+        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+            .ele('@w', 'p')
+            .up();
+        rowSpanCellFragment.import(paragraphFragment);
+        rowSpanCellFragment.up();
+        rowSpanCellFragments.push(rowSpanCellFragment);
+        if (spanObject.rowSpan - 1 === 0) {
+            rowSpanMap.delete(columnIndex.index);
+        }
+        else {
+            rowSpanMap.set(columnIndex.index, {
+                rowSpan: spanObject.rowSpan - 1,
+                colSpan: spanObject.colSpan || 0,
+            });
+        }
+        columnIndex.index += spanObject.colSpan || 1;
+        spanObject = rowSpanMap.get(columnIndex.index);
+    }
+    return rowSpanCellFragments;
+};
+const ɵ46 = buildRowSpanCell;
+const buildTableRowProperties = (attributes) => {
+    const tableRowPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'trPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'tableRowHeight':
+                    const tableRowHeightFragment = buildTableRowHeight(attributes[key]);
+                    tableRowPropertiesFragment.import(tableRowHeightFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableRowHeight;
+                    break;
+                case 'rowCantSplit':
+                    if (attributes.rowCantSplit) {
+                        const cantSplitFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+                            .ele('@w', 'cantSplit')
+                            .up();
+                        tableRowPropertiesFragment.import(cantSplitFragment);
+                        // eslint-disable-next-line no-param-reassign
+                        delete attributes.rowCantSplit;
+                    }
+                    break;
+            }
+        });
+    }
+    tableRowPropertiesFragment.up();
+    return tableRowPropertiesFragment;
+};
+const ɵ47 = buildTableRowProperties;
+const buildTableRow = (vNode, attributes, rowSpanMap, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableRowFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tr');
+    const modifiedAttributes = Object.assign({}, attributes);
+    if (isVNode(vNode) && vNode.properties) {
+        // FIXME: find a better way to get row height from cell style
+        if ((vNode.properties.style && vNode.properties.style.height) ||
+            (vNode.children[0] &&
+                isVNode(vNode.children[0]) &&
+                vNode.children[0].properties.style &&
+                vNode.children[0].properties.style.height)) {
+            modifiedAttributes.tableRowHeight = fixupRowHeight((vNode.properties.style && vNode.properties.style.height) ||
+                (vNode.children[0] &&
+                    isVNode(vNode.children[0]) &&
+                    vNode.children[0].properties.style &&
+                    vNode.children[0].properties.style.height
+                    ? vNode.children[0].properties.style.height
+                    : undefined));
+        }
+        if (vNode.properties.style) {
+            fixupTableCellBorder(vNode, modifiedAttributes);
+        }
+    }
+    const tableRowPropertiesFragment = buildTableRowProperties(modifiedAttributes);
+    tableRowFragment.import(tableRowPropertiesFragment);
+    const columnIndex = { index: 0 };
+    if (vNodeHasChildren(vNode)) {
+        const tableColumns = vNode.children.filter((childVNode) => ['td', 'th'].includes(childVNode.tagName));
+        const maximumColumnWidth = docxDocumentInstance.availableDocumentSpace / tableColumns.length;
+        // eslint-disable-next-line no-restricted-syntax
+        for (const column of tableColumns) {
+            const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);
+            if (Array.isArray(rowSpanCellFragments)) {
+                for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {
+                    const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];
+                    tableRowFragment.import(rowSpanCellFragment);
+                }
+            }
+            const tableCellFragment = yield buildTableCell(column, Object.assign(Object.assign({}, modifiedAttributes), { maximumWidth: maximumColumnWidth }), rowSpanMap, columnIndex, docxDocumentInstance);
+            columnIndex.index++;
+            tableRowFragment.import(tableCellFragment);
+        }
+    }
+    if (columnIndex.index < rowSpanMap.size) {
+        const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);
+        if (Array.isArray(rowSpanCellFragments)) {
+            for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {
+                const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];
+                tableRowFragment.import(rowSpanCellFragment);
+            }
+        }
+    }
+    tableRowFragment.up();
+    return tableRowFragment;
+});
+const ɵ48 = buildTableRow;
+const buildTableGridCol = (gridWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'gridCol')
+    .att('@w', 'w', String(gridWidth));
+const ɵ49 = buildTableGridCol;
+const buildTableGrid = (vNode, attributes) => {
+    const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');
+    if (vNodeHasChildren(vNode)) {
+        const gridColumns = vNode.children.filter((childVNode) => childVNode.tagName === 'col');
+        const gridWidth = attributes.maximumWidth / gridColumns.length;
+        for (let index = 0; index < gridColumns.length; index++) {
+            const tableGridColFragment = buildTableGridCol(gridWidth);
+            tableGridFragment.import(tableGridColFragment);
+        }
+    }
+    tableGridFragment.up();
+    return tableGridFragment;
+};
+const ɵ50 = buildTableGrid;
+const buildTableGridFromTableRow = (vNode, attributes) => {
+    const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');
+    if (vNodeHasChildren(vNode)) {
+        const numberOfGridColumns = vNode.children.reduce((accumulator, childVNode) => {
+            const colSpan = childVNode.properties.colSpan ||
+                (childVNode.properties.style && childVNode.properties.style['column-span']);
+            return accumulator + (colSpan ? parseInt(colSpan) : 1);
+        }, 0);
+        const gridWidth = attributes.maximumWidth / numberOfGridColumns;
+        for (let index = 0; index < numberOfGridColumns; index++) {
+            const tableGridColFragment = buildTableGridCol(gridWidth);
+            tableGridFragment.import(tableGridColFragment);
+        }
+    }
+    tableGridFragment.up();
+    return tableGridFragment;
+};
+const ɵ51 = buildTableGridFromTableRow;
+const buildTableBorders = (tableBorder) => {
+    const tableBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblBorders');
+    const { color, stroke } = tableBorder, borders = __rest(tableBorder, ["color", "stroke"]);
+    Object.keys(borders).forEach((border) => {
+        if (borders[border]) {
+            const borderFragment = buildBorder(border, borders[border], 0, color, stroke);
+            tableBordersFragment.import(borderFragment);
+        }
+    });
+    tableBordersFragment.up();
+    return tableBordersFragment;
+};
+const ɵ52 = buildTableBorders;
+const buildTableWidth = (tableWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'tblW')
+    .att('@w', 'type', 'dxa')
+    .att('@w', 'w', String(tableWidth))
+    .up();
+const ɵ53 = buildTableWidth;
+const buildCellMargin = (side, margin) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', side)
+    .att('@w', 'type', 'dxa')
+    .att('@w', 'w', String(margin))
+    .up();
+const ɵ54 = buildCellMargin;
+const buildTableCellMargins = (margin) => {
+    const tableCellMarFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblCellMar');
+    ['top', 'bottom'].forEach((side) => {
+        const marginFragment = buildCellMargin(side, margin / 2);
+        tableCellMarFragment.import(marginFragment);
+    });
+    ['left', 'right'].forEach((side) => {
+        const marginFragment = buildCellMargin(side, margin);
+        tableCellMarFragment.import(marginFragment);
+    });
+    return tableCellMarFragment;
+};
+const ɵ55 = buildTableCellMargins;
+const buildTableProperties = (attributes) => {
+    const tablePropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'tableBorder':
+                    const tableBordersFragment = buildTableBorders(attributes[key]);
+                    tablePropertiesFragment.import(tableBordersFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableBorder;
+                    break;
+                case 'tableCellSpacing':
+                    const tableCellSpacingFragment = buildTableCellSpacing(attributes[key]);
+                    tablePropertiesFragment.import(tableCellSpacingFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableCellSpacing;
+                    break;
+                case 'width':
+                    if (attributes[key]) {
+                        const tableWidthFragment = buildTableWidth(attributes[key]);
+                        tablePropertiesFragment.import(tableWidthFragment);
+                    }
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.width;
+                    break;
+            }
+        });
+    }
+    const tableCellMarginFragment = buildTableCellMargins(160);
+    tablePropertiesFragment.import(tableCellMarginFragment);
+    // by default, all tables are center aligned.
+    const alignmentFragment = buildHorizontalAlignment('center');
+    tablePropertiesFragment.import(alignmentFragment);
+    tablePropertiesFragment.up();
+    return tablePropertiesFragment;
+};
+const ɵ56 = buildTableProperties;
+const cssBorderParser = (borderString) => {
+    let [size, stroke, color] = borderString.split(' ');
+    if (pointRegex.test(size)) {
+        const matchedParts = size.match(pointRegex);
+        // convert point to eighth of a point
+        size = pointToEIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(size)) {
+        const matchedParts = size.match(pixelRegex);
+        // convert pixels to eighth of a point
+        size = pixelToEIP(matchedParts[1]);
+    }
+    stroke = stroke && ['dashed', 'dotted', 'double'].includes(stroke) ? stroke : 'single';
+    color = color && fixupColorCode(color).toUpperCase();
+    return [size, stroke, color];
+};
+const ɵ57 = cssBorderParser;
+const buildTable = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tbl');
+    const modifiedAttributes = Object.assign({}, attributes);
+    if (isVNode(vNode) && vNode.properties) {
+        const tableAttributes = vNode.properties.attributes || {};
+        const tableStyles = vNode.properties.style || {};
+        const tableBorders = {};
+        const tableCellBorders = {};
+        let [borderSize, borderStrike, borderColor] = [2, 'single', '000000'];
+        // eslint-disable-next-line no-restricted-globals
+        if (!isNaN(tableAttributes.border)) {
+            borderSize = parseInt(tableAttributes.border, 10);
+        }
+        // css style overrides table border properties
+        if (tableStyles.border) {
+            const [cssSize, cssStroke, cssColor] = cssBorderParser(tableStyles.border);
+            borderSize = cssSize || borderSize;
+            borderColor = cssColor || borderColor;
+            borderStrike = cssStroke || borderStrike;
+        }
+        tableBorders.top = borderSize;
+        tableBorders.bottom = borderSize;
+        tableBorders.left = borderSize;
+        tableBorders.right = borderSize;
+        tableBorders.stroke = borderStrike;
+        tableBorders.color = borderColor;
+        if (tableStyles['border-collapse'] === 'collapse') {
+            tableBorders.insideV = borderSize;
+            tableBorders.insideH = borderSize;
+        }
+        else {
+            tableBorders.insideV = 0;
+            tableBorders.insideH = 0;
+            tableCellBorders.top = 1;
+            tableCellBorders.bottom = 1;
+            tableCellBorders.left = 1;
+            tableCellBorders.right = 1;
+        }
+        modifiedAttributes.tableBorder = tableBorders;
+        modifiedAttributes.tableCellSpacing = 0;
+        if (Object.keys(tableCellBorders).length) {
+            modifiedAttributes.tableCellBorder = tableCellBorders;
+        }
+        let minimumWidth;
+        let maximumWidth;
+        let width;
+        // Calculate minimum width of table
+        if (pixelRegex.test(tableStyles['min-width'])) {
+            minimumWidth = pixelToTWIP(tableStyles['min-width'].match(pixelRegex)[1]);
+        }
+        else if (percentageRegex.test(tableStyles['min-width'])) {
+            const percentageValue = tableStyles['min-width'].match(percentageRegex)[1];
+            minimumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);
+        }
+        // Calculate maximum width of table
+        if (pixelRegex.test(tableStyles['max-width'])) {
+            pixelRegex.lastIndex = 0;
+            maximumWidth = pixelToTWIP(tableStyles['max-width'].match(pixelRegex)[1]);
+        }
+        else if (percentageRegex.test(tableStyles['max-width'])) {
+            percentageRegex.lastIndex = 0;
+            const percentageValue = tableStyles['max-width'].match(percentageRegex)[1];
+            maximumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);
+        }
+        // Calculate specified width of table
+        if (pixelRegex.test(tableStyles.width)) {
+            pixelRegex.lastIndex = 0;
+            width = pixelToTWIP(tableStyles.width.match(pixelRegex)[1]);
+        }
+        else if (percentageRegex.test(tableStyles.width)) {
+            percentageRegex.lastIndex = 0;
+            const percentageValue = tableStyles.width.match(percentageRegex)[1];
+            width = Math.round((percentageValue / 100) * attributes.maximumWidth);
+        }
+        // If width isn't supplied, we should have min-width as the width.
+        if (width) {
+            modifiedAttributes.width = width;
+            if (maximumWidth) {
+                modifiedAttributes.width = Math.min(modifiedAttributes.width, maximumWidth);
+            }
+            if (minimumWidth) {
+                modifiedAttributes.width = Math.max(modifiedAttributes.width, minimumWidth);
+            }
+        }
+        else if (minimumWidth) {
+            modifiedAttributes.width = minimumWidth;
+        }
+        if (modifiedAttributes.width) {
+            modifiedAttributes.width = Math.min(modifiedAttributes.width, attributes.maximumWidth);
+        }
+    }
+    const tablePropertiesFragment = buildTableProperties(modifiedAttributes);
+    tableFragment.import(tablePropertiesFragment);
+    const rowSpanMap = new Map();
+    if (vNodeHasChildren(vNode)) {
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            if (childVNode.tagName === 'colgroup') {
+                const tableGridFragment = buildTableGrid(childVNode, modifiedAttributes);
+                tableFragment.import(tableGridFragment);
+            }
+            else if (childVNode.tagName === 'thead') {
+                for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
+                    const grandChildVNode = childVNode.children[iteratorIndex];
+                    if (grandChildVNode.tagName === 'tr') {
+                        if (iteratorIndex === 0) {
+                            const tableGridFragment = buildTableGridFromTableRow(grandChildVNode, modifiedAttributes);
+                            tableFragment.import(tableGridFragment);
+                        }
+                        const tableRowFragment = yield buildTableRow(grandChildVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
+                        tableFragment.import(tableRowFragment);
+                    }
+                }
+            }
+            else if (childVNode.tagName === 'tbody') {
+                for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
+                    const grandChildVNode = childVNode.children[iteratorIndex];
+                    if (grandChildVNode.tagName === 'tr') {
+                        if (iteratorIndex === 0) {
+                            const tableGridFragment = buildTableGridFromTableRow(grandChildVNode, modifiedAttributes);
+                            tableFragment.import(tableGridFragment);
+                        }
+                        const tableRowFragment = yield buildTableRow(grandChildVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
+                        tableFragment.import(tableRowFragment);
+                    }
+                }
+            }
+            else if (childVNode.tagName === 'tr') {
+                if (index === 0) {
+                    const tableGridFragment = buildTableGridFromTableRow(childVNode, modifiedAttributes);
+                    tableFragment.import(tableGridFragment);
+                }
+                const tableRowFragment = yield buildTableRow(childVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
+                tableFragment.import(tableRowFragment);
+            }
+        }
+    }
+    tableFragment.up();
+    return tableFragment;
+});
+const ɵ58 = buildTable;
+const buildPresetGeometry = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'prstGeom')
+    .att('prst', 'rect')
+    .up();
+const ɵ59 = buildPresetGeometry;
+const buildExtents = ({ width, height }) => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'ext')
+    .att('cx', width)
+    .att('cy', height)
+    .up();
+const ɵ60 = buildExtents;
+const buildOffset = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'off')
+    .att('x', '0')
+    .att('y', '0')
+    .up();
+const ɵ61 = buildOffset;
+const buildGraphicFrameTransform = (attributes) => {
+    const graphicFrameTransformFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'xfrm');
+    const offsetFragment = buildOffset();
+    graphicFrameTransformFragment.import(offsetFragment);
+    const extentsFragment = buildExtents(attributes);
+    graphicFrameTransformFragment.import(extentsFragment);
+    graphicFrameTransformFragment.up();
+    return graphicFrameTransformFragment;
+};
+const ɵ62 = buildGraphicFrameTransform;
+const buildShapeProperties = (attributes) => {
+    const shapeProperties = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'spPr');
+    const graphicFrameTransformFragment = buildGraphicFrameTransform(attributes);
+    shapeProperties.import(graphicFrameTransformFragment);
+    const presetGeometryFragment = buildPresetGeometry();
+    shapeProperties.import(presetGeometryFragment);
+    shapeProperties.up();
+    return shapeProperties;
+};
+const ɵ63 = buildShapeProperties;
+const buildFillRect = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'fillRect')
+    .up();
+const ɵ64 = buildFillRect;
+const buildStretch = () => {
+    const stretchFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'stretch');
+    const fillRectFragment = buildFillRect();
+    stretchFragment.import(fillRectFragment);
+    stretchFragment.up();
+    return stretchFragment;
+};
+const ɵ65 = buildStretch;
+const buildSrcRectFragment = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'srcRect')
+    .att('b', '0')
+    .att('l', '0')
+    .att('r', '0')
+    .att('t', '0')
+    .up();
+const ɵ66 = buildSrcRectFragment;
+const buildBinaryLargeImageOrPicture = (relationshipId) => fragment({
+    namespaceAlias: { a: namespaces.a, r: namespaces.r },
+})
+    .ele('@a', 'blip')
+    .att('@r', 'embed', `rId${relationshipId}`)
+    // FIXME: possible values 'email', 'none', 'print', 'hqprint', 'screen'
+    .att('cstate', 'print')
+    .up();
+const ɵ67 = buildBinaryLargeImageOrPicture;
+const buildBinaryLargeImageOrPictureFill = (relationshipId) => {
+    const binaryLargeImageOrPictureFillFragment = fragment({
+        namespaceAlias: { pic: namespaces.pic },
+    }).ele('@pic', 'blipFill');
+    const binaryLargeImageOrPictureFragment = buildBinaryLargeImageOrPicture(relationshipId);
+    binaryLargeImageOrPictureFillFragment.import(binaryLargeImageOrPictureFragment);
+    const srcRectFragment = buildSrcRectFragment();
+    binaryLargeImageOrPictureFillFragment.import(srcRectFragment);
+    const stretchFragment = buildStretch();
+    binaryLargeImageOrPictureFillFragment.import(stretchFragment);
+    binaryLargeImageOrPictureFillFragment.up();
+    return binaryLargeImageOrPictureFillFragment;
+};
+const ɵ68 = buildBinaryLargeImageOrPictureFill;
+const buildNonVisualPictureDrawingProperties = () => fragment({ namespaceAlias: { pic: namespaces.pic } })
+    .ele('@pic', 'cNvPicPr')
+    .up();
+const ɵ69 = buildNonVisualPictureDrawingProperties;
+const buildNonVisualDrawingProperties = (pictureId, pictureNameWithExtension, pictureDescription = '') => fragment({ namespaceAlias: { pic: namespaces.pic } })
+    .ele('@pic', 'cNvPr')
+    .att('id', pictureId)
+    .att('name', pictureNameWithExtension)
+    .att('descr', pictureDescription)
+    .up();
+const ɵ70 = buildNonVisualDrawingProperties;
+const buildNonVisualPictureProperties = (pictureId, pictureNameWithExtension, pictureDescription) => {
+    const nonVisualPicturePropertiesFragment = fragment({
+        namespaceAlias: { pic: namespaces.pic },
+    }).ele('@pic', 'nvPicPr');
+    // TODO: Handle picture attributes
+    const nonVisualDrawingPropertiesFragment = buildNonVisualDrawingProperties(pictureId, pictureNameWithExtension, pictureDescription);
+    nonVisualPicturePropertiesFragment.import(nonVisualDrawingPropertiesFragment);
+    const nonVisualPictureDrawingPropertiesFragment = buildNonVisualPictureDrawingProperties();
+    nonVisualPicturePropertiesFragment.import(nonVisualPictureDrawingPropertiesFragment);
+    nonVisualPicturePropertiesFragment.up();
+    return nonVisualPicturePropertiesFragment;
+};
+const ɵ71 = buildNonVisualPictureProperties;
+const buildPicture = ({ id, fileNameWithExtension, description, relationshipId, width, height, }) => {
+    const pictureFragment = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'pic');
+    const nonVisualPicturePropertiesFragment = buildNonVisualPictureProperties(id, fileNameWithExtension, description);
+    pictureFragment.import(nonVisualPicturePropertiesFragment);
+    const binaryLargeImageOrPictureFill = buildBinaryLargeImageOrPictureFill(relationshipId);
+    pictureFragment.import(binaryLargeImageOrPictureFill);
+    const shapeProperties = buildShapeProperties({ width, height });
+    pictureFragment.import(shapeProperties);
+    pictureFragment.up();
+    return pictureFragment;
+};
+const ɵ72 = buildPicture;
+const buildGraphicData = (graphicType, attributes) => {
+    const graphicDataFragment = fragment({ namespaceAlias: { a: namespaces.a } })
+        .ele('@a', 'graphicData')
+        .att('uri', 'http://schemas.openxmlformats.org/drawingml/2006/picture');
+    if (graphicType === 'picture') {
+        const pictureFragment = buildPicture(attributes);
+        graphicDataFragment.import(pictureFragment);
+    }
+    graphicDataFragment.up();
+    return graphicDataFragment;
+};
+const ɵ73 = buildGraphicData;
+const buildGraphic = (graphicType, attributes) => {
+    const graphicFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'graphic');
+    // TODO: Handle drawing type
+    const graphicDataFragment = buildGraphicData(graphicType, attributes);
+    graphicFragment.import(graphicDataFragment);
+    graphicFragment.up();
+    return graphicFragment;
+};
+const ɵ74 = buildGraphic;
+const buildDrawingObjectNonVisualProperties = (pictureId, pictureName) => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'docPr')
+    .att('id', pictureId)
+    .att('name', pictureName)
+    .up();
+const ɵ75 = buildDrawingObjectNonVisualProperties;
+const buildWrapSquare = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'wrapSquare')
+    .att('wrapText', 'bothSides')
+    .att('distB', '228600')
+    .att('distT', '228600')
+    .att('distL', '228600')
+    .att('distR', '228600')
+    .up();
+const ɵ76 = buildWrapSquare;
+// eslint-disable-next-line no-unused-vars
+const buildWrapNone = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'wrapNone')
+    .up();
+const ɵ77 = buildWrapNone;
+const buildEffectExtentFragment = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'effectExtent')
+    .att('b', '0')
+    .att('l', '0')
+    .att('r', '0')
+    .att('t', '0')
+    .up();
+const ɵ78 = buildEffectExtentFragment;
+const buildExtent = ({ width, height }) => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'extent')
+    .att('cx', width)
+    .att('cy', height)
+    .up();
+const ɵ79 = buildExtent;
+const buildPositionV = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'positionV')
+    .att('relativeFrom', 'paragraph')
+    .ele('@wp', 'posOffset')
+    .txt('19050')
+    .up()
+    .up();
+const ɵ80 = buildPositionV;
+const buildPositionH = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'positionH')
+    .att('relativeFrom', 'column')
+    .ele('@wp', 'posOffset')
+    .txt('19050')
+    .up()
+    .up();
+const ɵ81 = buildPositionH;
+const buildSimplePos = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'simplePos')
+    .att('x', '0')
+    .att('y', '0')
+    .up();
+const ɵ82 = buildSimplePos;
+const buildAnchoredDrawing = (graphicType, attributes) => {
+    const anchoredDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })
+        .ele('@wp', 'anchor')
+        .att('distB', '0')
+        .att('distL', '0')
+        .att('distR', '0')
+        .att('distT', '0')
+        .att('relativeHeight', '0')
+        .att('behindDoc', 'false')
+        .att('locked', 'true')
+        .att('layoutInCell', 'true')
+        .att('allowOverlap', 'false')
+        .att('simplePos', 'false');
+    // Even though simplePos isnt supported by Word 2007 simplePos is required.
+    const simplePosFragment = buildSimplePos();
+    anchoredDrawingFragment.import(simplePosFragment);
+    const positionHFragment = buildPositionH();
+    anchoredDrawingFragment.import(positionHFragment);
+    const positionVFragment = buildPositionV();
+    anchoredDrawingFragment.import(positionVFragment);
+    const extentFragment = buildExtent({ width: attributes.width, height: attributes.height });
+    anchoredDrawingFragment.import(extentFragment);
+    const effectExtentFragment = buildEffectExtentFragment();
+    anchoredDrawingFragment.import(effectExtentFragment);
+    const wrapSquareFragment = buildWrapSquare();
+    anchoredDrawingFragment.import(wrapSquareFragment);
+    const drawingObjectNonVisualPropertiesFragment = buildDrawingObjectNonVisualProperties(attributes.id, attributes.fileNameWithExtension);
+    anchoredDrawingFragment.import(drawingObjectNonVisualPropertiesFragment);
+    const graphicFragment = buildGraphic(graphicType, attributes);
+    anchoredDrawingFragment.import(graphicFragment);
+    anchoredDrawingFragment.up();
+    return anchoredDrawingFragment;
+};
+const ɵ83 = buildAnchoredDrawing;
+const buildInlineDrawing = (graphicType, attributes) => {
+    const inlineDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })
+        .ele('@wp', 'inline')
+        .att('distB', '0')
+        .att('distL', '0')
+        .att('distR', '0')
+        .att('distT', '0');
+    const extentFragment = buildExtent({ width: attributes.width, height: attributes.height });
+    inlineDrawingFragment.import(extentFragment);
+    const effectExtentFragment = buildEffectExtentFragment();
+    inlineDrawingFragment.import(effectExtentFragment);
+    const drawingObjectNonVisualPropertiesFragment = buildDrawingObjectNonVisualProperties(attributes.id, attributes.fileNameWithExtension);
+    inlineDrawingFragment.import(drawingObjectNonVisualPropertiesFragment);
+    const graphicFragment = buildGraphic(graphicType, attributes);
+    inlineDrawingFragment.import(graphicFragment);
+    inlineDrawingFragment.up();
+    return inlineDrawingFragment;
+};
+const ɵ84 = buildInlineDrawing;
+const buildDrawing = (inlineOrAnchored = false, graphicType, attributes) => {
+    const drawingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'drawing');
+    const inlineOrAnchoredDrawingFragment = inlineOrAnchored
+        ? buildInlineDrawing(graphicType, attributes)
+        : buildAnchoredDrawing(graphicType, attributes);
+    drawingFragment.import(inlineOrAnchoredDrawingFragment);
+    drawingFragment.up();
+    return drawingFragment;
+};
+const ɵ85 = buildDrawing;
+export { buildParagraph, buildTable, buildNumberingInstances, buildLineBreak, buildIndentation, buildTextElement, buildBold, buildItalics, buildUnderline, buildDrawing, fixupLineHeight, };
+export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8, ɵ9, ɵ10, ɵ11, ɵ12, ɵ13, ɵ14, ɵ15, ɵ16, ɵ17, ɵ18, ɵ19, ɵ20, ɵ21, ɵ22, ɵ23, ɵ24, ɵ25, ɵ26, ɵ27, ɵ28, ɵ29, ɵ30, ɵ31, ɵ32, ɵ33, ɵ34, ɵ35, ɵ36, ɵ37, ɵ38, ɵ39, ɵ40, ɵ41, ɵ42, ɵ43, ɵ44, ɵ45, ɵ46, ɵ47, ɵ48, ɵ49, ɵ50, ɵ51, ɵ52, ɵ53, ɵ54, ɵ55, ɵ56, ɵ57, ɵ58, ɵ59, ɵ60, ɵ61, ɵ62, ɵ63, ɵ64, ɵ65, ɵ66, ɵ67, ɵ68, ɵ69, ɵ70, ɵ71, ɵ72, ɵ73, ɵ74, ɵ75, ɵ76, ɵ77, ɵ78, ɵ79, ɵ80, ɵ81, ɵ82, ɵ83, ɵ84, ɵ85 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xml-builder.js","sourceRoot":"","sources":["../../../../../../../../projects/bbsf-utilities/src/lib/shared/config/word/helpers/xml-builder.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-await-in-loop */\r\n/* eslint-disable radix */\r\n/* eslint-disable no-param-reassign */\r\n/* eslint-disable no-case-declarations */\r\n/* eslint-disable no-plusplus */\r\n/* eslint-disable no-else-return */\r\nimport { fragment } from 'xmlbuilder2';\r\nimport isVNode from 'virtual-dom/vnode/is-vnode';\r\nimport isVText from 'virtual-dom/vnode/is-vtext';\r\nimport colorNames from 'color-name';\r\nimport { cloneDeep } from 'lodash';\r\nimport imageToBase64 from 'image-to-base64';\r\nimport mimeTypes from 'mime-types';\r\nimport sizeOf from 'image-size';\r\n\r\nimport namespaces from '../namespaces';\r\nimport {\r\n  rgbToHex,\r\n  hslToHex,\r\n  hslRegex,\r\n  rgbRegex,\r\n  hexRegex,\r\n  hex3Regex,\r\n  hex3ToHex,\r\n} from '../utils/color-conversion';\r\nimport {\r\n  pixelToEMU,\r\n  pixelRegex,\r\n  TWIPToEMU,\r\n  percentageRegex,\r\n  pointRegex,\r\n  pointToHIP,\r\n  HIPToTWIP,\r\n  pointToTWIP,\r\n  pixelToHIP,\r\n  pixelToTWIP,\r\n  pixelToEIP,\r\n  pointToEIP,\r\n  cmToTWIP,\r\n  cmRegex,\r\n  inchRegex,\r\n  inchToTWIP,\r\n} from '../utils/unit-conversion';\r\n// FIXME: remove the cyclic dependency\r\n// eslint-disable-next-line import/no-cycle\r\nimport { buildImage, buildList } from './render-document-file';\r\nimport {\r\n  defaultFont,\r\n  hyperlinkType,\r\n  paragraphBordersObject,\r\n  colorlessColors,\r\n  verticalAlignValues,\r\n  imageType,\r\n  internalRelationship,\r\n} from '../constants';\r\nimport { vNodeHasChildren } from '../utils/vnode';\r\nimport { isValidUrl } from '../utils/url';\r\n\r\n// eslint-disable-next-line consistent-return\r\nconst fixupColorCode = (colorCodeString) => {\r\n  if (Object.prototype.hasOwnProperty.call(colorNames, colorCodeString.toLowerCase())) {\r\n    const [red, green, blue] = colorNames[colorCodeString.toLowerCase()];\r\n\r\n    return rgbToHex(red, green, blue);\r\n  } else if (rgbRegex.test(colorCodeString)) {\r\n    const matchedParts = colorCodeString.match(rgbRegex);\r\n    const red = matchedParts[1];\r\n    const green = matchedParts[2];\r\n    const blue = matchedParts[3];\r\n\r\n    return rgbToHex(red, green, blue);\r\n  } else if (hslRegex.test(colorCodeString)) {\r\n    const matchedParts = colorCodeString.match(hslRegex);\r\n    const hue = matchedParts[1];\r\n    const saturation = matchedParts[2];\r\n    const luminosity = matchedParts[3];\r\n\r\n    return hslToHex(hue, saturation, luminosity);\r\n  } else if (hexRegex.test(colorCodeString)) {\r\n    const matchedParts = colorCodeString.match(hexRegex);\r\n\r\n    return matchedParts[1];\r\n  } else if (hex3Regex.test(colorCodeString)) {\r\n    const matchedParts = colorCodeString.match(hex3Regex);\r\n    const red = matchedParts[1];\r\n    const green = matchedParts[2];\r\n    const blue = matchedParts[3];\r\n\r\n    return hex3ToHex(red, green, blue);\r\n  } else {\r\n    return '000000';\r\n  }\r\n};\r\n\r\nconst buildRunFontFragment = (fontName = defaultFont) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'rFonts')\r\n    .att('@w', 'ascii', fontName)\r\n    .att('@w', 'hAnsi', fontName)\r\n    .up();\r\n\r\nconst buildRunStyleFragment = (type = 'Hyperlink') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'rStyle')\r\n    .att('@w', 'val', type)\r\n    .up();\r\n\r\nconst buildTableRowHeight = (tableRowHeight) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'trHeight')\r\n    .att('@w', 'val', tableRowHeight)\r\n    .att('@w', 'hRule', 'atLeast')\r\n    .up();\r\n\r\nconst buildVerticalAlignment = (verticalAlignment) => {\r\n  if (verticalAlignment.toLowerCase() === 'middle') {\r\n    verticalAlignment = 'center';\r\n  }\r\n\r\n  return fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'vAlign')\r\n    .att('@w', 'val', verticalAlignment)\r\n    .up();\r\n};\r\n\r\nconst buildVerticalMerge = (verticalMerge = 'continue') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'vMerge')\r\n    .att('@w', 'val', verticalMerge)\r\n    .up();\r\n\r\nconst buildColor = (colorCode) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'color')\r\n    .att('@w', 'val', colorCode)\r\n    .up();\r\n\r\nconst buildFontSize = (fontSize) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'sz')\r\n    .att('@w', 'val', fontSize)\r\n    .up();\r\n\r\nconst buildShading = (colorCode) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'shd')\r\n    .att('@w', 'val', 'clear')\r\n    .att('@w', 'fill', colorCode)\r\n    .up();\r\n\r\nconst buildHighlight = (color = 'yellow') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'highlight')\r\n    .att('@w', 'val', color)\r\n    .up();\r\n\r\nconst buildVertAlign = (type = 'baseline') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'vertAlign')\r\n    .att('@w', 'val', type)\r\n    .up();\r\n\r\nconst buildStrike = () =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'strike')\r\n    .att('@w', 'val', true)\r\n    .up();\r\n\r\nconst buildBold = () =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'b')\r\n    .up();\r\n\r\nconst buildItalics = () =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'i')\r\n    .up();\r\n\r\nconst buildUnderline = (type = 'single') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'u')\r\n    .att('@w', 'val', type)\r\n    .up();\r\n\r\nconst buildLineBreak = (type = 'textWrapping') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'br')\r\n    .att('@w', 'type', type)\r\n    .up();\r\n\r\nconst buildBorder = (\r\n  borderSide = 'top',\r\n  borderSize = 0,\r\n  borderSpacing = 0,\r\n  borderColor = fixupColorCode('black'),\r\n  borderStroke = 'single'\r\n) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', borderSide)\r\n    .att('@w', 'val', borderStroke)\r\n    .att('@w', 'sz', borderSize)\r\n    .att('@w', 'space', borderSpacing)\r\n    .att('@w', 'color', borderColor)\r\n    .up();\r\n\r\nconst buildTextElement = (text) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 't')\r\n    .att('@xml', 'space', 'preserve')\r\n    .txt(text)\r\n    .up();\r\n\r\n// eslint-disable-next-line consistent-return\r\nconst fixupLineHeight = (lineHeight, fontSize) => {\r\n  // FIXME: If line height is anything other than a number\r\n  // eslint-disable-next-line no-restricted-globals\r\n  if (!isNaN(lineHeight)) {\r\n    if (fontSize) {\r\n      const actualLineHeight = +lineHeight * fontSize;\r\n\r\n      return HIPToTWIP(actualLineHeight);\r\n    } else {\r\n      // 240 TWIP or 12 point is default line height\r\n      return +lineHeight * 240;\r\n    }\r\n  } else {\r\n    // 240 TWIP or 12 point is default line height\r\n    return 240;\r\n  }\r\n};\r\n\r\n// eslint-disable-next-line consistent-return\r\nconst fixupFontSize = (fontSizeString) => {\r\n  if (pointRegex.test(fontSizeString)) {\r\n    const matchedParts = fontSizeString.match(pointRegex);\r\n    // convert point to half point\r\n    return pointToHIP(matchedParts[1]);\r\n  } else if (pixelRegex.test(fontSizeString)) {\r\n    const matchedParts = fontSizeString.match(pixelRegex);\r\n    // convert pixels to half point\r\n    return pixelToHIP(matchedParts[1]);\r\n  }\r\n};\r\n\r\n// eslint-disable-next-line consistent-return\r\nconst fixupRowHeight = (rowHeightString) => {\r\n  if (pointRegex.test(rowHeightString)) {\r\n    const matchedParts = rowHeightString.match(pointRegex);\r\n    // convert point to half point\r\n    return pointToTWIP(matchedParts[1]);\r\n  } else if (pixelRegex.test(rowHeightString)) {\r\n    const matchedParts = rowHeightString.match(pixelRegex);\r\n    // convert pixels to half point\r\n    return pixelToTWIP(matchedParts[1]);\r\n  } else if (cmRegex.test(rowHeightString)) {\r\n    const matchedParts = rowHeightString.match(cmRegex);\r\n    return cmToTWIP(matchedParts[1]);\r\n  } else if (inchRegex.test(rowHeightString)) {\r\n    const matchedParts = rowHeightString.match(inchRegex);\r\n    return inchToTWIP(matchedParts[1]);\r\n  }\r\n};\r\n\r\n// eslint-disable-next-line consistent-return\r\nconst fixupColumnWidth = (columnWidthString) => {\r\n  if (pointRegex.test(columnWidthString)) {\r\n    const matchedParts = columnWidthString.match(pointRegex);\r\n    return pointToTWIP(matchedParts[1]);\r\n  } else if (pixelRegex.test(columnWidthString)) {\r\n    const matchedParts = columnWidthString.match(pixelRegex);\r\n    return pixelToTWIP(matchedParts[1]);\r\n  } else if (cmRegex.test(columnWidthString)) {\r\n    const matchedParts = columnWidthString.match(cmRegex);\r\n    return cmToTWIP(matchedParts[1]);\r\n  } else if (inchRegex.test(columnWidthString)) {\r\n    const matchedParts = columnWidthString.match(inchRegex);\r\n    return inchToTWIP(matchedParts[1]);\r\n  }\r\n};\r\n\r\n// eslint-disable-next-line consistent-return\r\nconst fixupMargin = (marginString) => {\r\n  if (pointRegex.test(marginString)) {\r\n    const matchedParts = marginString.match(pointRegex);\r\n    // convert point to half point\r\n    return pointToTWIP(matchedParts[1]);\r\n  } else if (pixelRegex.test(marginString)) {\r\n    const matchedParts = marginString.match(pixelRegex);\r\n    // convert pixels to half point\r\n    return pixelToTWIP(matchedParts[1]);\r\n  }\r\n};\r\n\r\nconst modifiedStyleAttributesBuilder = (vNode, attributes, options) => {\r\n  const modifiedAttributes = { ...attributes };\r\n\r\n  // styles\r\n  if (isVNode(vNode) && vNode.properties && vNode.properties.style) {\r\n    if (vNode.properties.style.color && !colorlessColors.includes(vNode.properties.style.color)) {\r\n      modifiedAttributes.color = fixupColorCode(vNode.properties.style.color);\r\n    }\r\n\r\n    if (\r\n      vNode.properties.style['background-color'] &&\r\n      !colorlessColors.includes(vNode.properties.style['background-color'])\r\n    ) {\r\n      modifiedAttributes.backgroundColor = fixupColorCode(\r\n        vNode.properties.style['background-color']\r\n      );\r\n    }\r\n\r\n    if (\r\n      vNode.properties.style['vertical-align'] &&\r\n      verticalAlignValues.includes(vNode.properties.style['vertical-align'])\r\n    ) {\r\n      modifiedAttributes.verticalAlign = vNode.properties.style['vertical-align'];\r\n    }\r\n\r\n    if (\r\n      vNode.properties.style['text-align'] &&\r\n      ['left', 'right', 'center', 'justify'].includes(vNode.properties.style['text-align'])\r\n    ) {\r\n      modifiedAttributes.textAlign = vNode.properties.style['text-align'];\r\n    }\r\n\r\n    // FIXME: remove bold check when other font weights are handled.\r\n    if (vNode.properties.style['font-weight'] && vNode.properties.style['font-weight'] === 'bold') {\r\n      modifiedAttributes.strong = vNode.properties.style['font-weight'];\r\n    }\r\n    if (vNode.properties.style['font-size']) {\r\n      modifiedAttributes.fontSize = fixupFontSize(vNode.properties.style['font-size']);\r\n    }\r\n    if (vNode.properties.style['line-height']) {\r\n      modifiedAttributes.lineHeight = fixupLineHeight(\r\n        vNode.properties.style['line-height'],\r\n        vNode.properties.style['font-size']\r\n          ? fixupFontSize(vNode.properties.style['font-size'])\r\n          : null\r\n      );\r\n    }\r\n    if (vNode.properties.style['margin-left'] || vNode.properties.style['margin-right']) {\r\n      const leftMargin = fixupMargin(vNode.properties.style['margin-left']);\r\n      const rightMargin = fixupMargin(vNode.properties.style['margin-right']);\r\n      const indentation = {};\r\n      if (leftMargin) {\r\n        indentation.left = leftMargin;\r\n      }\r\n      if (rightMargin) {\r\n        indentation.right = rightMargin;\r\n      }\r\n      if (leftMargin || rightMargin) {\r\n        modifiedAttributes.indentation = indentation;\r\n      }\r\n    }\r\n    if (vNode.properties.style.display) {\r\n      modifiedAttributes.display = vNode.properties.style.display;\r\n    }\r\n\r\n    if (vNode.properties.style.width) {\r\n      modifiedAttributes.width = vNode.properties.style.width;\r\n    }\r\n  }\r\n\r\n  // paragraph only\r\n  if (options && options.isParagraph) {\r\n    if (isVNode(vNode) && vNode.tagName === 'blockquote') {\r\n      modifiedAttributes.indentation = { left: 284 };\r\n      modifiedAttributes.textAlign = 'justify';\r\n    } else if (isVNode(vNode) && vNode.tagName === 'code') {\r\n      modifiedAttributes.highlightColor = 'lightGray';\r\n    } else if (isVNode(vNode) && vNode.tagName === 'pre') {\r\n      modifiedAttributes.font = 'Courier';\r\n    }\r\n  }\r\n\r\n  return modifiedAttributes;\r\n};\r\n\r\n// html tag to formatting function\r\n// options are passed to the formatting function if needed\r\nconst buildFormatting = (htmlTag, options) => {\r\n  switch (htmlTag) {\r\n    case 'strong':\r\n    case 'b':\r\n      return buildBold();\r\n    case 'em':\r\n    case 'i':\r\n      return buildItalics();\r\n    case 'ins':\r\n    case 'u':\r\n      return buildUnderline();\r\n    case 'strike':\r\n    case 'del':\r\n    case 's':\r\n      return buildStrike();\r\n    case 'sub':\r\n      return buildVertAlign('subscript');\r\n    case 'sup':\r\n      return buildVertAlign('superscript');\r\n    case 'mark':\r\n      return buildHighlight();\r\n    case 'code':\r\n      return buildHighlight('lightGray');\r\n    case 'highlightColor':\r\n      return buildHighlight(options && options.color ? options.color : 'lightGray');\r\n    case 'font':\r\n    case 'pre':\r\n      return buildRunFontFragment('Courier');\r\n    case 'color':\r\n      return buildColor(options && options.color ? options.color : 'black');\r\n    case 'backgroundColor':\r\n      return buildShading(options && options.color ? options.color : 'black');\r\n    case 'fontSize':\r\n      // does this need a unit of measure?\r\n      return buildFontSize(options && options.fontSize ? options.fontSize : 10);\r\n    case 'hyperlink':\r\n      return buildRunStyleFragment('Hyperlink');\r\n  }\r\n\r\n  return null;\r\n};\r\n\r\nconst buildRunProperties = (attributes) => {\r\n  const runPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'rPr');\r\n  if (attributes && attributes.constructor === Object) {\r\n    Object.keys(attributes).forEach((key) => {\r\n      const options = {};\r\n      if (key === 'color' || key === 'backgroundColor' || key === 'highlightColor') {\r\n        options.color = attributes[key];\r\n      }\r\n\r\n      if (key === 'fontSize') {\r\n        options.fontSize = attributes[key];\r\n      }\r\n\r\n      const formattingFragment = buildFormatting(key, options);\r\n      if (formattingFragment) {\r\n        runPropertiesFragment.import(formattingFragment);\r\n      }\r\n    });\r\n  }\r\n  runPropertiesFragment.up();\r\n\r\n  return runPropertiesFragment;\r\n};\r\n\r\nconst buildRun = async (vNode, attributes, docxDocumentInstance) => {\r\n  const runFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');\r\n  const runPropertiesFragment = buildRunProperties(cloneDeep(attributes));\r\n\r\n  // case where we have recursive spans representing font changes\r\n  if (isVNode(vNode) && vNode.tagName === 'span') {\r\n    // eslint-disable-next-line no-use-before-define\r\n    return buildRunOrRuns(vNode, attributes, docxDocumentInstance);\r\n  }\r\n\r\n  if (\r\n    isVNode(vNode) &&\r\n    [\r\n      'strong',\r\n      'b',\r\n      'em',\r\n      'i',\r\n      'u',\r\n      'ins',\r\n      'strike',\r\n      'del',\r\n      's',\r\n      'sub',\r\n      'sup',\r\n      'mark',\r\n      'blockquote',\r\n      'code',\r\n      'pre',\r\n    ].includes(vNode.tagName)\r\n  ) {\r\n    const runFragmentsArray = [];\r\n\r\n    let vNodes = [vNode];\r\n    // create temp run fragments to split the paragraph into different runs\r\n    let tempAttributes = cloneDeep(attributes);\r\n    let tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');\r\n    while (vNodes.length) {\r\n      const tempVNode = vNodes.shift();\r\n      if (isVText(tempVNode)) {\r\n        const textFragment = buildTextElement(tempVNode.text);\r\n        const tempRunPropertiesFragment = buildRunProperties({ ...attributes, ...tempAttributes });\r\n        tempRunFragment.import(tempRunPropertiesFragment);\r\n        tempRunFragment.import(textFragment);\r\n        runFragmentsArray.push(tempRunFragment);\r\n\r\n        // re initialize temp run fragments with new fragment\r\n        tempAttributes = cloneDeep(attributes);\r\n        tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');\r\n      } else if (isVNode(tempVNode)) {\r\n        if (\r\n          [\r\n            'strong',\r\n            'b',\r\n            'em',\r\n            'i',\r\n            'u',\r\n            'ins',\r\n            'strike',\r\n            'del',\r\n            's',\r\n            'sub',\r\n            'sup',\r\n            'mark',\r\n            'code',\r\n            'pre',\r\n          ].includes(tempVNode.tagName)\r\n        ) {\r\n          tempAttributes = {};\r\n          switch (tempVNode.tagName) {\r\n            case 'strong':\r\n            case 'b':\r\n              tempAttributes.strong = true;\r\n              break;\r\n            case 'i':\r\n              tempAttributes.i = true;\r\n              break;\r\n            case 'u':\r\n              tempAttributes.u = true;\r\n              break;\r\n            case 'sub':\r\n              tempAttributes.sub = true;\r\n              break;\r\n            case 'sup':\r\n              tempAttributes.sup = true;\r\n              break;\r\n          }\r\n          const formattingFragment = buildFormatting(tempVNode);\r\n\r\n          if (formattingFragment) {\r\n            runPropertiesFragment.import(formattingFragment);\r\n          }\r\n          // go a layer deeper if there is a span somewhere in the children\r\n        } else if (tempVNode.tagName === 'span') {\r\n          // eslint-disable-next-line no-use-before-define\r\n          const spanFragment = await buildRunOrRuns(\r\n            tempVNode,\r\n            { ...attributes, ...tempAttributes },\r\n            docxDocumentInstance\r\n          );\r\n\r\n          // if spanFragment is an array, we need to add each fragment to the runFragmentsArray. If the fragment is an array, perform a depth first search on the array to add each fragment to the runFragmentsArray\r\n          if (Array.isArray(spanFragment)) {\r\n            spanFragment.flat(Infinity);\r\n            runFragmentsArray.push(...spanFragment);\r\n          } else {\r\n            runFragmentsArray.push(spanFragment);\r\n          }\r\n\r\n          // do not slice and concat children since this is already accounted for in the buildRunOrRuns function\r\n          // eslint-disable-next-line no-continue\r\n          continue;\r\n        }\r\n      }\r\n\r\n      if (tempVNode.children && tempVNode.children.length) {\r\n        if (tempVNode.children.length > 1) {\r\n          attributes = { ...attributes, ...tempAttributes };\r\n        }\r\n\r\n        vNodes = tempVNode.children.slice().concat(vNodes);\r\n      }\r\n    }\r\n    if (runFragmentsArray.length) {\r\n      return runFragmentsArray;\r\n    }\r\n  }\r\n\r\n  runFragment.import(runPropertiesFragment);\r\n  if (isVText(vNode)) {\r\n    const textFragment = buildTextElement(vNode.text);\r\n    runFragment.import(textFragment);\r\n  } else if (attributes && attributes.type === 'picture') {\r\n    let response = null;\r\n\r\n    const base64Uri = decodeURIComponent(vNode.properties.src);\r\n    if (base64Uri) {\r\n      response = docxDocumentInstance.createMediaFile(base64Uri);\r\n    }\r\n\r\n    if (response) {\r\n      docxDocumentInstance.zip\r\n        .folder('word')\r\n        .folder('media')\r\n        .file(response.fileNameWithExtension, Buffer.from(response.fileContent, 'base64'), {\r\n          createFolders: false,\r\n        });\r\n\r\n      const documentRelsId = docxDocumentInstance.createDocumentRelationships(\r\n        docxDocumentInstance.relationshipFilename,\r\n        imageType,\r\n        `media/${response.fileNameWithExtension}`,\r\n        internalRelationship\r\n      );\r\n\r\n      attributes.inlineOrAnchored = true;\r\n      attributes.relationshipId = documentRelsId;\r\n      attributes.id = response.id;\r\n      attributes.fileContent = response.fileContent;\r\n      attributes.fileNameWithExtension = response.fileNameWithExtension;\r\n    }\r\n\r\n    const { type, inlineOrAnchored, ...otherAttributes } = attributes;\r\n    // eslint-disable-next-line no-use-before-define\r\n    const imageFragment = buildDrawing(inlineOrAnchored, type, otherAttributes);\r\n    runFragment.import(imageFragment);\r\n  } else if (isVNode(vNode) && vNode.tagName === 'br') {\r\n    const lineBreakFragment = buildLineBreak();\r\n    runFragment.import(lineBreakFragment);\r\n  }\r\n  runFragment.up();\r\n\r\n  return runFragment;\r\n};\r\n\r\nconst buildRunOrRuns = async (vNode, attributes, docxDocumentInstance) => {\r\n  if (isVNode(vNode) && vNode.tagName === 'span') {\r\n    let runFragments = [];\r\n\r\n    for (let index = 0; index < vNode.children.length; index++) {\r\n      const childVNode = vNode.children[index];\r\n      const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes);\r\n      const tempRunFragments = await buildRun(childVNode, modifiedAttributes, docxDocumentInstance);\r\n      runFragments = runFragments.concat(\r\n        Array.isArray(tempRunFragments) ? tempRunFragments : [tempRunFragments]\r\n      );\r\n    }\r\n\r\n    return runFragments;\r\n  } else {\r\n    const tempRunFragments = await buildRun(vNode, attributes, docxDocumentInstance);\r\n    return tempRunFragments;\r\n  }\r\n};\r\n\r\nconst buildRunOrHyperLink = async (vNode, attributes, docxDocumentInstance) => {\r\n  if (isVNode(vNode) && vNode.tagName === 'a') {\r\n    const relationshipId = docxDocumentInstance.createDocumentRelationships(\r\n      docxDocumentInstance.relationshipFilename,\r\n      hyperlinkType,\r\n      vNode.properties && vNode.properties.href ? vNode.properties.href : ''\r\n    );\r\n    const hyperlinkFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })\r\n      .ele('@w', 'hyperlink')\r\n      .att('@r', 'id', `rId${relationshipId}`);\r\n\r\n    const modifiedAttributes = { ...attributes };\r\n    modifiedAttributes.hyperlink = true;\r\n\r\n    const runFragments = await buildRunOrRuns(\r\n      vNode.children[0],\r\n      modifiedAttributes,\r\n      docxDocumentInstance\r\n    );\r\n    if (Array.isArray(runFragments)) {\r\n      for (let index = 0; index < runFragments.length; index++) {\r\n        const runFragment = runFragments[index];\r\n\r\n        hyperlinkFragment.import(runFragment);\r\n      }\r\n    } else {\r\n      hyperlinkFragment.import(runFragments);\r\n    }\r\n    hyperlinkFragment.up();\r\n\r\n    return hyperlinkFragment;\r\n  }\r\n\r\n  const runFragments = await buildRunOrRuns(vNode, attributes, docxDocumentInstance);\r\n\r\n  return runFragments;\r\n};\r\n\r\nconst buildNumberingProperties = (levelId, numberingId) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'numPr')\r\n    .ele('@w', 'ilvl')\r\n    .att('@w', 'val', String(levelId))\r\n    .up()\r\n    .ele('@w', 'numId')\r\n    .att('@w', 'val', String(numberingId))\r\n    .up()\r\n    .up();\r\n\r\nconst buildNumberingInstances = () =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'num')\r\n    .ele('@w', 'abstractNumId')\r\n    .up()\r\n    .up();\r\n\r\nconst buildSpacing = (lineSpacing, beforeSpacing, afterSpacing) => {\r\n  const spacingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'spacing');\r\n\r\n  if (lineSpacing) {\r\n    spacingFragment.att('@w', 'line', lineSpacing);\r\n  }\r\n  if (beforeSpacing) {\r\n    spacingFragment.att('@w', 'before', beforeSpacing);\r\n  }\r\n  if (afterSpacing) {\r\n    spacingFragment.att('@w', 'after', afterSpacing);\r\n  }\r\n\r\n  spacingFragment.att('@w', 'lineRule', 'auto').up();\r\n\r\n  return spacingFragment;\r\n};\r\n\r\nconst buildIndentation = ({ left, right }) => {\r\n  const indentationFragment = fragment({\r\n    namespaceAlias: { w: namespaces.w },\r\n  }).ele('@w', 'ind');\r\n\r\n  if (left) {\r\n    indentationFragment.att('@w', 'left', left);\r\n  }\r\n  if (right) {\r\n    indentationFragment.att('@w', 'right', right);\r\n  }\r\n\r\n  indentationFragment.up();\r\n\r\n  return indentationFragment;\r\n};\r\n\r\nconst buildPStyle = (style = 'Normal') =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'pStyle')\r\n    .att('@w', 'val', style)\r\n    .up();\r\n\r\nconst buildHorizontalAlignment = (horizontalAlignment) => {\r\n  if (horizontalAlignment === 'justify') {\r\n    horizontalAlignment = 'both';\r\n  }\r\n  return fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'jc')\r\n    .att('@w', 'val', horizontalAlignment)\r\n    .up();\r\n};\r\n\r\nconst buildParagraphBorder = () => {\r\n  const paragraphBorderFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'pBdr'\r\n  );\r\n  const bordersObject = cloneDeep(paragraphBordersObject);\r\n\r\n  Object.keys(bordersObject).forEach((borderName) => {\r\n    if (bordersObject[borderName]) {\r\n      const { size, spacing, color } = bordersObject[borderName];\r\n\r\n      const borderFragment = buildBorder(borderName, size, spacing, color);\r\n      paragraphBorderFragment.import(borderFragment);\r\n    }\r\n  });\r\n\r\n  paragraphBorderFragment.up();\r\n\r\n  return paragraphBorderFragment;\r\n};\r\n\r\nconst buildParagraphProperties = (attributes) => {\r\n  const paragraphPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'pPr'\r\n  );\r\n  if (attributes && attributes.constructor === Object) {\r\n    Object.keys(attributes).forEach((key) => {\r\n      switch (key) {\r\n        case 'numbering':\r\n          const { levelId, numberingId } = attributes[key];\r\n          const numberingPropertiesFragment = buildNumberingProperties(levelId, numberingId);\r\n          paragraphPropertiesFragment.import(numberingPropertiesFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.numbering;\r\n          break;\r\n        case 'textAlign':\r\n          const horizontalAlignmentFragment = buildHorizontalAlignment(attributes[key]);\r\n          paragraphPropertiesFragment.import(horizontalAlignmentFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.textAlign;\r\n          break;\r\n        case 'backgroundColor':\r\n          // Add shading to Paragraph Properties only if display is block\r\n          // Essentially if background color needs to be across the row\r\n          if (attributes.display === 'block') {\r\n            const shadingFragment = buildShading(attributes[key]);\r\n            paragraphPropertiesFragment.import(shadingFragment);\r\n            // FIXME: Inner padding in case of shaded paragraphs.\r\n            const paragraphBorderFragment = buildParagraphBorder();\r\n            paragraphPropertiesFragment.import(paragraphBorderFragment);\r\n            // eslint-disable-next-line no-param-reassign\r\n            delete attributes.backgroundColor;\r\n          }\r\n          break;\r\n        case 'paragraphStyle':\r\n          const pStyleFragment = buildPStyle(attributes.paragraphStyle);\r\n          paragraphPropertiesFragment.import(pStyleFragment);\r\n          delete attributes.paragraphStyle;\r\n          break;\r\n        case 'indentation':\r\n          const indentationFragment = buildIndentation(attributes[key]);\r\n          paragraphPropertiesFragment.import(indentationFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.indentation;\r\n          break;\r\n      }\r\n    });\r\n\r\n    const spacingFragment = buildSpacing(\r\n      attributes.lineHeight,\r\n      attributes.beforeSpacing,\r\n      attributes.afterSpacing\r\n    );\r\n    // eslint-disable-next-line no-param-reassign\r\n    delete attributes.lineHeight;\r\n    // eslint-disable-next-line no-param-reassign\r\n    delete attributes.beforeSpacing;\r\n    // eslint-disable-next-line no-param-reassign\r\n    delete attributes.afterSpacing;\r\n\r\n    paragraphPropertiesFragment.import(spacingFragment);\r\n  }\r\n  paragraphPropertiesFragment.up();\r\n\r\n  return paragraphPropertiesFragment;\r\n};\r\n\r\nconst computeImageDimensions = (vNode, attributes) => {\r\n  const { maximumWidth, originalWidth, originalHeight } = attributes;\r\n  const aspectRatio = originalWidth / originalHeight;\r\n  const maximumWidthInEMU = TWIPToEMU(maximumWidth);\r\n  let originalWidthInEMU = pixelToEMU(originalWidth);\r\n  let originalHeightInEMU = pixelToEMU(originalHeight);\r\n  if (originalWidthInEMU > maximumWidthInEMU) {\r\n    originalWidthInEMU = maximumWidthInEMU;\r\n    originalHeightInEMU = Math.round(originalWidthInEMU / aspectRatio);\r\n  }\r\n  let modifiedHeight;\r\n  let modifiedWidth;\r\n\r\n  if (vNode.properties && vNode.properties.style) {\r\n    if (vNode.properties.style.width) {\r\n      if (vNode.properties.style.width !== 'auto') {\r\n        if (pixelRegex.test(vNode.properties.style.width)) {\r\n          modifiedWidth = pixelToEMU(vNode.properties.style.width.match(pixelRegex)[1]);\r\n        } else if (percentageRegex.test(vNode.properties.style.width)) {\r\n          const percentageValue = vNode.properties.style.width.match(percentageRegex)[1];\r\n\r\n          modifiedWidth = Math.round((percentageValue / 100) * originalWidthInEMU);\r\n        }\r\n      } else {\r\n        // eslint-disable-next-line no-lonely-if\r\n        if (vNode.properties.style.height && vNode.properties.style.height === 'auto') {\r\n          modifiedWidth = originalWidthInEMU;\r\n          modifiedHeight = originalHeightInEMU;\r\n        }\r\n      }\r\n    }\r\n    if (vNode.properties.style.height) {\r\n      if (vNode.properties.style.height !== 'auto') {\r\n        if (pixelRegex.test(vNode.properties.style.height)) {\r\n          modifiedHeight = pixelToEMU(vNode.properties.style.height.match(pixelRegex)[1]);\r\n        } else if (percentageRegex.test(vNode.properties.style.height)) {\r\n          const percentageValue = vNode.properties.style.width.match(percentageRegex)[1];\r\n\r\n          modifiedHeight = Math.round((percentageValue / 100) * originalHeightInEMU);\r\n          if (!modifiedWidth) {\r\n            modifiedWidth = Math.round(modifiedHeight * aspectRatio);\r\n          }\r\n        }\r\n      } else {\r\n        // eslint-disable-next-line no-lonely-if\r\n        if (modifiedWidth) {\r\n          if (!modifiedHeight) {\r\n            modifiedHeight = Math.round(modifiedWidth / aspectRatio);\r\n          }\r\n        } else {\r\n          modifiedHeight = originalHeightInEMU;\r\n          modifiedWidth = originalWidthInEMU;\r\n        }\r\n      }\r\n    }\r\n    if (modifiedWidth && !modifiedHeight) {\r\n      modifiedHeight = Math.round(modifiedWidth / aspectRatio);\r\n    } else if (modifiedHeight && !modifiedWidth) {\r\n      modifiedWidth = Math.round(modifiedHeight * aspectRatio);\r\n    }\r\n  } else {\r\n    modifiedWidth = originalWidthInEMU;\r\n    modifiedHeight = originalHeightInEMU;\r\n  }\r\n\r\n  // eslint-disable-next-line no-param-reassign\r\n  attributes.width = modifiedWidth;\r\n  // eslint-disable-next-line no-param-reassign\r\n  attributes.height = modifiedHeight;\r\n};\r\n\r\nconst buildParagraph = async (vNode, attributes, docxDocumentInstance) => {\r\n  const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'p');\r\n  const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes, {\r\n    isParagraph: true,\r\n  });\r\n  const paragraphPropertiesFragment = buildParagraphProperties(modifiedAttributes);\r\n  paragraphFragment.import(paragraphPropertiesFragment);\r\n  if (isVNode(vNode) && vNodeHasChildren(vNode)) {\r\n    if (\r\n      [\r\n        'span',\r\n        'strong',\r\n        'b',\r\n        'em',\r\n        'i',\r\n        'u',\r\n        'ins',\r\n        'strike',\r\n        'del',\r\n        's',\r\n        'sub',\r\n        'sup',\r\n        'mark',\r\n        'a',\r\n        'code',\r\n        'pre',\r\n      ].includes(vNode.tagName)\r\n    ) {\r\n      const runOrHyperlinkFragments = await buildRunOrHyperLink(\r\n        vNode,\r\n        modifiedAttributes,\r\n        docxDocumentInstance\r\n      );\r\n      if (Array.isArray(runOrHyperlinkFragments)) {\r\n        for (\r\n          let iteratorIndex = 0;\r\n          iteratorIndex < runOrHyperlinkFragments.length;\r\n          iteratorIndex++\r\n        ) {\r\n          const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];\r\n\r\n          paragraphFragment.import(runOrHyperlinkFragment);\r\n        }\r\n      } else {\r\n        paragraphFragment.import(runOrHyperlinkFragments);\r\n      }\r\n    } else if (vNode.tagName === 'blockquote') {\r\n      const runFragmentOrFragments = await buildRun(vNode, attributes);\r\n      if (Array.isArray(runFragmentOrFragments)) {\r\n        for (let index = 0; index < runFragmentOrFragments.length; index++) {\r\n          paragraphFragment.import(runFragmentOrFragments[index]);\r\n        }\r\n      } else {\r\n        paragraphFragment.import(runFragmentOrFragments);\r\n      }\r\n    } else {\r\n      for (let index = 0; index < vNode.children.length; index++) {\r\n        const childVNode = vNode.children[index];\r\n        if (childVNode.tagName === 'img') {\r\n          let base64String;\r\n          const imageSource = childVNode.properties.src;\r\n          if (isValidUrl(imageSource)) {\r\n            base64String = await imageToBase64(imageSource).catch((error) => {\r\n              // eslint-disable-next-line no-console\r\n              console.warning(`skipping image download and conversion due to ${error}`);\r\n            });\r\n\r\n            if (base64String && mimeTypes.lookup(imageSource)) {\r\n              childVNode.properties.src = `data:${mimeTypes.lookup(\r\n                imageSource\r\n              )};base64, ${base64String}`;\r\n            } else {\r\n              break;\r\n            }\r\n          } else {\r\n            // eslint-disable-next-line no-useless-escape, prefer-destructuring\r\n            base64String = imageSource.match(/^data:([A-Za-z-+\\/]+);base64,(.+)$/)[2];\r\n          }\r\n          const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');\r\n          const imageProperties = sizeOf(imageBuffer);\r\n\r\n          modifiedAttributes.maximumWidth =\r\n            modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;\r\n          modifiedAttributes.originalWidth = imageProperties.width;\r\n          modifiedAttributes.originalHeight = imageProperties.height;\r\n\r\n          computeImageDimensions(childVNode, modifiedAttributes);\r\n        }\r\n        const runOrHyperlinkFragments = await buildRunOrHyperLink(\r\n          childVNode,\r\n          isVNode(childVNode) && childVNode.tagName === 'img'\r\n            ? { ...modifiedAttributes, type: 'picture' }\r\n            : modifiedAttributes,\r\n          docxDocumentInstance\r\n        );\r\n        if (Array.isArray(runOrHyperlinkFragments)) {\r\n          for (\r\n            let iteratorIndex = 0;\r\n            iteratorIndex < runOrHyperlinkFragments.length;\r\n            iteratorIndex++\r\n          ) {\r\n            const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];\r\n\r\n            paragraphFragment.import(runOrHyperlinkFragment);\r\n          }\r\n        } else {\r\n          paragraphFragment.import(runOrHyperlinkFragments);\r\n        }\r\n      }\r\n    }\r\n  } else {\r\n    // In case paragraphs has to be rendered where vText is present. Eg. table-cell\r\n    // Or in case the vNode is something like img\r\n    if (isVNode(vNode) && vNode.tagName === 'img') {\r\n      const imageSource = vNode.properties.src;\r\n      let base64String = imageSource;\r\n      if (isValidUrl(imageSource)) {\r\n        base64String = await imageToBase64(imageSource).catch((error) => {\r\n          // eslint-disable-next-line no-console\r\n          console.warning(`skipping image download and conversion due to ${error}`);\r\n        });\r\n\r\n        if (base64String && mimeTypes.lookup(imageSource)) {\r\n          vNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;\r\n        } else {\r\n          paragraphFragment.up();\r\n\r\n          return paragraphFragment;\r\n        }\r\n      } else {\r\n        // eslint-disable-next-line no-useless-escape, prefer-destructuring\r\n        base64String = base64String.match(/^data:([A-Za-z-+\\/]+);base64,(.+)$/)[2];\r\n      }\r\n\r\n      const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');\r\n      const imageProperties = sizeOf(imageBuffer);\r\n\r\n      modifiedAttributes.maximumWidth =\r\n        modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;\r\n      modifiedAttributes.originalWidth = imageProperties.width;\r\n      modifiedAttributes.originalHeight = imageProperties.height;\r\n\r\n      computeImageDimensions(vNode, modifiedAttributes);\r\n    }\r\n    const runFragments = await buildRunOrRuns(vNode, modifiedAttributes, docxDocumentInstance);\r\n    if (Array.isArray(runFragments)) {\r\n      for (let index = 0; index < runFragments.length; index++) {\r\n        const runFragment = runFragments[index];\r\n\r\n        paragraphFragment.import(runFragment);\r\n      }\r\n    } else {\r\n      paragraphFragment.import(runFragments);\r\n    }\r\n  }\r\n  paragraphFragment.up();\r\n\r\n  return paragraphFragment;\r\n};\r\n\r\nconst buildGridSpanFragment = (spanValue) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'gridSpan')\r\n    .att('@w', 'val', spanValue)\r\n    .up();\r\n\r\nconst buildTableCellSpacing = (cellSpacing = 0) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'tblCellSpacing')\r\n    .att('@w', 'w', cellSpacing)\r\n    .att('@w', 'type', 'dxa')\r\n    .up();\r\n\r\nconst buildTableCellBorders = (tableCellBorder) => {\r\n  const tableCellBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'tcBorders'\r\n  );\r\n\r\n  const { color, stroke, ...borders } = tableCellBorder;\r\n  Object.keys(borders).forEach((border) => {\r\n    if (tableCellBorder[border]) {\r\n      const borderFragment = buildBorder(border, tableCellBorder[border], 0, color, stroke);\r\n      tableCellBordersFragment.import(borderFragment);\r\n    }\r\n  });\r\n\r\n  tableCellBordersFragment.up();\r\n\r\n  return tableCellBordersFragment;\r\n};\r\n\r\nconst buildTableCellWidth = (tableCellWidth) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'tcW')\r\n    .att('@w', 'w', fixupColumnWidth(tableCellWidth))\r\n    .att('@w', 'type', 'dxa')\r\n    .up();\r\n\r\nconst buildTableCellProperties = (attributes) => {\r\n  const tableCellPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'tcPr'\r\n  );\r\n  if (attributes && attributes.constructor === Object) {\r\n    Object.keys(attributes).forEach((key) => {\r\n      switch (key) {\r\n        case 'backgroundColor':\r\n          const shadingFragment = buildShading(attributes[key]);\r\n          tableCellPropertiesFragment.import(shadingFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.backgroundColor;\r\n          break;\r\n        case 'verticalAlign':\r\n          const verticalAlignmentFragment = buildVerticalAlignment(attributes[key]);\r\n          tableCellPropertiesFragment.import(verticalAlignmentFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.verticalAlign;\r\n          break;\r\n        case 'colSpan':\r\n          const gridSpanFragment = buildGridSpanFragment(attributes[key]);\r\n          tableCellPropertiesFragment.import(gridSpanFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.colSpan;\r\n          break;\r\n        case 'tableCellBorder':\r\n          const tableCellBorderFragment = buildTableCellBorders(attributes[key]);\r\n          tableCellPropertiesFragment.import(tableCellBorderFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.tableCellBorder;\r\n          break;\r\n        case 'rowSpan':\r\n          const verticalMergeFragment = buildVerticalMerge(attributes[key]);\r\n          tableCellPropertiesFragment.import(verticalMergeFragment);\r\n\r\n          delete attributes.rowSpan;\r\n          break;\r\n        case 'width':\r\n          const widthFragment = buildTableCellWidth(attributes[key]);\r\n          tableCellPropertiesFragment.import(widthFragment);\r\n          delete attributes.width;\r\n          break;\r\n      }\r\n    });\r\n  }\r\n  tableCellPropertiesFragment.up();\r\n\r\n  return tableCellPropertiesFragment;\r\n};\r\n\r\nconst fixupTableCellBorder = (vNode, attributes) => {\r\n  if (Object.prototype.hasOwnProperty.call(vNode.properties.style, 'border')) {\r\n    if (vNode.properties.style.border === 'none' || vNode.properties.style.border === 0) {\r\n      attributes.tableCellBorder = {};\r\n    } else {\r\n      // eslint-disable-next-line no-use-before-define\r\n      const [borderSize, borderStroke, borderColor] = cssBorderParser(\r\n        vNode.properties.style.border\r\n      );\r\n\r\n      attributes.tableCellBorder = {\r\n        top: borderSize,\r\n        left: borderSize,\r\n        bottom: borderSize,\r\n        right: borderSize,\r\n        color: borderColor,\r\n        stroke: borderStroke,\r\n      };\r\n    }\r\n  }\r\n  if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] === '0') {\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      top: 0,\r\n    };\r\n  } else if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] !== '0') {\r\n    // eslint-disable-next-line no-use-before-define\r\n    const [borderSize, borderStroke, borderColor] = cssBorderParser(\r\n      vNode.properties.style['border-top']\r\n    );\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      top: borderSize,\r\n      color: borderColor,\r\n      stroke: borderStroke,\r\n    };\r\n  }\r\n  if (vNode.properties.style['border-left'] && vNode.properties.style['border-left'] === '0') {\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      left: 0,\r\n    };\r\n  } else if (\r\n    vNode.properties.style['border-left'] &&\r\n    vNode.properties.style['border-left'] !== '0'\r\n  ) {\r\n    // eslint-disable-next-line no-use-before-define\r\n    const [borderSize, borderStroke, borderColor] = cssBorderParser(\r\n      vNode.properties.style['border-left']\r\n    );\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      left: borderSize,\r\n      color: borderColor,\r\n      stroke: borderStroke,\r\n    };\r\n  }\r\n  if (vNode.properties.style['border-bottom'] && vNode.properties.style['border-bottom'] === '0') {\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      bottom: 0,\r\n    };\r\n  } else if (\r\n    vNode.properties.style['border-bottom'] &&\r\n    vNode.properties.style['border-bottom'] !== '0'\r\n  ) {\r\n    // eslint-disable-next-line no-use-before-define\r\n    const [borderSize, borderStroke, borderColor] = cssBorderParser(\r\n      vNode.properties.style['border-bottom']\r\n    );\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      bottom: borderSize,\r\n      color: borderColor,\r\n      stroke: borderStroke,\r\n    };\r\n  }\r\n  if (vNode.properties.style['border-right'] && vNode.properties.style['border-right'] === '0') {\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      right: 0,\r\n    };\r\n  } else if (\r\n    vNode.properties.style['border-right'] &&\r\n    vNode.properties.style['border-right'] !== '0'\r\n  ) {\r\n    // eslint-disable-next-line no-use-before-define\r\n    const [borderSize, borderStroke, borderColor] = cssBorderParser(\r\n      vNode.properties.style['border-right']\r\n    );\r\n    attributes.tableCellBorder = {\r\n      ...attributes.tableCellBorder,\r\n      right: borderSize,\r\n      color: borderColor,\r\n      stroke: borderStroke,\r\n    };\r\n  }\r\n};\r\n\r\nconst buildTableCell = async (vNode, attributes, rowSpanMap, columnIndex, docxDocumentInstance) => {\r\n  const tableCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');\r\n\r\n  let modifiedAttributes = { ...attributes };\r\n  if (isVNode(vNode) && vNode.properties) {\r\n    if (vNode.properties.rowSpan) {\r\n      rowSpanMap.set(columnIndex.index, { rowSpan: vNode.properties.rowSpan - 1, colSpan: 0 });\r\n      modifiedAttributes.rowSpan = 'restart';\r\n    } else {\r\n      const previousSpanObject = rowSpanMap.get(columnIndex.index);\r\n      rowSpanMap.set(\r\n        columnIndex.index,\r\n        // eslint-disable-next-line prefer-object-spread\r\n        Object.assign({}, previousSpanObject, {\r\n          rowSpan: 0,\r\n          colSpan: (previousSpanObject && previousSpanObject.colSpan) || 0,\r\n        })\r\n      );\r\n    }\r\n    if (\r\n      vNode.properties.colSpan ||\r\n      (vNode.properties.style && vNode.properties.style['column-span'])\r\n    ) {\r\n      modifiedAttributes.colSpan =\r\n        vNode.properties.colSpan ||\r\n        (vNode.properties.style && vNode.properties.style['column-span']);\r\n      const previousSpanObject = rowSpanMap.get(columnIndex.index);\r\n      rowSpanMap.set(\r\n        columnIndex.index,\r\n        // eslint-disable-next-line prefer-object-spread\r\n        Object.assign({}, previousSpanObject, {\r\n          colSpan: parseInt(modifiedAttributes.colSpan) || 0,\r\n        })\r\n      );\r\n      columnIndex.index += parseInt(modifiedAttributes.colSpan) - 1;\r\n    }\r\n    if (vNode.properties.style) {\r\n      modifiedAttributes = {\r\n        ...modifiedAttributes,\r\n        ...modifiedStyleAttributesBuilder(vNode, attributes),\r\n      };\r\n\r\n      fixupTableCellBorder(vNode, modifiedAttributes);\r\n    }\r\n  }\r\n  const tableCellPropertiesFragment = buildTableCellProperties(modifiedAttributes);\r\n  tableCellFragment.import(tableCellPropertiesFragment);\r\n  if (vNodeHasChildren(vNode)) {\r\n    for (let index = 0; index < vNode.children.length; index++) {\r\n      const childVNode = vNode.children[index];\r\n      if (isVNode(childVNode) && childVNode.tagName === 'img') {\r\n        const imageFragment = await buildImage(\r\n          docxDocumentInstance,\r\n          childVNode,\r\n          modifiedAttributes.maximumWidth\r\n        );\r\n        if (imageFragment) {\r\n          tableCellFragment.import(imageFragment);\r\n        }\r\n      } else if (isVNode(childVNode) && childVNode.tagName === 'figure') {\r\n        if (vNodeHasChildren(childVNode)) {\r\n          // eslint-disable-next-line no-plusplus\r\n          for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {\r\n            const grandChildVNode = childVNode.children[iteratorIndex];\r\n            if (grandChildVNode.tagName === 'img') {\r\n              const imageFragment = await buildImage(\r\n                docxDocumentInstance,\r\n                grandChildVNode,\r\n                modifiedAttributes.maximumWidth\r\n              );\r\n              if (imageFragment) {\r\n                tableCellFragment.import(imageFragment);\r\n              }\r\n            }\r\n          }\r\n        }\r\n      } else if (isVNode(childVNode) && ['ul', 'ol'].includes(childVNode.tagName)) {\r\n        // render list in table\r\n        if (vNodeHasChildren(childVNode)) {\r\n          await buildList(childVNode, docxDocumentInstance, tableCellFragment);\r\n        }\r\n      } else {\r\n        const paragraphFragment = await buildParagraph(\r\n          childVNode,\r\n          modifiedAttributes,\r\n          docxDocumentInstance\r\n        );\r\n\r\n        tableCellFragment.import(paragraphFragment);\r\n      }\r\n    }\r\n  } else {\r\n    // TODO: Figure out why building with buildParagraph() isn't working\r\n    const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })\r\n      .ele('@w', 'p')\r\n      .up();\r\n    tableCellFragment.import(paragraphFragment);\r\n  }\r\n  tableCellFragment.up();\r\n\r\n  return tableCellFragment;\r\n};\r\n\r\nconst buildRowSpanCell = (rowSpanMap, columnIndex, attributes) => {\r\n  const rowSpanCellFragments = [];\r\n  let spanObject = rowSpanMap.get(columnIndex.index);\r\n  while (spanObject && spanObject.rowSpan) {\r\n    const rowSpanCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');\r\n\r\n    const tableCellPropertiesFragment = buildTableCellProperties({\r\n      ...attributes,\r\n      rowSpan: 'continue',\r\n      colSpan: spanObject.colSpan ? spanObject.colSpan : 0,\r\n    });\r\n    rowSpanCellFragment.import(tableCellPropertiesFragment);\r\n\r\n    const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })\r\n      .ele('@w', 'p')\r\n      .up();\r\n    rowSpanCellFragment.import(paragraphFragment);\r\n    rowSpanCellFragment.up();\r\n\r\n    rowSpanCellFragments.push(rowSpanCellFragment);\r\n\r\n    if (spanObject.rowSpan - 1 === 0) {\r\n      rowSpanMap.delete(columnIndex.index);\r\n    } else {\r\n      rowSpanMap.set(columnIndex.index, {\r\n        rowSpan: spanObject.rowSpan - 1,\r\n        colSpan: spanObject.colSpan || 0,\r\n      });\r\n    }\r\n    columnIndex.index += spanObject.colSpan || 1;\r\n    spanObject = rowSpanMap.get(columnIndex.index);\r\n  }\r\n\r\n  return rowSpanCellFragments;\r\n};\r\n\r\nconst buildTableRowProperties = (attributes) => {\r\n  const tableRowPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'trPr'\r\n  );\r\n  if (attributes && attributes.constructor === Object) {\r\n    Object.keys(attributes).forEach((key) => {\r\n      switch (key) {\r\n        case 'tableRowHeight':\r\n          const tableRowHeightFragment = buildTableRowHeight(attributes[key]);\r\n          tableRowPropertiesFragment.import(tableRowHeightFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.tableRowHeight;\r\n          break;\r\n        case 'rowCantSplit':\r\n          if (attributes.rowCantSplit) {\r\n            const cantSplitFragment = fragment({ namespaceAlias: { w: namespaces.w } })\r\n              .ele('@w', 'cantSplit')\r\n              .up();\r\n            tableRowPropertiesFragment.import(cantSplitFragment);\r\n            // eslint-disable-next-line no-param-reassign\r\n            delete attributes.rowCantSplit;\r\n          }\r\n          break;\r\n      }\r\n    });\r\n  }\r\n  tableRowPropertiesFragment.up();\r\n  return tableRowPropertiesFragment;\r\n};\r\n\r\nconst buildTableRow = async (vNode, attributes, rowSpanMap, docxDocumentInstance) => {\r\n  const tableRowFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tr');\r\n  const modifiedAttributes = { ...attributes };\r\n  if (isVNode(vNode) && vNode.properties) {\r\n    // FIXME: find a better way to get row height from cell style\r\n    if (\r\n      (vNode.properties.style && vNode.properties.style.height) ||\r\n      (vNode.children[0] &&\r\n        isVNode(vNode.children[0]) &&\r\n        vNode.children[0].properties.style &&\r\n        vNode.children[0].properties.style.height)\r\n    ) {\r\n      modifiedAttributes.tableRowHeight = fixupRowHeight(\r\n        (vNode.properties.style && vNode.properties.style.height) ||\r\n          (vNode.children[0] &&\r\n          isVNode(vNode.children[0]) &&\r\n          vNode.children[0].properties.style &&\r\n          vNode.children[0].properties.style.height\r\n            ? vNode.children[0].properties.style.height\r\n            : undefined)\r\n      );\r\n    }\r\n    if (vNode.properties.style) {\r\n      fixupTableCellBorder(vNode, modifiedAttributes);\r\n    }\r\n  }\r\n\r\n  const tableRowPropertiesFragment = buildTableRowProperties(modifiedAttributes);\r\n  tableRowFragment.import(tableRowPropertiesFragment);\r\n\r\n  const columnIndex = { index: 0 };\r\n\r\n  if (vNodeHasChildren(vNode)) {\r\n    const tableColumns = vNode.children.filter((childVNode) =>\r\n      ['td', 'th'].includes(childVNode.tagName)\r\n    );\r\n    const maximumColumnWidth = docxDocumentInstance.availableDocumentSpace / tableColumns.length;\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    for (const column of tableColumns) {\r\n      const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);\r\n      if (Array.isArray(rowSpanCellFragments)) {\r\n        for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {\r\n          const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];\r\n\r\n          tableRowFragment.import(rowSpanCellFragment);\r\n        }\r\n      }\r\n      const tableCellFragment = await buildTableCell(\r\n        column,\r\n        { ...modifiedAttributes, maximumWidth: maximumColumnWidth },\r\n        rowSpanMap,\r\n        columnIndex,\r\n        docxDocumentInstance\r\n      );\r\n      columnIndex.index++;\r\n\r\n      tableRowFragment.import(tableCellFragment);\r\n    }\r\n  }\r\n\r\n  if (columnIndex.index < rowSpanMap.size) {\r\n    const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);\r\n    if (Array.isArray(rowSpanCellFragments)) {\r\n      for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {\r\n        const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];\r\n\r\n        tableRowFragment.import(rowSpanCellFragment);\r\n      }\r\n    }\r\n  }\r\n\r\n  tableRowFragment.up();\r\n\r\n  return tableRowFragment;\r\n};\r\n\r\nconst buildTableGridCol = (gridWidth) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'gridCol')\r\n    .att('@w', 'w', String(gridWidth));\r\n\r\nconst buildTableGrid = (vNode, attributes) => {\r\n  const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');\r\n  if (vNodeHasChildren(vNode)) {\r\n    const gridColumns = vNode.children.filter((childVNode) => childVNode.tagName === 'col');\r\n    const gridWidth = attributes.maximumWidth / gridColumns.length;\r\n\r\n    for (let index = 0; index < gridColumns.length; index++) {\r\n      const tableGridColFragment = buildTableGridCol(gridWidth);\r\n      tableGridFragment.import(tableGridColFragment);\r\n    }\r\n  }\r\n  tableGridFragment.up();\r\n\r\n  return tableGridFragment;\r\n};\r\n\r\nconst buildTableGridFromTableRow = (vNode, attributes) => {\r\n  const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');\r\n  if (vNodeHasChildren(vNode)) {\r\n    const numberOfGridColumns = vNode.children.reduce((accumulator, childVNode) => {\r\n      const colSpan =\r\n        childVNode.properties.colSpan ||\r\n        (childVNode.properties.style && childVNode.properties.style['column-span']);\r\n\r\n      return accumulator + (colSpan ? parseInt(colSpan) : 1);\r\n    }, 0);\r\n    const gridWidth = attributes.maximumWidth / numberOfGridColumns;\r\n\r\n    for (let index = 0; index < numberOfGridColumns; index++) {\r\n      const tableGridColFragment = buildTableGridCol(gridWidth);\r\n      tableGridFragment.import(tableGridColFragment);\r\n    }\r\n  }\r\n  tableGridFragment.up();\r\n\r\n  return tableGridFragment;\r\n};\r\n\r\nconst buildTableBorders = (tableBorder) => {\r\n  const tableBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'tblBorders'\r\n  );\r\n\r\n  const { color, stroke, ...borders } = tableBorder;\r\n\r\n  Object.keys(borders).forEach((border) => {\r\n    if (borders[border]) {\r\n      const borderFragment = buildBorder(border, borders[border], 0, color, stroke);\r\n      tableBordersFragment.import(borderFragment);\r\n    }\r\n  });\r\n\r\n  tableBordersFragment.up();\r\n\r\n  return tableBordersFragment;\r\n};\r\n\r\nconst buildTableWidth = (tableWidth) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', 'tblW')\r\n    .att('@w', 'type', 'dxa')\r\n    .att('@w', 'w', String(tableWidth))\r\n    .up();\r\n\r\nconst buildCellMargin = (side, margin) =>\r\n  fragment({ namespaceAlias: { w: namespaces.w } })\r\n    .ele('@w', side)\r\n    .att('@w', 'type', 'dxa')\r\n    .att('@w', 'w', String(margin))\r\n    .up();\r\n\r\nconst buildTableCellMargins = (margin) => {\r\n  const tableCellMarFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'tblCellMar'\r\n  );\r\n\r\n  ['top', 'bottom'].forEach((side) => {\r\n    const marginFragment = buildCellMargin(side, margin / 2);\r\n    tableCellMarFragment.import(marginFragment);\r\n  });\r\n  ['left', 'right'].forEach((side) => {\r\n    const marginFragment = buildCellMargin(side, margin);\r\n    tableCellMarFragment.import(marginFragment);\r\n  });\r\n\r\n  return tableCellMarFragment;\r\n};\r\n\r\nconst buildTableProperties = (attributes) => {\r\n  const tablePropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele(\r\n    '@w',\r\n    'tblPr'\r\n  );\r\n\r\n  if (attributes && attributes.constructor === Object) {\r\n    Object.keys(attributes).forEach((key) => {\r\n      switch (key) {\r\n        case 'tableBorder':\r\n          const tableBordersFragment = buildTableBorders(attributes[key]);\r\n          tablePropertiesFragment.import(tableBordersFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.tableBorder;\r\n          break;\r\n        case 'tableCellSpacing':\r\n          const tableCellSpacingFragment = buildTableCellSpacing(attributes[key]);\r\n          tablePropertiesFragment.import(tableCellSpacingFragment);\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.tableCellSpacing;\r\n          break;\r\n        case 'width':\r\n          if (attributes[key]) {\r\n            const tableWidthFragment = buildTableWidth(attributes[key]);\r\n            tablePropertiesFragment.import(tableWidthFragment);\r\n          }\r\n          // eslint-disable-next-line no-param-reassign\r\n          delete attributes.width;\r\n          break;\r\n      }\r\n    });\r\n  }\r\n  const tableCellMarginFragment = buildTableCellMargins(160);\r\n  tablePropertiesFragment.import(tableCellMarginFragment);\r\n\r\n  // by default, all tables are center aligned.\r\n  const alignmentFragment = buildHorizontalAlignment('center');\r\n  tablePropertiesFragment.import(alignmentFragment);\r\n\r\n  tablePropertiesFragment.up();\r\n\r\n  return tablePropertiesFragment;\r\n};\r\n\r\nconst cssBorderParser = (borderString) => {\r\n  let [size, stroke, color] = borderString.split(' ');\r\n\r\n  if (pointRegex.test(size)) {\r\n    const matchedParts = size.match(pointRegex);\r\n    // convert point to eighth of a point\r\n    size = pointToEIP(matchedParts[1]);\r\n  } else if (pixelRegex.test(size)) {\r\n    const matchedParts = size.match(pixelRegex);\r\n    // convert pixels to eighth of a point\r\n    size = pixelToEIP(matchedParts[1]);\r\n  }\r\n  stroke = stroke && ['dashed', 'dotted', 'double'].includes(stroke) ? stroke : 'single';\r\n\r\n  color = color && fixupColorCode(color).toUpperCase();\r\n\r\n  return [size, stroke, color];\r\n};\r\n\r\nconst buildTable = async (vNode, attributes, docxDocumentInstance) => {\r\n  const tableFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tbl');\r\n  const modifiedAttributes = { ...attributes };\r\n  if (isVNode(vNode) && vNode.properties) {\r\n    const tableAttributes = vNode.properties.attributes || {};\r\n    const tableStyles = vNode.properties.style || {};\r\n    const tableBorders = {};\r\n    const tableCellBorders = {};\r\n    let [borderSize, borderStrike, borderColor] = [2, 'single', '000000'];\r\n\r\n    // eslint-disable-next-line no-restricted-globals\r\n    if (!isNaN(tableAttributes.border)) {\r\n      borderSize = parseInt(tableAttributes.border, 10);\r\n    }\r\n\r\n    // css style overrides table border properties\r\n    if (tableStyles.border) {\r\n      const [cssSize, cssStroke, cssColor] = cssBorderParser(tableStyles.border);\r\n      borderSize = cssSize || borderSize;\r\n      borderColor = cssColor || borderColor;\r\n      borderStrike = cssStroke || borderStrike;\r\n    }\r\n\r\n    tableBorders.top = borderSize;\r\n    tableBorders.bottom = borderSize;\r\n    tableBorders.left = borderSize;\r\n    tableBorders.right = borderSize;\r\n    tableBorders.stroke = borderStrike;\r\n    tableBorders.color = borderColor;\r\n\r\n    if (tableStyles['border-collapse'] === 'collapse') {\r\n      tableBorders.insideV = borderSize;\r\n      tableBorders.insideH = borderSize;\r\n    } else {\r\n      tableBorders.insideV = 0;\r\n      tableBorders.insideH = 0;\r\n      tableCellBorders.top = 1;\r\n      tableCellBorders.bottom = 1;\r\n      tableCellBorders.left = 1;\r\n      tableCellBorders.right = 1;\r\n    }\r\n\r\n    modifiedAttributes.tableBorder = tableBorders;\r\n    modifiedAttributes.tableCellSpacing = 0;\r\n\r\n    if (Object.keys(tableCellBorders).length) {\r\n      modifiedAttributes.tableCellBorder = tableCellBorders;\r\n    }\r\n\r\n    let minimumWidth;\r\n    let maximumWidth;\r\n    let width;\r\n    // Calculate minimum width of table\r\n    if (pixelRegex.test(tableStyles['min-width'])) {\r\n      minimumWidth = pixelToTWIP(tableStyles['min-width'].match(pixelRegex)[1]);\r\n    } else if (percentageRegex.test(tableStyles['min-width'])) {\r\n      const percentageValue = tableStyles['min-width'].match(percentageRegex)[1];\r\n      minimumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);\r\n    }\r\n\r\n    // Calculate maximum width of table\r\n    if (pixelRegex.test(tableStyles['max-width'])) {\r\n      pixelRegex.lastIndex = 0;\r\n      maximumWidth = pixelToTWIP(tableStyles['max-width'].match(pixelRegex)[1]);\r\n    } else if (percentageRegex.test(tableStyles['max-width'])) {\r\n      percentageRegex.lastIndex = 0;\r\n      const percentageValue = tableStyles['max-width'].match(percentageRegex)[1];\r\n      maximumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);\r\n    }\r\n\r\n    // Calculate specified width of table\r\n    if (pixelRegex.test(tableStyles.width)) {\r\n      pixelRegex.lastIndex = 0;\r\n      width = pixelToTWIP(tableStyles.width.match(pixelRegex)[1]);\r\n    } else if (percentageRegex.test(tableStyles.width)) {\r\n      percentageRegex.lastIndex = 0;\r\n      const percentageValue = tableStyles.width.match(percentageRegex)[1];\r\n      width = Math.round((percentageValue / 100) * attributes.maximumWidth);\r\n    }\r\n\r\n    // If width isn't supplied, we should have min-width as the width.\r\n    if (width) {\r\n      modifiedAttributes.width = width;\r\n      if (maximumWidth) {\r\n        modifiedAttributes.width = Math.min(modifiedAttributes.width, maximumWidth);\r\n      }\r\n      if (minimumWidth) {\r\n        modifiedAttributes.width = Math.max(modifiedAttributes.width, minimumWidth);\r\n      }\r\n    } else if (minimumWidth) {\r\n      modifiedAttributes.width = minimumWidth;\r\n    }\r\n    if (modifiedAttributes.width) {\r\n      modifiedAttributes.width = Math.min(modifiedAttributes.width, attributes.maximumWidth);\r\n    }\r\n  }\r\n  const tablePropertiesFragment = buildTableProperties(modifiedAttributes);\r\n  tableFragment.import(tablePropertiesFragment);\r\n\r\n  const rowSpanMap = new Map();\r\n\r\n  if (vNodeHasChildren(vNode)) {\r\n    for (let index = 0; index < vNode.children.length; index++) {\r\n      const childVNode = vNode.children[index];\r\n      if (childVNode.tagName === 'colgroup') {\r\n        const tableGridFragment = buildTableGrid(childVNode, modifiedAttributes);\r\n        tableFragment.import(tableGridFragment);\r\n      } else if (childVNode.tagName === 'thead') {\r\n        for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {\r\n          const grandChildVNode = childVNode.children[iteratorIndex];\r\n          if (grandChildVNode.tagName === 'tr') {\r\n            if (iteratorIndex === 0) {\r\n              const tableGridFragment = buildTableGridFromTableRow(\r\n                grandChildVNode,\r\n                modifiedAttributes\r\n              );\r\n              tableFragment.import(tableGridFragment);\r\n            }\r\n            const tableRowFragment = await buildTableRow(\r\n              grandChildVNode,\r\n              modifiedAttributes,\r\n              rowSpanMap,\r\n              docxDocumentInstance\r\n            );\r\n            tableFragment.import(tableRowFragment);\r\n          }\r\n        }\r\n      } else if (childVNode.tagName === 'tbody') {\r\n        for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {\r\n          const grandChildVNode = childVNode.children[iteratorIndex];\r\n          if (grandChildVNode.tagName === 'tr') {\r\n            if (iteratorIndex === 0) {\r\n              const tableGridFragment = buildTableGridFromTableRow(\r\n                grandChildVNode,\r\n                modifiedAttributes\r\n              );\r\n              tableFragment.import(tableGridFragment);\r\n            }\r\n            const tableRowFragment = await buildTableRow(\r\n              grandChildVNode,\r\n              modifiedAttributes,\r\n              rowSpanMap,\r\n              docxDocumentInstance\r\n            );\r\n            tableFragment.import(tableRowFragment);\r\n          }\r\n        }\r\n      } else if (childVNode.tagName === 'tr') {\r\n        if (index === 0) {\r\n          const tableGridFragment = buildTableGridFromTableRow(childVNode, modifiedAttributes);\r\n          tableFragment.import(tableGridFragment);\r\n        }\r\n        const tableRowFragment = await buildTableRow(\r\n          childVNode,\r\n          modifiedAttributes,\r\n          rowSpanMap,\r\n          docxDocumentInstance\r\n        );\r\n        tableFragment.import(tableRowFragment);\r\n      }\r\n    }\r\n  }\r\n  tableFragment.up();\r\n\r\n  return tableFragment;\r\n};\r\n\r\nconst buildPresetGeometry = () =>\r\n  fragment({ namespaceAlias: { a: namespaces.a } })\r\n    .ele('@a', 'prstGeom')\r\n    .att('prst', 'rect')\r\n    .up();\r\n\r\nconst buildExtents = ({ width, height }) =>\r\n  fragment({ namespaceAlias: { a: namespaces.a } })\r\n    .ele('@a', 'ext')\r\n    .att('cx', width)\r\n    .att('cy', height)\r\n    .up();\r\n\r\nconst buildOffset = () =>\r\n  fragment({ namespaceAlias: { a: namespaces.a } })\r\n    .ele('@a', 'off')\r\n    .att('x', '0')\r\n    .att('y', '0')\r\n    .up();\r\n\r\nconst buildGraphicFrameTransform = (attributes) => {\r\n  const graphicFrameTransformFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele(\r\n    '@a',\r\n    'xfrm'\r\n  );\r\n\r\n  const offsetFragment = buildOffset();\r\n  graphicFrameTransformFragment.import(offsetFragment);\r\n  const extentsFragment = buildExtents(attributes);\r\n  graphicFrameTransformFragment.import(extentsFragment);\r\n\r\n  graphicFrameTransformFragment.up();\r\n\r\n  return graphicFrameTransformFragment;\r\n};\r\n\r\nconst buildShapeProperties = (attributes) => {\r\n  const shapeProperties = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'spPr');\r\n\r\n  const graphicFrameTransformFragment = buildGraphicFrameTransform(attributes);\r\n  shapeProperties.import(graphicFrameTransformFragment);\r\n  const presetGeometryFragment = buildPresetGeometry();\r\n  shapeProperties.import(presetGeometryFragment);\r\n\r\n  shapeProperties.up();\r\n\r\n  return shapeProperties;\r\n};\r\n\r\nconst buildFillRect = () =>\r\n  fragment({ namespaceAlias: { a: namespaces.a } })\r\n    .ele('@a', 'fillRect')\r\n    .up();\r\n\r\nconst buildStretch = () => {\r\n  const stretchFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'stretch');\r\n\r\n  const fillRectFragment = buildFillRect();\r\n  stretchFragment.import(fillRectFragment);\r\n\r\n  stretchFragment.up();\r\n\r\n  return stretchFragment;\r\n};\r\n\r\nconst buildSrcRectFragment = () =>\r\n  fragment({ namespaceAlias: { a: namespaces.a } })\r\n    .ele('@a', 'srcRect')\r\n    .att('b', '0')\r\n    .att('l', '0')\r\n    .att('r', '0')\r\n    .att('t', '0')\r\n    .up();\r\n\r\nconst buildBinaryLargeImageOrPicture = (relationshipId) =>\r\n  fragment({\r\n    namespaceAlias: { a: namespaces.a, r: namespaces.r },\r\n  })\r\n    .ele('@a', 'blip')\r\n    .att('@r', 'embed', `rId${relationshipId}`)\r\n    // FIXME: possible values 'email', 'none', 'print', 'hqprint', 'screen'\r\n    .att('cstate', 'print')\r\n    .up();\r\n\r\nconst buildBinaryLargeImageOrPictureFill = (relationshipId) => {\r\n  const binaryLargeImageOrPictureFillFragment = fragment({\r\n    namespaceAlias: { pic: namespaces.pic },\r\n  }).ele('@pic', 'blipFill');\r\n  const binaryLargeImageOrPictureFragment = buildBinaryLargeImageOrPicture(relationshipId);\r\n  binaryLargeImageOrPictureFillFragment.import(binaryLargeImageOrPictureFragment);\r\n  const srcRectFragment = buildSrcRectFragment();\r\n  binaryLargeImageOrPictureFillFragment.import(srcRectFragment);\r\n  const stretchFragment = buildStretch();\r\n  binaryLargeImageOrPictureFillFragment.import(stretchFragment);\r\n\r\n  binaryLargeImageOrPictureFillFragment.up();\r\n\r\n  return binaryLargeImageOrPictureFillFragment;\r\n};\r\n\r\nconst buildNonVisualPictureDrawingProperties = () =>\r\n  fragment({ namespaceAlias: { pic: namespaces.pic } })\r\n    .ele('@pic', 'cNvPicPr')\r\n    .up();\r\n\r\nconst buildNonVisualDrawingProperties = (\r\n  pictureId,\r\n  pictureNameWithExtension,\r\n  pictureDescription = ''\r\n) =>\r\n  fragment({ namespaceAlias: { pic: namespaces.pic } })\r\n    .ele('@pic', 'cNvPr')\r\n    .att('id', pictureId)\r\n    .att('name', pictureNameWithExtension)\r\n    .att('descr', pictureDescription)\r\n    .up();\r\n\r\nconst buildNonVisualPictureProperties = (\r\n  pictureId,\r\n  pictureNameWithExtension,\r\n  pictureDescription\r\n) => {\r\n  const nonVisualPicturePropertiesFragment = fragment({\r\n    namespaceAlias: { pic: namespaces.pic },\r\n  }).ele('@pic', 'nvPicPr');\r\n  // TODO: Handle picture attributes\r\n  const nonVisualDrawingPropertiesFragment = buildNonVisualDrawingProperties(\r\n    pictureId,\r\n    pictureNameWithExtension,\r\n    pictureDescription\r\n  );\r\n  nonVisualPicturePropertiesFragment.import(nonVisualDrawingPropertiesFragment);\r\n  const nonVisualPictureDrawingPropertiesFragment = buildNonVisualPictureDrawingProperties();\r\n  nonVisualPicturePropertiesFragment.import(nonVisualPictureDrawingPropertiesFragment);\r\n  nonVisualPicturePropertiesFragment.up();\r\n\r\n  return nonVisualPicturePropertiesFragment;\r\n};\r\n\r\nconst buildPicture = ({\r\n  id,\r\n  fileNameWithExtension,\r\n  description,\r\n  relationshipId,\r\n  width,\r\n  height,\r\n}) => {\r\n  const pictureFragment = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'pic');\r\n  const nonVisualPicturePropertiesFragment = buildNonVisualPictureProperties(\r\n    id,\r\n    fileNameWithExtension,\r\n    description\r\n  );\r\n  pictureFragment.import(nonVisualPicturePropertiesFragment);\r\n  const binaryLargeImageOrPictureFill = buildBinaryLargeImageOrPictureFill(relationshipId);\r\n  pictureFragment.import(binaryLargeImageOrPictureFill);\r\n  const shapeProperties = buildShapeProperties({ width, height });\r\n  pictureFragment.import(shapeProperties);\r\n  pictureFragment.up();\r\n\r\n  return pictureFragment;\r\n};\r\n\r\nconst buildGraphicData = (graphicType, attributes) => {\r\n  const graphicDataFragment = fragment({ namespaceAlias: { a: namespaces.a } })\r\n    .ele('@a', 'graphicData')\r\n    .att('uri', 'http://schemas.openxmlformats.org/drawingml/2006/picture');\r\n  if (graphicType === 'picture') {\r\n    const pictureFragment = buildPicture(attributes);\r\n    graphicDataFragment.import(pictureFragment);\r\n  }\r\n  graphicDataFragment.up();\r\n\r\n  return graphicDataFragment;\r\n};\r\n\r\nconst buildGraphic = (graphicType, attributes) => {\r\n  const graphicFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'graphic');\r\n  // TODO: Handle drawing type\r\n  const graphicDataFragment = buildGraphicData(graphicType, attributes);\r\n  graphicFragment.import(graphicDataFragment);\r\n  graphicFragment.up();\r\n\r\n  return graphicFragment;\r\n};\r\n\r\nconst buildDrawingObjectNonVisualProperties = (pictureId, pictureName) =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'docPr')\r\n    .att('id', pictureId)\r\n    .att('name', pictureName)\r\n    .up();\r\n\r\nconst buildWrapSquare = () =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'wrapSquare')\r\n    .att('wrapText', 'bothSides')\r\n    .att('distB', '228600')\r\n    .att('distT', '228600')\r\n    .att('distL', '228600')\r\n    .att('distR', '228600')\r\n    .up();\r\n\r\n// eslint-disable-next-line no-unused-vars\r\nconst buildWrapNone = () =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'wrapNone')\r\n    .up();\r\n\r\nconst buildEffectExtentFragment = () =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'effectExtent')\r\n    .att('b', '0')\r\n    .att('l', '0')\r\n    .att('r', '0')\r\n    .att('t', '0')\r\n    .up();\r\n\r\nconst buildExtent = ({ width, height }) =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'extent')\r\n    .att('cx', width)\r\n    .att('cy', height)\r\n    .up();\r\n\r\nconst buildPositionV = () =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'positionV')\r\n    .att('relativeFrom', 'paragraph')\r\n    .ele('@wp', 'posOffset')\r\n    .txt('19050')\r\n    .up()\r\n    .up();\r\n\r\nconst buildPositionH = () =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'positionH')\r\n    .att('relativeFrom', 'column')\r\n    .ele('@wp', 'posOffset')\r\n    .txt('19050')\r\n    .up()\r\n    .up();\r\n\r\nconst buildSimplePos = () =>\r\n  fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'simplePos')\r\n    .att('x', '0')\r\n    .att('y', '0')\r\n    .up();\r\n\r\nconst buildAnchoredDrawing = (graphicType, attributes) => {\r\n  const anchoredDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'anchor')\r\n    .att('distB', '0')\r\n    .att('distL', '0')\r\n    .att('distR', '0')\r\n    .att('distT', '0')\r\n    .att('relativeHeight', '0')\r\n    .att('behindDoc', 'false')\r\n    .att('locked', 'true')\r\n    .att('layoutInCell', 'true')\r\n    .att('allowOverlap', 'false')\r\n    .att('simplePos', 'false');\r\n  // Even though simplePos isnt supported by Word 2007 simplePos is required.\r\n  const simplePosFragment = buildSimplePos();\r\n  anchoredDrawingFragment.import(simplePosFragment);\r\n  const positionHFragment = buildPositionH();\r\n  anchoredDrawingFragment.import(positionHFragment);\r\n  const positionVFragment = buildPositionV();\r\n  anchoredDrawingFragment.import(positionVFragment);\r\n  const extentFragment = buildExtent({ width: attributes.width, height: attributes.height });\r\n  anchoredDrawingFragment.import(extentFragment);\r\n  const effectExtentFragment = buildEffectExtentFragment();\r\n  anchoredDrawingFragment.import(effectExtentFragment);\r\n  const wrapSquareFragment = buildWrapSquare();\r\n  anchoredDrawingFragment.import(wrapSquareFragment);\r\n  const drawingObjectNonVisualPropertiesFragment = buildDrawingObjectNonVisualProperties(\r\n    attributes.id,\r\n    attributes.fileNameWithExtension\r\n  );\r\n  anchoredDrawingFragment.import(drawingObjectNonVisualPropertiesFragment);\r\n  const graphicFragment = buildGraphic(graphicType, attributes);\r\n  anchoredDrawingFragment.import(graphicFragment);\r\n\r\n  anchoredDrawingFragment.up();\r\n\r\n  return anchoredDrawingFragment;\r\n};\r\n\r\nconst buildInlineDrawing = (graphicType, attributes) => {\r\n  const inlineDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })\r\n    .ele('@wp', 'inline')\r\n    .att('distB', '0')\r\n    .att('distL', '0')\r\n    .att('distR', '0')\r\n    .att('distT', '0');\r\n\r\n  const extentFragment = buildExtent({ width: attributes.width, height: attributes.height });\r\n  inlineDrawingFragment.import(extentFragment);\r\n  const effectExtentFragment = buildEffectExtentFragment();\r\n  inlineDrawingFragment.import(effectExtentFragment);\r\n  const drawingObjectNonVisualPropertiesFragment = buildDrawingObjectNonVisualProperties(\r\n    attributes.id,\r\n    attributes.fileNameWithExtension\r\n  );\r\n  inlineDrawingFragment.import(drawingObjectNonVisualPropertiesFragment);\r\n  const graphicFragment = buildGraphic(graphicType, attributes);\r\n  inlineDrawingFragment.import(graphicFragment);\r\n\r\n  inlineDrawingFragment.up();\r\n\r\n  return inlineDrawingFragment;\r\n};\r\n\r\nconst buildDrawing = (inlineOrAnchored = false, graphicType, attributes) => {\r\n  const drawingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'drawing');\r\n  const inlineOrAnchoredDrawingFragment = inlineOrAnchored\r\n    ? buildInlineDrawing(graphicType, attributes)\r\n    : buildAnchoredDrawing(graphicType, attributes);\r\n  drawingFragment.import(inlineOrAnchoredDrawingFragment);\r\n  drawingFragment.up();\r\n\r\n  return drawingFragment;\r\n};\r\n\r\nexport {\r\n  buildParagraph,\r\n  buildTable,\r\n  buildNumberingInstances,\r\n  buildLineBreak,\r\n  buildIndentation,\r\n  buildTextElement,\r\n  buildBold,\r\n  buildItalics,\r\n  buildUnderline,\r\n  buildDrawing,\r\n  fixupLineHeight,\r\n};\r\n"]}