npm - @bnsights/bbsf-utilities - Versions diffs - 1.0.69-beta.1 → 1.0.69-beta.2 - Mend

@bnsights/bbsf-utilities 1.0.69-beta.1 → 1.0.69-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +28 -1
package/esm2022/lib/shared/services/word-document.service.mjs +22 -3
package/esm2022/public-api.mjs +2 -1
package/esm2022/word/public-api.mjs +4 -1
package/fesm2022/bnsights-bbsf-utilities-index-C3Twnewr.mjs +3536 -0
package/fesm2022/bnsights-bbsf-utilities-index-C3Twnewr.mjs.map +1 -0
package/fesm2022/bnsights-bbsf-utilities-word.mjs +3 -0
package/fesm2022/bnsights-bbsf-utilities-word.mjs.map +1 -1
package/fesm2022/bnsights-bbsf-utilities.mjs +20 -3533
package/fesm2022/bnsights-bbsf-utilities.mjs.map +1 -1
package/lib/shared/services/word-document.service.d.ts +17 -0
package/package.json +7 -7

package/fesm2022/bnsights-bbsf-utilities.mjs CHANGED Viewed

@@ -18,20 +18,6 @@ import { JwtHelperService } from '@auth0/angular-jwt';
 import { __decorate } from 'tslib';
 import { plainToClass } from 'class-transformer';
 import { takeUntil, tap, map } from 'rxjs/operators';
-import JSZip from 'jszip';
-import { fragment, create } from 'xmlbuilder2';
-import VNode$1 from 'virtual-dom/vnode/vnode';
-import VText from 'virtual-dom/vnode/vtext';
-import HTMLToVDOM from 'html-to-vdom';
-import { cloneDeep } from 'lodash';
-import { nanoid } from 'nanoid';
-import isVNode from 'virtual-dom/vnode/is-vnode';
-import isVText from 'virtual-dom/vnode/is-vtext';
-import escape from 'escape-html';
-import colorNames from 'color-name';
-import imageToBase64 from 'image-to-base64';
-import mimeTypes from 'mime-types';
-import sizeOf from 'image-size';
 class User {
 }
@@ -894,3527 +880,28 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }]
         }], ctorParameters: () => [{ type: BBSFTranslateService }, { type: EnvironmentService }, { type: i0.Injector }], propDecorators: { blockUI: [] } });
-const contentTypesXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
-        <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
-        <Default Extension="jpeg" ContentType="image/jpeg"/>
-        <Default Extension="png" ContentType="image/png"/>
-        <Default Extension="xml" ContentType="application/xml"/>
-        <Override PartName="/_rels/.rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-        <Override PartName="/word/_rels/document.xml.rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-        <Override PartName="/word/_rels/footer1.xml.rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-        <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
-        <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
-        <Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>
-        <Override PartName="/word/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>
-        <Override PartName="/word/fontTable.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>
-        <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
-        <Override PartName="/word/settings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>
-        <Override PartName="/word/webSettings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"/>
-        <Override PartName="/word/afchunk.mht" ContentType="message/rfc822"/>
-        <Override PartName="/word/afchunkheader.mht" ContentType="message/rfc822"/>
-        <Override PartName="/word/afchunkfooter.mht" ContentType="message/rfc822"/>
-    </Types>
-`;
-const namespaces = {
-    a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
-    b: 'http://schemas.openxmlformats.org/officeDocument/2006/bibliography',
-    cdr: 'http://schemas.openxmlformats.org/drawingml/2006/chartDrawing',
-    dc: 'http://purl.org/dc/elements/1.1/',
-    dcmitype: 'http://purl.org/dc/dcmitype/',
-    dcterms: 'http://purl.org/dc/terms/',
-    o: 'urn:schemas-microsoft-com:office:office',
-    pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
-    r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
-    v: 'urn:schemas-microsoft-com:vml',
-    ve: 'http://schemas.openxmlformats.org/markup-compatibility/2006',
-    vt: 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes',
-    w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-    w10: 'urn:schemas-microsoft-com:office:word',
-    wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
-    wne: 'http://schemas.microsoft.com/office/word/2006/wordml',
-    xsd: 'http://www.w3.org/2001/XMLSchema',
-    xsi: 'http://www.w3.org/2001/XMLSchema-instance',
-    numbering: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering',
-    hyperlinks: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink',
-    images: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image',
-    styles: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles',
-    headers: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header',
-    footers: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer',
-    themes: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme',
-    coreProperties: 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties',
-    officeDocumentRelation: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument',
-    corePropertiesRelation: 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties',
-    settingsRelation: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings',
-    webSettingsRelation: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings',
-    sl: 'http://schemas.openxmlformats.org/schemaLibrary/2006/main',
-    contentTypes: 'http://schemas.openxmlformats.org/package/2006/content-types',
-    relationship: 'http://schemas.openxmlformats.org/package/2006/relationships',
-};
-const applicationName = 'html-to-docx';
-const defaultOrientation = 'portrait';
-const landscapeWidth = 15840;
-const landscapeHeight = 12240;
-const landscapeMargins = {
-    top: 1800,
-    right: 1440,
-    bottom: 1800,
-    left: 1440,
-    header: 720,
-    footer: 720,
-    gutter: 0,
-};
-const portraitMargins = {
-    top: 1440,
-    right: 1800,
-    bottom: 1440,
-    left: 1800,
-    header: 720,
-    footer: 720,
-    gutter: 0,
-};
-const defaultFont = 'Times New Roman';
-const defaultFontSize = 22;
-const defaultDocumentOptions = {
-    orientation: defaultOrientation,
-    margins: cloneDeep(portraitMargins),
-    title: '',
-    subject: '',
-    creator: applicationName,
-    keywords: [applicationName],
-    description: '',
-    lastModifiedBy: applicationName,
-    revision: 1,
-    createdAt: new Date(),
-    modifiedAt: new Date(),
-    headerType: 'default',
-    header: false,
-    footerType: 'default',
-    footer: false,
-    font: defaultFont,
-    fontSize: defaultFontSize,
-    complexScriptFontSize: defaultFontSize,
-    table: {
-        row: {
-            cantSplit: false,
-        },
-    },
-    pageSize: {
-        width: landscapeHeight,
-        height: landscapeWidth,
-    },
-    pageNumber: false,
-    skipFirstHeaderFooter: false,
-    lineNumber: false,
-    lineNumberOptions: {
-        countBy: 1,
-        start: 0,
-        restart: 'continuous',
-    },
-    numbering: {
-        defaultOrderedListStyleType: 'decimal',
-    },
-};
-const defaultHTMLString = '<p></p>';
-const relsFolderName = '_rels';
-const headerFileName = 'header1';
-const footerFileName = 'footer1';
-const themeFileName = 'theme1';
-const documentFileName = 'document';
-const headerType = 'header';
-const footerType = 'footer';
-const themeType = 'theme';
-const hyperlinkType = 'hyperlink';
-const imageType = 'image';
-const internalRelationship = 'Internal';
-const wordFolder = 'word';
-const themeFolder = 'theme';
-const paragraphBordersObject = {
-    top: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-    left: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-    bottom: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-    right: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-};
-const colorlessColors = ['transparent', 'auto'];
-const verticalAlignValues = ['top', 'middle', 'bottom'];
-const generateCoreXML = (title = '', subject = '', creator = applicationName, keywords = [applicationName], description = '', lastModifiedBy = applicationName, revision = 1, createdAt = new Date(), modifiedAt = new Date()) => `
-        <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-        <cp:coreProperties
-          xmlns:cp="${namespaces.coreProperties}"
-          xmlns:dc="${namespaces.dc}"
-          xmlns:dcterms="${namespaces.dcterms}"
-          xmlns:dcmitype="${namespaces.dcmitype}"
-          xmlns:xsi="${namespaces.xsi}"
-          >
-            <dc:title>${title}</dc:title>
-            <dc:subject>${subject}</dc:subject>
-            <dc:creator>${creator}</dc:creator>
-            ${keywords && Array.isArray(keywords)
-    ? `<cp:keywords>${keywords.join(', ')}</cp:keywords>`
-    : ''}
-            <dc:description>${description}</dc:description>
-            <cp:lastModifiedBy>${lastModifiedBy}</cp:lastModifiedBy>
-            <cp:revision>${revision}</cp:revision>
-            <dcterms:created xsi:type="dcterms:W3CDTF">${createdAt instanceof Date ? createdAt.toISOString() : new Date().toISOString()}</dcterms:created>
-            <dcterms:modified xsi:type="dcterms:W3CDTF">${modifiedAt instanceof Date ? modifiedAt.toISOString() : new Date().toISOString()}</dcterms:modified>
-        </cp:coreProperties>
-    `;
-const documentRelsXML = `
-  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-  <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-    <Relationship Id="rId1" Type="${namespaces.numbering}" Target="numbering.xml"/>
-    <Relationship Id="rId2" Type="${namespaces.styles}" Target="styles.xml"/>
-    <Relationship Id="rId3" Type="${namespaces.settingsRelation}" Target="settings.xml"/>
-    <Relationship Id="rId4" Type="${namespaces.webSettingsRelation}" Target="webSettings.xml"/>
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunk.mht" Id="htmlChunk" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkheader.mht" Id="htmlChunkHeader" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkfooter.mht" Id="htmlChunkFooter" />
-  </Relationships>
-`;
-const relsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-        <Relationship Id="rId1" Type="${namespaces.officeDocumentRelation}" Target="word/document.xml"/>
-        <Relationship Id="rId2" Type="${namespaces.corePropertiesRelation}" Target="docProps/core.xml"/>
-    </Relationships>
-`;
-const generateNumberingXMLTemplate = () => `
-        <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-        <w:numbering
-        xmlns:w="${namespaces.w}"
-        xmlns:ve="${namespaces.ve}"
-        xmlns:o="${namespaces.o}"
-        xmlns:r="${namespaces.r}"
-        xmlns:v="${namespaces.v}"
-        xmlns:wp="${namespaces.wp}"
-        xmlns:w10="${namespaces.w10}"
-        xmlns:wne="${namespaces.wne}">
-        </w:numbering>
-    `;
-const generateStylesXML = (font = defaultFont, fontSize = defaultFontSize, complexScriptFontSize = defaultFontSize) => `
-  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-  <w:styles xmlns:w="${namespaces.w}" xmlns:r="${namespaces.r}">
-	<w:docDefaults>
-	  <w:rPrDefault>
-		<w:rPr>
-		  <w:rFonts w:ascii="${font}" w:eastAsiaTheme="minorHAnsi" w:hAnsiTheme="minorHAnsi" w:cstheme="minorBidi" />
-		  <w:sz w:val="${fontSize}" />
-		  <w:szCs w:val="${complexScriptFontSize}" />
-		  <w:lang w:val="en-US" w:eastAsia="en-US" w:bidi="ar-SA" />
-		</w:rPr>
-	  </w:rPrDefault>
-	  <w:pPrDefault>
-		<w:pPr>
-		  <w:spacing w:after="120" w:line="240" w:lineRule="atLeast" />
-		</w:pPr>
-	  </w:pPrDefault>
-	</w:docDefaults>
-	<w:style w:type="character" w:styleId="Hyperlink">
-	  <w:name w:val="Hyperlink" />
-	  <w:rPr>
-		<w:color w:val="0000FF" />
-		<w:u w:val="single" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading1">
-	  <w:name w:val="heading 1" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="480" />
-		<w:outlineLvl w:val="0" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="48" />
-		<w:szCs w:val="48" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading2">
-	  <w:name w:val="heading 2" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="360" w:after="80" />
-		<w:outlineLvl w:val="1" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="36" />
-		<w:szCs w:val="36" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading3">
-	  <w:name w:val="heading 3" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="280" w:after="80" />
-		<w:outlineLvl w:val="2" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="28" />
-		<w:szCs w:val="28" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading4">
-	  <w:name w:val="heading 4" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="240" w:after="40" />
-		<w:outlineLvl w:val="3" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="24" />
-		<w:szCs w:val="24" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading5">
-	  <w:name w:val="heading 5" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="220" w:after="40" />
-		<w:outlineLvl w:val="4" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading6">
-	  <w:name w:val="heading 6" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="200" w:after="40" />
-		<w:outlineLvl w:val="5" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="20" />
-		<w:szCs w:val="20" />
-	  </w:rPr>
-	</w:style>
-  </w:styles>
-  `;
-const fontTableXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <w:fonts
-      xmlns:r="${namespaces.r}"
-      xmlns:w="${namespaces.w}"
-      >
-        <w:font w:name="Symbol">
-            <w:panose1 w:val="05050102010706020507"/>
-            <w:charset w:val="02"/>
-            <w:family w:val="decorative"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="00000000" w:usb1="10000000" w:usb2="00000000" w:usb3="00000000" w:csb0="80000000" w:csb1="00000000"/>
-        </w:font>
-        <w:font w:name="Calibri">
-            <w:panose1 w:val="020F0502020204030204"/>
-            <w:charset w:val="00"/>
-            <w:family w:val="swiss"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="E4002EFF" w:usb1="C000247B" w:usb2="00000009" w:usb3="00000000" w:csb0="000001FF" w:csb1="00000000"/>
-        </w:font>
-        <w:font w:name="Times New Roman">
-            <w:panose1 w:val="02020603050405020304"/>
-            <w:charset w:val="00"/>
-            <w:family w:val="roman"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="E0002EFF" w:usb1="C000785B" w:usb2="00000009" w:usb3="00000000" w:csb0="000001FF" w:csb1="00000000"/>
-        </w:font>
-        <w:font w:name="Calibri Light">
-            <w:panose1 w:val="020F0302020204030204"/>
-            <w:charset w:val="00"/>
-            <w:family w:val="swiss"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="E4002EFF" w:usb1="C000247B" w:usb2="00000009" w:usb3="00000000" w:csb0="000001FF" w:csb1="00000000"/>
-        </w:font>
-    </w:fonts>
-`;
-const generateThemeXML = (font = defaultFont) => `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Office Theme">
-    <a:themeElements>
-      <a:clrScheme name="Office">
-        <a:dk1>
-          <a:sysClr val="windowText" lastClr="000000"/>
-        </a:dk1>
-        <a:lt1>
-          <a:sysClr val="window" lastClr="FFFFFF"/>
-        </a:lt1>
-        <a:dk2>
-          <a:srgbClr val="44546A"/>
-        </a:dk2>
-        <a:lt2>
-          <a:srgbClr val="E7E6E6"/>
-        </a:lt2>
-        <a:accent1>
-          <a:srgbClr val="4472C4"/>
-        </a:accent1>
-        <a:accent2>
-          <a:srgbClr val="ED7D31"/>
-        </a:accent2>
-        <a:accent3>
-          <a:srgbClr val="A5A5A5"/>
-        </a:accent3>
-        <a:accent4>
-          <a:srgbClr val="FFC000"/>
-        </a:accent4>
-        <a:accent5>
-          <a:srgbClr val="5B9BD5"/>
-        </a:accent5>
-        <a:accent6>
-          <a:srgbClr val="70AD47"/>
-        </a:accent6>
-        <a:hlink>
-          <a:srgbClr val="0563C1"/>
-        </a:hlink>
-        <a:folHlink>
-          <a:srgbClr val="954F72"/>
-        </a:folHlink>
-      </a:clrScheme>
-      <a:fontScheme name="Office">
-        <a:majorFont>
-          <a:latin typeface="${font}"/>
-          <a:ea typeface="${font}"/>
-          <a:cs typeface=""/>
-        </a:majorFont>
-        <a:minorFont>
-          <a:latin typeface="${font}"/>
-          <a:ea typeface="${font}"/>
-          <a:cs typeface=""/>
-        </a:minorFont>
-      </a:fontScheme>
-      <a:fmtScheme name="Office">
-        <a:fillStyleLst>
-          <a:solidFill>
-            <a:schemeClr val="phClr"/>
-          </a:solidFill>
-          <a:gradFill rotWithShape="1">
-            <a:gsLst>
-              <a:gs pos="0">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="110000"/>
-                  <a:satMod val="105000"/>
-                  <a:tint val="67000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="50000">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="105000"/>
-                  <a:satMod val="103000"/>
-                  <a:tint val="73000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="100000">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="105000"/>
-                  <a:satMod val="109000"/>
-                  <a:tint val="81000"/>
-                </a:schemeClr>
-              </a:gs>
-            </a:gsLst>
-            <a:lin ang="5400000" scaled="0"/>
-          </a:gradFill>
-          <a:gradFill rotWithShape="1">
-            <a:gsLst>
-              <a:gs pos="0">
-                <a:schemeClr val="phClr">
-                  <a:satMod val="103000"/>
-                  <a:lumMod val="102000"/>
-                  <a:tint val="94000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="50000">
-                <a:schemeClr val="phClr">
-                  <a:satMod val="110000"/>
-                  <a:lumMod val="100000"/>
-                  <a:shade val="100000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="100000">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="99000"/>
-                  <a:satMod val="120000"/>
-                  <a:shade val="78000"/>
-                </a:schemeClr>
-              </a:gs>
-            </a:gsLst>
-            <a:lin ang="5400000" scaled="0"/>
-          </a:gradFill>
-        </a:fillStyleLst>
-        <a:lnStyleLst>
-          <a:ln w="6350" cap="flat" cmpd="sng" algn="ctr">
-            <a:solidFill>
-              <a:schemeClr val="phClr"/>
-            </a:solidFill>
-            <a:prstDash val="solid"/>
-            <a:miter lim="800000"/>
-          </a:ln>
-          <a:ln w="12700" cap="flat" cmpd="sng" algn="ctr">
-            <a:solidFill>
-              <a:schemeClr val="phClr"/>
-            </a:solidFill>
-            <a:prstDash val="solid"/>
-            <a:miter lim="800000"/>
-          </a:ln>
-          <a:ln w="19050" cap="flat" cmpd="sng" algn="ctr">
-            <a:solidFill>
-              <a:schemeClr val="phClr"/>
-            </a:solidFill>
-            <a:prstDash val="solid"/>
-            <a:miter lim="800000"/>
-          </a:ln>
-        </a:lnStyleLst>
-        <a:effectStyleLst>
-          <a:effectStyle>
-            <a:effectLst/>
-          </a:effectStyle>
-          <a:effectStyle>
-            <a:effectLst/>
-          </a:effectStyle>
-          <a:effectStyle>
-            <a:effectLst>
-              <a:outerShdw blurRad="57150" dist="19050" dir="5400000" algn="ctr" rotWithShape="0">
-                <a:srgbClr val="000000">
-                  <a:alpha val="63000"/>
-                </a:srgbClr>
-              </a:outerShdw>
-            </a:effectLst>
-          </a:effectStyle>
-        </a:effectStyleLst>
-        <a:bgFillStyleLst>
-          <a:solidFill>
-            <a:schemeClr val="phClr"/>
-          </a:solidFill>
-          <a:solidFill>
-            <a:schemeClr val="phClr">
-              <a:tint val="95000"/>
-              <a:satMod val="170000"/>
-            </a:schemeClr>
-          </a:solidFill>
-          <a:gradFill rotWithShape="1">
-            <a:gsLst>
-              <a:gs pos="0">
-                <a:schemeClr val="phClr">
-                  <a:tint val="93000"/>
-                  <a:satMod val="150000"/>
-                  <a:shade val="98000"/>
-                  <a:lumMod val="102000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="50000">
-                <a:schemeClr val="phClr">
-                  <a:tint val="98000"/>
-                  <a:satMod val="130000"/>
-                  <a:shade val="90000"/>
-                  <a:lumMod val="103000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="100000">
-                <a:schemeClr val="phClr">
-                  <a:shade val="63000"/>
-                  <a:satMod val="120000"/>
-                </a:schemeClr>
-              </a:gs>
-            </a:gsLst>
-            <a:lin ang="5400000" scaled="0"/>
-          </a:gradFill>
-        </a:bgFillStyleLst>
-      </a:fmtScheme>
-    </a:themeElements>
-  </a:theme>
-`;
-const settingsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <w:settings xmlns:w="${namespaces.w}" xmlns:o="${namespaces.o}" xmlns:r="${namespaces.r}" xmlns:v="${namespaces.v}" xmlns:w10="${namespaces.w10}" xmlns:sl="${namespaces.sl}">
-        <w:zoom w:percent="100"/>
-        <w:defaultTabStop w:val="720"/>
-        <w:decimalSymbol w:val="."/>
-        <w:listSeparator w:val=","/>
-    </w:settings>
-`;
-const webSettingsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <w:webSettings xmlns:w="${namespaces.w}" xmlns:r="${namespaces.r}">
-    </w:webSettings>
-`;
-const genericRelsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunk.mht" Id="htmlChunk" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkheader.mht" Id="htmlChunkHeader" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkfooter.mht" Id="htmlChunkFooter" />
-    </Relationships>
-`;
-const generateDocumentTemplate = (width, height, orientation, margins) => `
-  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <w:document
-        xmlns:a="${namespaces.a}"
-        xmlns:cdr="${namespaces.cdr}"
-        xmlns:o="${namespaces.o}"
-        xmlns:pic="${namespaces.pic}"
-        xmlns:r="${namespaces.r}"
-        xmlns:v="${namespaces.v}"
-        xmlns:ve="${namespaces.ve}"
-        xmlns:vt="${namespaces.vt}"
-        xmlns:w="${namespaces.w}"
-        xmlns:w10="${namespaces.w10}"
-        xmlns:wp="${namespaces.wp}"
-        xmlns:wne="${namespaces.wne}"
-        >
-        <w:body>
-        <w:altChunk r:id="htmlChunk" />
-            <w:sectPr>
-                <w:pgSz w:w="${width}" w:h="${height}" w:orient="${orientation}" />
-                <w:pgMar w:top="${margins.top}"
-                        w:right="${margins.right}"
-                        w:bottom="${margins.bottom}"
-                        w:left="${margins.left}"
-                        w:header="${margins.header}"
-                        w:footer="${margins.footer}"
-                        w:gutter="${margins.gutter}"/>
-            </w:sectPr>
-        </w:body>
-    </w:document>
-  `;
-const generateDocumentTemplateHeader = `
-<w:hdr
-xmlns:a="${namespaces.a}"
-xmlns:cdr="${namespaces.cdr}"
-xmlns:o="${namespaces.o}"
-xmlns:pic="${namespaces.pic}"
-xmlns:r="${namespaces.r}"
-xmlns:v="${namespaces.v}"
-xmlns:ve="${namespaces.ve}"
-xmlns:vt="${namespaces.vt}"
-xmlns:w="${namespaces.w}"
-xmlns:w10="${namespaces.w10}"
-xmlns:wp="${namespaces.wp}"
-xmlns:wne="${namespaces.wne}"
->
-<w:altChunk r:id="htmlChunkHeader" />
-</w:hdr>
-  `;
-const generateDocumentTemplateFooter = `
-  <w:ftr
-  xmlns:a="${namespaces.a}"
-  xmlns:cdr="${namespaces.cdr}"
-  xmlns:o="${namespaces.o}"
-  xmlns:pic="${namespaces.pic}"
-  xmlns:r="${namespaces.r}"
-  xmlns:v="${namespaces.v}"
-  xmlns:ve="${namespaces.ve}"
-  xmlns:vt="${namespaces.vt}"
-  xmlns:w="${namespaces.w}"
-  xmlns:w10="${namespaces.w10}"
-  xmlns:wp="${namespaces.wp}"
-  >
-  <w:altChunk r:id="htmlChunkFooter" />
-	<w:p w:rsidR="0014021C" w:rsidRDefault="0014021C" w:rsidP="0014021C">
-			<w:pPr>
-				<w:pStyle w:val="Footer"/>
-				<w:jc w:val="center"/>
-			</w:pPr>
-      <w:fldSimple xmlns:ns2="http://schemas.openxmlformats.org/wordprocessingml/2006/main" ns2:instr="PAGE">
-      <w:r/>
-    </w:fldSimple>
-		</w:p>
-	</w:ftr>
-  `;
-const generateDocumentTemplateFooterWithoutPaging = `
-  <w:ftr
-  xmlns:a="${namespaces.a}"
-  xmlns:cdr="${namespaces.cdr}"
-  xmlns:o="${namespaces.o}"
-  xmlns:pic="${namespaces.pic}"
-  xmlns:r="${namespaces.r}"
-  xmlns:v="${namespaces.v}"
-  xmlns:ve="${namespaces.ve}"
-  xmlns:vt="${namespaces.vt}"
-  xmlns:w="${namespaces.w}"
-  xmlns:w10="${namespaces.w10}"
-  xmlns:wp="${namespaces.wp}"
-  >
-  <w:altChunk r:id="htmlChunkFooter" />
-	</w:ftr>
-  `;
-{ /* <w:altChunk r:id="htmlChunkFooter" /> */ }
-{
-    /* <w:altChunk r:id="htmlChunkFooter" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" /> */
-}
-{
-    /* <w:ftr xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <fldSimple xmlns:ns2="http://schemas.openxmlformats.org/wordprocessingml/2006/main" ns2:instr="PAGE">
-  </fldSimple>
-  <w:altChunk r:id="htmlChunkFooter" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" />
-   </w:ftr> */
-}
-/* eslint-disable no-param-reassign */
-const rgbRegex = /rgb\((\d+),\s*([\d.]+),\s*([\d.]+)\)/i;
-const hslRegex = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/i;
-const hexRegex = /#([0-9A-F]{6})/i;
-const hex3Regex = /#([0-9A-F])([0-9A-F])([0-9A-F])/i;
-// eslint-disable-next-line import/prefer-default-export
-const rgbToHex = (red, green, blue) => {
-    const hexColorCode = [red, green, blue]
-        .map((x) => {
-        // eslint-disable-next-line radix, no-param-reassign
-        x = parseInt(x).toString(16);
-        return x.length === 1 ? `0${x}` : x;
-    })
-        .join('');
-    return hexColorCode;
-};
-const hslToHex = (hue, saturation, luminosity) => {
-    hue /= 360;
-    saturation /= 100;
-    luminosity /= 100;
-    // eslint-disable-next-line one-var
-    let red, green, blue;
-    if (saturation === 0) {
-        // eslint-disable-next-line no-multi-assign
-        red = green = blue = luminosity; // achromatic
-    }
-    else {
-        const hue2rgb = (p, q, t) => {
-            if (t < 0)
-                t += 1;
-            if (t > 1)
-                t -= 1;
-            if (t < 1 / 6)
-                return p + (q - p) * 6 * t;
-            if (t < 1 / 2)
-                return q;
-            if (t < 2 / 3)
-                return p + (q - p) * (2 / 3 - t) * 6;
-            return p;
-        };
-        const q = luminosity < 0.5
-            ? luminosity * (1 + saturation)
-            : luminosity + saturation - luminosity * saturation;
-        const p = 2 * luminosity - q;
-        red = hue2rgb(p, q, hue + 1 / 3);
-        green = hue2rgb(p, q, hue);
-        blue = hue2rgb(p, q, hue - 1 / 3);
-    }
-    return [red, green, blue]
-        .map((x) => {
-        const hex = Math.round(x * 255).toString(16);
-        return hex.length === 1 ? `0${hex}` : hex;
-    })
-        .join('');
-};
-const hex3ToHex = (red, green, blue) => {
-    const hexColorCode = [red, green, blue].map((x) => `${x}${x}`).join('');
-    return hexColorCode;
-};
-const pixelRegex = /([\d.]+)px/i;
-const percentageRegex = /([\d.]+)%/i;
-const pointRegex = /([\d.]+)pt/i;
-const cmRegex = /([\d.]+)cm/i;
-const inchRegex = /([\d.]+)in/i;
-const pixelToEMU = (pixelValue) => Math.round(pixelValue * 9525);
-const EMUToPixel = (EMUValue) => Math.round(EMUValue / 9525);
-const TWIPToEMU = (TWIPValue) => Math.round(TWIPValue * 635);
-const EMUToTWIP = (EMUValue) => Math.round(EMUValue / 635);
-const pointToTWIP = (pointValue) => Math.round(pointValue * 20);
-const TWIPToPoint = (TWIPValue) => Math.round(TWIPValue / 20);
-const pointToHIP = (pointValue) => Math.round(pointValue * 2);
-const HIPToPoint = (HIPValue) => Math.round(HIPValue / 2);
-const HIPToTWIP = (HIPValue) => Math.round(HIPValue * 10);
-const TWIPToHIP = (TWIPValue) => Math.round(TWIPValue / 10);
-const pixelToTWIP = (pixelValue) => EMUToTWIP(pixelToEMU(pixelValue));
-const TWIPToPixel = (TWIPValue) => EMUToPixel(TWIPToEMU(TWIPValue));
-const pixelToHIP = (pixelValue) => TWIPToHIP(EMUToTWIP(pixelToEMU(pixelValue)));
-const HIPToPixel = (HIPValue) => EMUToPixel(TWIPToEMU(HIPToTWIP(HIPValue)));
-const inchToPoint = (inchValue) => Math.round(inchValue * 72);
-const inchToTWIP = (inchValue) => pointToTWIP(inchToPoint(inchValue));
-const cmToInch = (cmValue) => cmValue * 0.3937008;
-const cmToTWIP = (cmValue) => inchToTWIP(cmToInch(cmValue));
-const pixelToPoint = (pixelValue) => HIPToPoint(pixelToHIP(pixelValue));
-const pointToPixel = (pointValue) => HIPToPixel(pointToHIP(pointValue));
-const EIPToPoint = (EIPValue) => Math.round(EIPValue / 8);
-const pointToEIP = (PointValue) => Math.round(PointValue * 8);
-const pixelToEIP = (pixelValue) => pointToEIP(pixelToPoint(pixelValue));
-const EIPToPixel = (EIPValue) => pointToPixel(EIPToPoint(EIPValue));
-// eslint-disable-next-line import/prefer-default-export
-const vNodeHasChildren = (vNode) => vNode && vNode.children && Array.isArray(vNode.children) && vNode.children.length;
-const isValidUrl = (urlString) => {
-    const urlRegex = /http(s)?:\/\/(\w+:?\w*@)?(\S+)(:\d+)?((?<=\.)\w+)+(\/([\w#!:.?+=&%@!\-/])*)?/gi;
-    return Boolean(urlRegex.test(urlString));
-};
-/* 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 */
-// 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 buildRunFontFragment = (fontName = defaultFont) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'rFonts')
-    .att('@w', 'ascii', fontName)
-    .att('@w', 'hAnsi', fontName)
-    .up();
-const buildRunStyleFragment = (type = 'Hyperlink') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'rStyle')
-    .att('@w', 'val', type)
-    .up();
-const buildTableRowHeight = (tableRowHeight) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'trHeight')
-    .att('@w', 'val', tableRowHeight)
-    .att('@w', 'hRule', 'atLeast')
-    .up();
-const buildVerticalAlignment = (verticalAlignment) => {
-    if (verticalAlignment.toLowerCase() === 'middle') {
-        verticalAlignment = 'center';
-    }
-    return fragment({ namespaceAlias: { w: namespaces.w } })
-        .ele('@w', 'vAlign')
-        .att('@w', 'val', verticalAlignment)
-        .up();
-};
-const buildVerticalMerge = (verticalMerge = 'continue') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'vMerge')
-    .att('@w', 'val', verticalMerge)
-    .up();
-const buildColor = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'color')
-    .att('@w', 'val', colorCode)
-    .up();
-const buildFontSize = (fontSize) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'sz')
-    .att('@w', 'val', fontSize)
-    .up();
-const buildShading = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'shd')
-    .att('@w', 'val', 'clear')
-    .att('@w', 'fill', colorCode)
-    .up();
-const buildHighlight = (color = 'yellow') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'highlight')
-    .att('@w', 'val', color)
-    .up();
-const buildVertAlign = (type = 'baseline') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'vertAlign')
-    .att('@w', 'val', type)
-    .up();
-const buildStrike = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'strike')
-    .att('@w', 'val', true)
-    .up();
-const buildBold = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'b')
-    .up();
-const buildItalics = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'i')
-    .up();
-const buildUnderline = (type = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'u')
-    .att('@w', 'val', type)
-    .up();
-const buildLineBreak = (type = 'textWrapping') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'br')
-    .att('@w', 'type', type)
-    .up();
-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 buildTextElement = (text) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 't')
-    .att('@xml', 'space', 'preserve')
-    .txt(text)
-    .up();
-// 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;
-    }
-};
-// eslint-disable-next-line consistent-return
-const fixupFontSize$1 = (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]);
-    }
-};
-// 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]);
-    }
-};
-// 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]);
-    }
-};
-// 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 modifiedStyleAttributesBuilder = (vNode, attributes, options) => {
-    const modifiedAttributes = { ...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$1(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$1(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;
-};
-// 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 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 buildRun = async (vNode, attributes, docxDocumentInstance) => {
-    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({ ...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 = await buildRunOrRuns(tempVNode, { ...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 = { ...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, ...otherAttributes } = attributes;
-        // 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 buildRunOrRuns = async (vNode, attributes, docxDocumentInstance) => {
-    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 = await buildRun(childVNode, modifiedAttributes, docxDocumentInstance);
-            runFragments = runFragments.concat(Array.isArray(tempRunFragments) ? tempRunFragments : [tempRunFragments]);
-        }
-        return runFragments;
-    }
-    else {
-        const tempRunFragments = await buildRun(vNode, attributes, docxDocumentInstance);
-        return tempRunFragments;
-    }
-};
-const buildRunOrHyperLink = async (vNode, attributes, docxDocumentInstance) => {
-    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 = { ...attributes };
-        modifiedAttributes.hyperlink = true;
-        const runFragments = await 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 = await buildRunOrRuns(vNode, attributes, docxDocumentInstance);
-    return runFragments;
-};
-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 buildNumberingInstances = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'num')
-    .ele('@w', 'abstractNumId')
-    .up()
-    .up();
-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 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 buildPStyle = (style = 'Normal') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'pStyle')
-    .att('@w', 'val', style)
-    .up();
-const buildHorizontalAlignment = (horizontalAlignment) => {
-    if (horizontalAlignment === 'justify') {
-        horizontalAlignment = 'both';
-    }
-    return fragment({ namespaceAlias: { w: namespaces.w } })
-        .ele('@w', 'jc')
-        .att('@w', 'val', horizontalAlignment)
-        .up();
-};
-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 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 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 buildParagraph = async (vNode, attributes, docxDocumentInstance) => {
-    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 = await 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 = await 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 = await 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 = await buildRunOrHyperLink(childVNode, isVNode(childVNode) && childVNode.tagName === 'img'
-                    ? { ...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 = await 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 = await 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 buildGridSpanFragment = (spanValue) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'gridSpan')
-    .att('@w', 'val', spanValue)
-    .up();
-const buildTableCellSpacing = (cellSpacing = 0) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'tblCellSpacing')
-    .att('@w', 'w', cellSpacing)
-    .att('@w', 'type', 'dxa')
-    .up();
-const buildTableCellBorders = (tableCellBorder) => {
-    const tableCellBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcBorders');
-    const { color, stroke, ...borders } = tableCellBorder;
-    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 buildTableCellWidth = (tableCellWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'tcW')
-    .att('@w', 'w', fixupColumnWidth(tableCellWidth))
-    .att('@w', 'type', 'dxa')
-    .up();
-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 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 = {
-            ...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 = {
-            ...attributes.tableCellBorder,
-            top: borderSize,
-            color: borderColor,
-            stroke: borderStroke,
-        };
-    }
-    if (vNode.properties.style['border-left'] && vNode.properties.style['border-left'] === '0') {
-        attributes.tableCellBorder = {
-            ...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 = {
-            ...attributes.tableCellBorder,
-            left: borderSize,
-            color: borderColor,
-            stroke: borderStroke,
-        };
-    }
-    if (vNode.properties.style['border-bottom'] && vNode.properties.style['border-bottom'] === '0') {
-        attributes.tableCellBorder = {
-            ...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 = {
-            ...attributes.tableCellBorder,
-            bottom: borderSize,
-            color: borderColor,
-            stroke: borderStroke,
-        };
-    }
-    if (vNode.properties.style['border-right'] && vNode.properties.style['border-right'] === '0') {
-        attributes.tableCellBorder = {
-            ...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 = {
-            ...attributes.tableCellBorder,
-            right: borderSize,
-            color: borderColor,
-            stroke: borderStroke,
-        };
-    }
-};
-const buildTableCell = async (vNode, attributes, rowSpanMap, columnIndex, docxDocumentInstance) => {
-    const tableCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
-    let modifiedAttributes = { ...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 = {
-                ...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 = await 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 = await 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)) {
-                    await buildList(childVNode, docxDocumentInstance, tableCellFragment);
-                }
-            }
-            else {
-                const paragraphFragment = await 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 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({
-            ...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 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 buildTableRow = async (vNode, attributes, rowSpanMap, docxDocumentInstance) => {
-    const tableRowFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tr');
-    const modifiedAttributes = { ...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 = await buildTableCell(column, { ...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 buildTableGridCol = (gridWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'gridCol')
-    .att('@w', 'w', String(gridWidth));
-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 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 buildTableBorders = (tableBorder) => {
-    const tableBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblBorders');
-    const { color, stroke, ...borders } = tableBorder;
-    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 buildTableWidth = (tableWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'tblW')
-    .att('@w', 'type', 'dxa')
-    .att('@w', 'w', String(tableWidth))
-    .up();
-const buildCellMargin = (side, margin) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', side)
-    .att('@w', 'type', 'dxa')
-    .att('@w', 'w', String(margin))
-    .up();
-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 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 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 buildTable = async (vNode, attributes, docxDocumentInstance) => {
-    const tableFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tbl');
-    const modifiedAttributes = { ...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 = await 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 = await 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 = await buildTableRow(childVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
-                tableFragment.import(tableRowFragment);
-            }
-        }
-    }
-    tableFragment.up();
-    return tableFragment;
-};
-const buildPresetGeometry = () => fragment({ namespaceAlias: { a: namespaces.a } })
-    .ele('@a', 'prstGeom')
-    .att('prst', 'rect')
-    .up();
-const buildExtents = ({ width, height }) => fragment({ namespaceAlias: { a: namespaces.a } })
-    .ele('@a', 'ext')
-    .att('cx', width)
-    .att('cy', height)
-    .up();
-const buildOffset = () => fragment({ namespaceAlias: { a: namespaces.a } })
-    .ele('@a', 'off')
-    .att('x', '0')
-    .att('y', '0')
-    .up();
-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 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 buildFillRect = () => fragment({ namespaceAlias: { a: namespaces.a } })
-    .ele('@a', 'fillRect')
-    .up();
-const buildStretch = () => {
-    const stretchFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'stretch');
-    const fillRectFragment = buildFillRect();
-    stretchFragment.import(fillRectFragment);
-    stretchFragment.up();
-    return stretchFragment;
-};
-const buildSrcRectFragment = () => fragment({ namespaceAlias: { a: namespaces.a } })
-    .ele('@a', 'srcRect')
-    .att('b', '0')
-    .att('l', '0')
-    .att('r', '0')
-    .att('t', '0')
-    .up();
-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 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 buildNonVisualPictureDrawingProperties = () => fragment({ namespaceAlias: { pic: namespaces.pic } })
-    .ele('@pic', 'cNvPicPr')
-    .up();
-const buildNonVisualDrawingProperties = (pictureId, pictureNameWithExtension, pictureDescription = '') => fragment({ namespaceAlias: { pic: namespaces.pic } })
-    .ele('@pic', 'cNvPr')
-    .att('id', pictureId)
-    .att('name', pictureNameWithExtension)
-    .att('descr', pictureDescription)
-    .up();
-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 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 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 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 buildDrawingObjectNonVisualProperties = (pictureId, pictureName) => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'docPr')
-    .att('id', pictureId)
-    .att('name', pictureName)
-    .up();
-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();
-// eslint-disable-next-line no-unused-vars
-const buildWrapNone = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'wrapNone')
-    .up();
-const buildEffectExtentFragment = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'effectExtent')
-    .att('b', '0')
-    .att('l', '0')
-    .att('r', '0')
-    .att('t', '0')
-    .up();
-const buildExtent = ({ width, height }) => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'extent')
-    .att('cx', width)
-    .att('cy', height)
-    .up();
-const buildPositionV = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'positionV')
-    .att('relativeFrom', 'paragraph')
-    .ele('@wp', 'posOffset')
-    .txt('19050')
-    .up()
-    .up();
-const buildPositionH = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'positionH')
-    .att('relativeFrom', 'column')
-    .ele('@wp', 'posOffset')
-    .txt('19050')
-    .up()
-    .up();
-const buildSimplePos = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
-    .ele('@wp', 'simplePos')
-    .att('x', '0')
-    .att('y', '0')
-    .up();
-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 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 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;
-};
-// eslint-disable-next-line consistent-return, no-shadow
-const buildImage = async (docxDocumentInstance, vNode, maximumWidth = null) => {
-    let response = null;
-    let base64Uri = null;
-    try {
-        const imageSource = vNode.properties.src;
-        if (isValidUrl(imageSource)) {
-            const base64String = await imageToBase64(imageSource).catch((error) => {
-                // eslint-disable-next-line no-console
-                console.warning(`skipping image download and conversion due to ${error}`);
-            });
-            if (base64String) {
-                base64Uri = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
-            }
-        }
-        else {
-            base64Uri = decodeURIComponent(vNode.properties.src);
-        }
-        if (base64Uri) {
-            response = docxDocumentInstance.createMediaFile(base64Uri);
-        }
-    }
-    catch (error) {
-        // NOOP
-    }
-    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);
-        const imageBuffer = Buffer.from(response.fileContent, 'base64');
-        const imageProperties = sizeOf(imageBuffer);
-        const imageFragment = await xmlBuilder.buildParagraph(vNode, {
-            type: 'picture',
-            inlineOrAnchored: true,
-            relationshipId: documentRelsId,
-            ...response,
-            maximumWidth: maximumWidth || docxDocumentInstance.availableDocumentSpace,
-            originalWidth: imageProperties.width,
-            originalHeight: imageProperties.height,
-        }, docxDocumentInstance);
-        return imageFragment;
-    }
-};
-const buildList = async (vNode, docxDocumentInstance, xmlFragment) => {
-    const listElements = [];
-    let vNodeObjects = [
-        {
-            node: vNode,
-            level: 0,
-            type: vNode.tagName,
-            numberingId: docxDocumentInstance.createNumbering(vNode.tagName, vNode.properties),
-        },
-    ];
-    while (vNodeObjects.length) {
-        const tempVNodeObject = vNodeObjects.shift();
-        if (isVText(tempVNodeObject.node) ||
-            (isVNode(tempVNodeObject.node) && !['ul', 'ol', 'li'].includes(tempVNodeObject.node.tagName))) {
-            const paragraphFragment = await xmlBuilder.buildParagraph(tempVNodeObject.node, {
-                numbering: { levelId: tempVNodeObject.level, numberingId: tempVNodeObject.numberingId },
-            }, docxDocumentInstance);
-            xmlFragment.import(paragraphFragment);
-        }
-        if (tempVNodeObject.node.children &&
-            tempVNodeObject.node.children.length &&
-            ['ul', 'ol', 'li'].includes(tempVNodeObject.node.tagName)) {
-            const tempVNodeObjects = tempVNodeObject.node.children.reduce((accumulator, childVNode) => {
-                if (['ul', 'ol'].includes(childVNode.tagName)) {
-                    accumulator.push({
-                        node: childVNode,
-                        level: tempVNodeObject.level + 1,
-                        type: childVNode.tagName,
-                        numberingId: docxDocumentInstance.createNumbering(childVNode.tagName, childVNode.properties),
-                    });
-                }
-                else {
-                    // eslint-disable-next-line no-lonely-if
-                    if (accumulator.length > 0 &&
-                        isVNode(accumulator[accumulator.length - 1].node) &&
-                        accumulator[accumulator.length - 1].node.tagName.toLowerCase() === 'p') {
-                        accumulator[accumulator.length - 1].node.children.push(childVNode);
-                    }
-                    else {
-                        const paragraphVNode = new VNode('p', null,
-                        // eslint-disable-next-line no-nested-ternary
-                        isVText(childVNode)
-                            ? [childVNode]
-                            : // eslint-disable-next-line no-nested-ternary
-                                isVNode(childVNode)
-                                    ? childVNode.tagName.toLowerCase() === 'li'
-                                        ? [...childVNode.children]
-                                        : [childVNode]
-                                    : []);
-                        accumulator.push({
-                            // eslint-disable-next-line prettier/prettier, no-nested-ternary
-                            node: isVNode(childVNode)
-                                ? // eslint-disable-next-line prettier/prettier, no-nested-ternary
-                                    childVNode.tagName.toLowerCase() === 'li'
-                                        ? childVNode
-                                        : childVNode.tagName.toLowerCase() !== 'p'
-                                            ? paragraphVNode
-                                            : childVNode
-                                : // eslint-disable-next-line prettier/prettier
-                                    paragraphVNode,
-                            level: tempVNodeObject.level,
-                            type: tempVNodeObject.type,
-                            numberingId: tempVNodeObject.numberingId,
-                        });
-                    }
-                }
-                return accumulator;
-            }, []);
-            vNodeObjects = tempVNodeObjects.concat(vNodeObjects);
-        }
-    }
-    return listElements;
-};
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-case-declarations */
-const convertHTML$1 = HTMLToVDOM({
-    VNode: VNode$1,
-    VText,
-});
-async function findXMLEquivalent(docxDocumentInstance, vNode, xmlFragment) {
-    if (vNode.tagName === 'div' &&
-        (vNode.properties.attributes.class === 'page-break' ||
-            (vNode.properties.style && vNode.properties.style['page-break-after']))) {
-        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
-            .ele('@w', 'p')
-            .ele('@w', 'r')
-            .ele('@w', 'br')
-            .att('@w', 'type', 'page')
-            .up()
-            .up()
-            .up();
-        xmlFragment.import(paragraphFragment);
-        return;
-    }
-    switch (vNode.tagName) {
-        case 'h1':
-        case 'h2':
-        case 'h3':
-        case 'h4':
-        case 'h5':
-        case 'h6':
-            const headingFragment = await buildParagraph(vNode, {
-                paragraphStyle: `Heading${vNode.tagName[1]}`,
-            }, docxDocumentInstance);
-            xmlFragment.import(headingFragment);
-            return;
-        case 'span':
-        case 'strong':
-        case 'b':
-        case 'em':
-        case 'i':
-        case 'u':
-        case 'ins':
-        case 'strike':
-        case 'del':
-        case 's':
-        case 'sub':
-        case 'sup':
-        case 'mark':
-        case 'p':
-        case 'a':
-        case 'blockquote':
-        case 'code':
-        case 'pre':
-            const paragraphFragment = await buildParagraph(vNode, {}, docxDocumentInstance);
-            xmlFragment.import(paragraphFragment);
-            return;
-        case 'figure':
-            if (vNodeHasChildren(vNode)) {
-                // eslint-disable-next-line no-plusplus
-                for (let index = 0; index < vNode.children.length; index++) {
-                    const childVNode = vNode.children[index];
-                    if (childVNode.tagName === 'table') {
-                        const tableFragment = await buildTable(childVNode, {
-                            maximumWidth: docxDocumentInstance.availableDocumentSpace,
-                            rowCantSplit: docxDocumentInstance.tableRowCantSplit,
-                        }, docxDocumentInstance);
-                        xmlFragment.import(tableFragment);
-                        // Adding empty paragraph for space after table
-                        const emptyParagraphFragment = await buildParagraph(null, {});
-                        xmlFragment.import(emptyParagraphFragment);
-                    }
-                    else if (childVNode.tagName === 'img') {
-                        const imageFragment = await buildImage(docxDocumentInstance, childVNode);
-                        if (imageFragment) {
-                            xmlFragment.import(imageFragment);
-                        }
-                    }
-                }
-            }
-            return;
-        case 'table':
-            const tableFragment = await buildTable(vNode, {
-                maximumWidth: docxDocumentInstance.availableDocumentSpace,
-                rowCantSplit: docxDocumentInstance.tableRowCantSplit,
-            }, docxDocumentInstance);
-            xmlFragment.import(tableFragment);
-            // Adding empty paragraph for space after table
-            const emptyParagraphFragment = await buildParagraph(null, {});
-            xmlFragment.import(emptyParagraphFragment);
-            return;
-        case 'ol':
-        case 'ul':
-            await buildList(vNode, docxDocumentInstance, xmlFragment);
-            return;
-        case 'img':
-            const imageFragment = await buildImage(docxDocumentInstance, vNode);
-            if (imageFragment) {
-                xmlFragment.import(imageFragment);
-            }
-            return;
-        case 'br':
-            const linebreakFragment = await buildParagraph(null, {});
-            xmlFragment.import(linebreakFragment);
-            return;
-    }
-    if (vNodeHasChildren(vNode)) {
-        // eslint-disable-next-line no-plusplus
-        for (let index = 0; index < vNode.children.length; index++) {
-            const childVNode = vNode.children[index];
-            // eslint-disable-next-line no-use-before-define
-            await convertVTreeToXML(docxDocumentInstance, childVNode, xmlFragment);
-        }
-    }
-}
-// eslint-disable-next-line consistent-return
-async function convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment) {
-    if (!vTree) {
-        // eslint-disable-next-line no-useless-return
-        return '';
-    }
-    if (Array.isArray(vTree) && vTree.length) {
-        // eslint-disable-next-line no-plusplus
-        for (let index = 0; index < vTree.length; index++) {
-            const vNode = vTree[index];
-            await convertVTreeToXML(docxDocumentInstance, vNode, xmlFragment);
-        }
-    }
-    else if (isVNode(vTree)) {
-        await findXMLEquivalent(docxDocumentInstance, vTree, xmlFragment);
-    }
-    else if (isVText(vTree)) {
-        buildTextElement(xmlFragment, escape(String(vTree.text)));
-    }
-    return xmlFragment;
-}
-async function renderDocumentFile(docxDocumentInstance) {
-    const vTree = convertHTML$1(docxDocumentInstance.htmlString);
-    const xmlFragment = fragment({ namespaceAlias: { w: namespaces.w } });
-    const populatedXmlFragment = await convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment);
-    return populatedXmlFragment;
-}
-/* eslint-disable import/prefer-default-export */
-class ListStyleBuilder {
-    // defaults is an object passed in from constants.js / numbering with the following properties:
-    // defaultOrderedListStyleType: 'decimal' (unless otherwise specified)
-    constructor(defaults) {
-        this.defaults = defaults || { defaultOrderedListStyleType: 'decimal' };
-    }
-    // eslint-disable-next-line class-methods-use-this
-    getListStyleType(listType) {
-        switch (listType) {
-            case 'upper-roman':
-                return 'upperRoman';
-            case 'lower-roman':
-                return 'lowerRoman';
-            case 'upper-alpha':
-            case 'upper-alpha-bracket-end':
-                return 'upperLetter';
-            case 'lower-alpha':
-            case 'lower-alpha-bracket-end':
-                return 'lowerLetter';
-            case 'decimal':
-            case 'decimal-bracket':
-                return 'decimal';
-            default:
-                return this.defaults.defaultOrderedListStyleType;
-        }
-    }
-    getListPrefixSuffix(style, lvl) {
-        let listType = this.defaults.defaultOrderedListStyleType;
-        if (style && style['list-style-type']) {
-            listType = style['list-style-type'];
-        }
-        switch (listType) {
-            case 'upper-roman':
-            case 'lower-roman':
-            case 'upper-alpha':
-            case 'lower-alpha':
-                return `%${lvl + 1}.`;
-            case 'upper-alpha-bracket-end':
-            case 'lower-alpha-bracket-end':
-            case 'decimal-bracket-end':
-                return `%${lvl + 1})`;
-            case 'decimal-bracket':
-                return `(%${lvl + 1})`;
-            case 'decimal':
-            default:
-                return `%${lvl + 1}.`;
-        }
-    }
-}
-function generateContentTypesFragments(contentTypesXML, type, objects) {
-    if (objects && Array.isArray(objects)) {
-        objects.forEach((object) => {
-            const contentTypesFragment = fragment({ defaultNamespace: { ele: namespaces.contentTypes } })
-                .ele('Override')
-                .att('PartName', `/word/${type}${object[`${type}Id`]}.xml`)
-                .att('ContentType', `application/vnd.openxmlformats-officedocument.wordprocessingml.${type}+xml`)
-                .up();
-            contentTypesXML.root().import(contentTypesFragment);
-        });
-    }
-}
-function generateSectionReferenceXML(documentXML, documentSectionType, objects, isEnabled) {
-    if (isEnabled && objects && Array.isArray(objects) && objects.length) {
-        const xmlFragment = fragment();
-        objects.forEach(({ relationshipId, type }) => {
-            const objectFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })
-                .ele('@w', `${documentSectionType}Reference`)
-                .att('@r', 'id', `rId${relationshipId}`)
-                .att('@w', 'type', type)
-                .up();
-            xmlFragment.import(objectFragment);
-        });
-        documentXML.root().first().first().import(xmlFragment);
-    }
-}
-function generateXMLString(xmlString) {
-    const xmlDocumentString = create({ encoding: 'UTF-8', standalone: true }, xmlString);
-    return xmlDocumentString.toString({ prettyPrint: true });
-}
-async function generateSectionXML(vTree, type = 'header') {
-    debugger;
-    const sectionXML = create({
-        encoding: 'UTF-8',
-        standalone: true,
-        namespaceAlias: {
-            a: namespaces.a,
-            cdr: namespaces.cdr,
-            o: namespaces.o,
-            pic: namespaces.pic,
-            r: namespaces.r,
-            v: namespaces.v,
-            ve: namespaces.ve,
-            vt: namespaces.vt,
-            w: namespaces.w,
-            w10: namespaces.w10,
-            wp: namespaces.wp,
-            wne: namespaces.wne
-        },
-    }).ele('@w', type === 'header' ? 'hdr' : 'ftr');
-    const XMLFragment = fragment();
-    await convertVTreeToXML(this, vTree, XMLFragment);
-    if (type === 'footer' && XMLFragment.first().node.tagName === 'p' && this.pageNumber) {
-        XMLFragment.first().import(fragment({ namespaceAlias: { w: namespaces.w } })
-            .ele('@w', 'fldSimple')
-            .att('@w', 'instr', 'PAGE')
-            .ele('@w', 'r')
-            .up()
-            .up());
-    }
-    sectionXML.root().import(XMLFragment);
-    const referenceName = type === 'header' ? 'Header' : 'Footer';
-    this[`last${referenceName}Id`] += 1;
-    return { [`${type}Id`]: this[`last${referenceName}Id`], [`${type}XML`]: sectionXML };
-}
-class DocxDocument {
-    constructor(properties) {
-        this.zip = properties.zip;
-        this.htmlString = properties.htmlString;
-        this.orientation = properties.orientation;
-        this.pageSize = properties.pageSize || defaultDocumentOptions.pageSize;
-        const isPortraitOrientation = this.orientation === defaultOrientation;
-        const height = this.pageSize.height ? this.pageSize.height : landscapeHeight;
-        const width = this.pageSize.width ? this.pageSize.width : landscapeWidth;
-        this.width = isPortraitOrientation ? width : height;
-        this.height = isPortraitOrientation ? height : width;
-        const marginsObject = properties.margins;
-        this.margins =
-            // eslint-disable-next-line no-nested-ternary
-            marginsObject && Object.keys(marginsObject).length
-                ? marginsObject
-                : isPortraitOrientation
-                    ? portraitMargins
-                    : landscapeMargins;
-        this.availableDocumentSpace = this.width - this.margins.left - this.margins.right;
-        this.title = properties.title || '';
-        this.subject = properties.subject || '';
-        this.creator = properties.creator || applicationName;
-        this.keywords = properties.keywords || [applicationName];
-        this.description = properties.description || '';
-        this.lastModifiedBy = properties.lastModifiedBy || applicationName;
-        this.revision = properties.revision || 1;
-        this.createdAt = properties.createdAt || new Date();
-        this.modifiedAt = properties.modifiedAt || new Date();
-        this.headerType = properties.headerType || 'default';
-        this.header = properties.header || false;
-        this.footerType = properties.footerType || 'default';
-        this.footer = properties.footer || false;
-        this.font = properties.font || defaultFont;
-        this.fontSize = properties.fontSize || defaultFontSize;
-        this.complexScriptFontSize = properties.complexScriptFontSize || defaultFontSize;
-        this.tableRowCantSplit =
-            (properties.table && properties.table.row && properties.table.row.cantSplit) || false;
-        this.pageNumber = properties.pageNumber || false;
-        this.skipFirstHeaderFooter = properties.skipFirstHeaderFooter || false;
-        this.lineNumber = properties.lineNumber ? properties.lineNumberOptions : null;
-        this.lastNumberingId = 0;
-        this.lastMediaId = 0;
-        this.lastHeaderId = 0;
-        this.lastFooterId = 0;
-        this.stylesObjects = [];
-        this.numberingObjects = [];
-        this.relationshipFilename = documentFileName;
-        this.relationships = [{ fileName: documentFileName, lastRelsId: 4, rels: [] }];
-        this.mediaFiles = [];
-        this.headerObjects = [];
-        this.footerObjects = [];
-        this.documentXML = null;
-        this.generateContentTypesXML = this.generateContentTypesXML.bind(this);
-        this.generateDocumentXML = this.generateDocumentXML.bind(this);
-        this.generateCoreXML = this.generateCoreXML.bind(this);
-        this.generateSettingsXML = this.generateSettingsXML.bind(this);
-        this.generateWebSettingsXML = this.generateWebSettingsXML.bind(this);
-        this.generateStylesXML = this.generateStylesXML.bind(this);
-        this.generateFontTableXML = this.generateFontTableXML.bind(this);
-        this.generateThemeXML = this.generateThemeXML.bind(this);
-        this.generateNumberingXML = this.generateNumberingXML.bind(this);
-        this.generateRelsXML = this.generateRelsXML.bind(this);
-        this.createMediaFile = this.createMediaFile.bind(this);
-        this.createDocumentRelationships = this.createDocumentRelationships.bind(this);
-        this.generateHeaderXML = this.generateHeaderXML.bind(this);
-        this.generateFooterXML = this.generateFooterXML.bind(this);
-        this.generateSectionXML = generateSectionXML.bind(this);
-        this.ListStyleBuilder = new ListStyleBuilder(properties.numbering);
-    }
-    generateContentTypesXML() {
-        const contentTypesXML$1 = create({ encoding: 'UTF-8', standalone: true }, contentTypesXML);
-        generateContentTypesFragments(contentTypesXML$1, 'header', this.headerObjects);
-        generateContentTypesFragments(contentTypesXML$1, 'footer', this.footerObjects);
-        return contentTypesXML$1.toString({ prettyPrint: true });
-    }
-    generateDocumentXML() {
-        const documentXML = create({ encoding: 'UTF-8', standalone: true }, generateDocumentTemplate(this.width, this.height, this.orientation, this.margins));
-        // documentXML.root().first().import(this.documentXML);
-        generateSectionReferenceXML(documentXML, 'header', this.headerObjects, this.header);
-        generateSectionReferenceXML(documentXML, 'footer', this.footerObjects, this.footer);
-        if ((this.header || this.footer) && this.skipFirstHeaderFooter) {
-            documentXML
-                .root()
-                .first()
-                .first()
-                .import(fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'titlePg'));
-        }
-        if (this.lineNumber) {
-            const { countBy, start, restart } = this.lineNumber;
-            documentXML
-                .root()
-                .first()
-                .first()
-                .import(fragment({ namespaceAlias: { w: namespaces.w } })
-                .ele('@w', 'lnNumType')
-                .att('@w', 'countBy', countBy)
-                .att('@w', 'start', start)
-                .att('@w', 'restart', restart));
-        }
-        return documentXML.toString({ prettyPrint: true });
-    }
-    generateCoreXML() {
-        return generateXMLString(generateCoreXML(this.title, this.subject, this.creator, this.keywords, this.description, this.lastModifiedBy, this.revision, this.createdAt, this.modifiedAt));
-    }
-    // eslint-disable-next-line class-methods-use-this
-    generateSettingsXML() {
-        return generateXMLString(settingsXML);
-    }
-    // eslint-disable-next-line class-methods-use-this
-    generateWebSettingsXML() {
-        return generateXMLString(webSettingsXML);
-    }
-    generateStylesXML() {
-        return generateXMLString(generateStylesXML(this.font, this.fontSize, this.complexScriptFontSize));
-    }
-    // eslint-disable-next-line class-methods-use-this
-    generateFontTableXML() {
-        return generateXMLString(fontTableXML);
-    }
-    generateThemeXML() {
-        return generateXMLString(generateThemeXML(this.font));
-    }
-    generateNumberingXML() {
-        const numberingXML = create({ encoding: 'UTF-8', standalone: true }, generateNumberingXMLTemplate());
-        const abstractNumberingFragments = fragment();
-        const numberingFragments = fragment();
-        this.numberingObjects.forEach(({ numberingId, type, properties }) => {
-            const abstractNumberingFragment = fragment({ namespaceAlias: { w: namespaces.w } })
-                .ele('@w', 'abstractNum')
-                .att('@w', 'abstractNumId', String(numberingId));
-            [...Array(8).keys()].forEach((level) => {
-                const levelFragment = fragment({ namespaceAlias: { w: namespaces.w } })
-                    .ele('@w', 'lvl')
-                    .att('@w', 'ilvl', level)
-                    .ele('@w', 'start')
-                    .att('@w', 'val', type === 'ol'
-                    ? (properties.attributes && properties.attributes['data-start']) || 1
-                    : '1')
-                    .up()
-                    .ele('@w', 'numFmt')
-                    .att('@w', 'val', type === 'ol'
-                    ? this.ListStyleBuilder.getListStyleType(properties.style && properties.style['list-style-type'])
-                    : 'bullet')
-                    .up()
-                    .ele('@w', 'lvlText')
-                    .att('@w', 'val', type === 'ol' ? this.ListStyleBuilder.getListPrefixSuffix(properties.style, level) : '')
-                    .up()
-                    .ele('@w', 'lvlJc')
-                    .att('@w', 'val', 'left')
-                    .up()
-                    .ele('@w', 'pPr')
-                    .ele('@w', 'tabs')
-                    .ele('@w', 'tab')
-                    .att('@w', 'val', 'num')
-                    .att('@w', 'pos', (level + 1) * 720)
-                    .up()
-                    .up()
-                    .ele('@w', 'ind')
-                    .att('@w', 'left', (level + 1) * 720)
-                    .att('@w', 'hanging', 360)
-                    .up()
-                    .up()
-                    .up();
-                if (type === 'ul') {
-                    levelFragment.last().import(fragment({ namespaceAlias: { w: namespaces.w } })
-                        .ele('@w', 'rPr')
-                        .ele('@w', 'rFonts')
-                        .att('@w', 'ascii', 'Symbol')
-                        .att('@w', 'hAnsi', 'Symbol')
-                        .att('@w', 'hint', 'default')
-                        .up()
-                        .up());
-                }
-                abstractNumberingFragment.import(levelFragment);
-            });
-            abstractNumberingFragment.up();
-            abstractNumberingFragments.import(abstractNumberingFragment);
-            numberingFragments.import(fragment({ namespaceAlias: { w: namespaces.w } })
-                .ele('@w', 'num')
-                .att('@w', 'numId', String(numberingId))
-                .ele('@w', 'abstractNumId')
-                .att('@w', 'val', String(numberingId))
-                .up()
-                .up());
-        });
-        numberingXML.root().import(abstractNumberingFragments);
-        numberingXML.root().import(numberingFragments);
-        return numberingXML.toString({ prettyPrint: true });
-    }
-    // eslint-disable-next-line class-methods-use-this
-    appendRelationships(xmlFragment, relationships) {
-        relationships.forEach(({ relationshipId, type, target, targetMode }) => {
-            xmlFragment.import(fragment({ defaultNamespace: { ele: namespaces.relationship } })
-                .ele('Relationship')
-                .att('Id', `rId${relationshipId}`)
-                .att('Type', type)
-                .att('Target', target)
-                .att('TargetMode', targetMode)
-                .up());
-        });
-    }
-    generateRelsXML() {
-        const relationshipXMLStrings = this.relationships.map(({ fileName, rels }) => {
-            const xmlFragment = create({ encoding: 'UTF-8', standalone: true }, fileName === documentFileName ? documentRelsXML : genericRelsXML);
-            this.appendRelationships(xmlFragment.root(), rels);
-            return { fileName, xmlString: xmlFragment.toString({ prettyPrint: true }) };
-        });
-        return relationshipXMLStrings;
-    }
-    createNumbering(type, properties) {
-        this.lastNumberingId += 1;
-        this.numberingObjects.push({ numberingId: this.lastNumberingId, type, properties });
-        return this.lastNumberingId;
-    }
-    createMediaFile(base64String) {
-        // eslint-disable-next-line no-useless-escape
-        const matches = base64String.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/);
-        if (matches.length !== 3) {
-            throw new Error('Invalid base64 string');
-        }
-        const base64FileContent = matches[2];
-        // matches array contains file type in base64 format - image/jpeg and base64 stringified data
-        const fileExtension = matches[1].match(/\/(.*?)$/)[1] === 'octet-stream' ? 'png' : matches[1].match(/\/(.*?)$/)[1];
-        const fileNameWithExtension = `image-${nanoid()}.${fileExtension}`;
-        this.lastMediaId += 1;
-        return { id: this.lastMediaId, fileContent: base64FileContent, fileNameWithExtension };
-    }
-    createDocumentRelationships(fileName = 'document', type, target, targetMode = 'External') {
-        debugger;
-        let relationshipObject = this.relationships.find((relationship) => relationship.fileName === fileName);
-        let lastRelsId = 1;
-        if (relationshipObject) {
-            lastRelsId = relationshipObject.lastRelsId + 1;
-            relationshipObject.lastRelsId = lastRelsId;
-        }
-        else {
-            relationshipObject = { fileName, lastRelsId, rels: [] };
-            this.relationships.push(relationshipObject);
-        }
-        let relationshipType;
-        switch (type) {
-            case hyperlinkType:
-                relationshipType = namespaces.hyperlinks;
-                break;
-            case imageType:
-                relationshipType = namespaces.images;
-                break;
-            case headerType:
-                relationshipType = namespaces.headers;
-                break;
-            case footerType:
-                relationshipType = namespaces.footers;
-                break;
-            case themeType:
-                relationshipType = namespaces.themes;
-                break;
-        }
-        relationshipObject.rels.push({
-            relationshipId: lastRelsId,
-            type: relationshipType,
-            target,
-            targetMode,
-        });
-        console.log(fileName);
-        console.log(relationshipObject.rels);
-        return lastRelsId;
-    }
-    generateHeaderXML(vTree) {
-        return this.generateSectionXML(vTree, 'header');
-    }
-    generateFooterXML(vTree) {
-        return this.generateSectionXML(vTree, 'footer');
-    }
-}
-const defaultMargins = {
-    top: 1440,
-    right: 1440,
-    bottom: 1440,
-    left: 1440,
-    header: 720,
-    footer: 720,
-    gutter: 0,
-};
-const documentTemplate = (width, height, orient, margins) => {
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:document
-  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
-  xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
-  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
-  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
-  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
-  xmlns:ns6="http://schemas.openxmlformats.org/schemaLibrary/2006/main"
-  xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"
-  xmlns:ns8="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing"
-  xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"
-  xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"
-  xmlns:ns11="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
-  xmlns:dsp="http://schemas.microsoft.com/office/drawing/2008/diagram"
-  xmlns:ns13="urn:schemas-microsoft-com:office:excel"
-  xmlns:o="urn:schemas-microsoft-com:office:office"
-  xmlns:v="urn:schemas-microsoft-com:vml"
-  xmlns:w10="urn:schemas-microsoft-com:office:word"
-  xmlns:ns17="urn:schemas-microsoft-com:office:powerpoint"
-  xmlns:odx="http://opendope.org/xpaths"
-  xmlns:odc="http://opendope.org/conditions"
-  xmlns:odq="http://opendope.org/questions"
-  xmlns:odi="http://opendope.org/components"
-  xmlns:odgm="http://opendope.org/SmartArt/DataHierarchy"
-  xmlns:ns24="http://schemas.openxmlformats.org/officeDocument/2006/bibliography"
-  xmlns:ns25="http://schemas.openxmlformats.org/drawingml/2006/compatibility"
-  xmlns:ns26="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas">
-  <w:body>
-    <w:altChunk r:id="htmlChunk" />
-    <w:sectPr>
-      <w:pgSz w:w="${width}" w:h="${height}" w:orient="${orient}" />
-      <w:pgMar w:top="${margins.top}"
-               w:right="${margins.right}"
-               w:bottom="${margins.bottom}"
-               w:left="${margins.left}"
-               w:header="${margins.header}"
-               w:footer="${margins.footer}"
-               w:gutter="${margins.gutter}"/>
-    </w:sectPr>
-  </w:body>
-</w:document>
-`;
-};
-const mhtDocumentTemplate = (htmlSource, contentParts) => {
-    debugger;
-    return `MIME-Version: 1.0
-Content-Type: multipart/related;
-    type="text/html";
-    boundary="----=mhtDocumentPart"
-------=mhtDocumentPart
-Content-Type: text/html;
-    charset="utf-8"
-Content-Transfer-Encoding: quoted-printable
-Content-Location: file:///C:/fake/document.html
-${htmlSource}
-${contentParts}
-------=mhtDocumentPart--
-`;
-};
-const mhtPartTemplate = (contentType, contentEncoding, contentLocation, encodedContent) => {
-    return `------=mhtDocumentPart
-Content-Type: ${contentType}
-Content-Transfer-Encoding: ${contentEncoding}
-Content-Location: ${contentLocation}
-${encodedContent}
-`;
-};
-function getMHTdocument(htmlSource) {
-    debugger;
-    const ref = _prepareImageParts(htmlSource);
-    const imageContentPartsString = ref.imageContentParts.join('\n');
-    htmlSource = ref.htmlSource.replace(/\=/g, '=3D');
-    return mhtDocumentTemplate(htmlSource, imageContentPartsString);
-}
-function _prepareImageParts(htmlSource) {
-    debugger;
-    const imageContentParts = [];
-    const inlinedSrcPattern = /"data:(\w+\/\w+);(\w+),(\S+)"/g;
-    const inlinedReplacer = (match, contentType, contentEncoding, encodedContent) => {
-        const index = imageContentParts.length;
-        const extension = contentType.split('/')[1];
-        const contentLocation = `file:///C:/fake/image${index}.${extension}`;
-        imageContentParts.push(mhtPartTemplate(contentType, contentEncoding, contentLocation, encodedContent));
-        return `\"${contentLocation}\"`;
-    };
-    if (!/<img/g.test(htmlSource)) {
-        return { htmlSource, imageContentParts };
-    }
-    htmlSource = htmlSource.replace(inlinedSrcPattern, inlinedReplacer);
-    return { htmlSource, imageContentParts };
-}
-const convertHTML = HTMLToVDOM({
-    VNode: VNode$1,
-    VText,
-});
-const mergeOptions = (options, patch) => ({ ...options, ...patch });
-const fixupFontSize = (fontSize) => {
-    let normalizedFontSize;
-    if (pointRegex.test(fontSize)) {
-        const matchedParts = fontSize.match(pointRegex);
-        normalizedFontSize = pointToHIP(matchedParts[1]);
-    }
-    else if (fontSize) {
-        // assuming it is already in HIP
-        normalizedFontSize = fontSize;
-    }
-    else {
-        normalizedFontSize = null;
-    }
-    return normalizedFontSize;
-};
-const normalizeUnits = (dimensioningObject, defaultDimensionsProperty) => {
-    let normalizedUnitResult = {};
-    if (typeof dimensioningObject === 'object' && dimensioningObject !== null) {
-        Object.keys(dimensioningObject).forEach((key) => {
-            if (pixelRegex.test(dimensioningObject[key])) {
-                const matchedParts = dimensioningObject[key].match(pixelRegex);
-                normalizedUnitResult[key] = pixelToTWIP(matchedParts[1]);
-            }
-            else if (cmRegex.test(dimensioningObject[key])) {
-                const matchedParts = dimensioningObject[key].match(cmRegex);
-                normalizedUnitResult[key] = cmToTWIP(matchedParts[1]);
-            }
-            else if (inchRegex.test(dimensioningObject[key])) {
-                const matchedParts = dimensioningObject[key].match(inchRegex);
-                normalizedUnitResult[key] = inchToTWIP(matchedParts[1]);
-            }
-            else if (dimensioningObject[key]) {
-                normalizedUnitResult[key] = dimensioningObject[key];
-            }
-            else {
-                // incase value is something like 0
-                normalizedUnitResult[key] = defaultDimensionsProperty[key];
-            }
-        });
-    }
-    else {
-        // eslint-disable-next-line no-param-reassign
-        normalizedUnitResult = null;
-    }
-    return normalizedUnitResult;
-};
-const normalizeDocumentOptions = (documentOptions) => {
-    const normalizedDocumentOptions = { ...documentOptions };
-    Object.keys(documentOptions).forEach((key) => {
-        // eslint-disable-next-line default-case
-        switch (key) {
-            case 'pageSize':
-            case 'margins':
-                normalizedDocumentOptions[key] = normalizeUnits(documentOptions[key], defaultDocumentOptions[key]);
-                break;
-            case 'fontSize':
-            case 'complexScriptFontSize':
-                normalizedDocumentOptions[key] = fixupFontSize(documentOptions[key]);
-                break;
-        }
-    });
-    return normalizedDocumentOptions;
-};
-// Ref: https://en.wikipedia.org/wiki/Office_Open_XML_file_formats
-// http://officeopenxml.com/anatomyofOOXML.php
-async function addFilesToContainer(zip, htmlString, suppliedDocumentOptions, headerHTMLString, footerHTMLString) {
-    debugger;
-    const normalizedDocumentOptions = normalizeDocumentOptions(suppliedDocumentOptions);
-    const documentOptions = mergeOptions(defaultDocumentOptions, normalizedDocumentOptions);
-    if (documentOptions.header && !headerHTMLString) {
-        // eslint-disable-next-line no-param-reassign
-        headerHTMLString = defaultHTMLString;
-    }
-    if (documentOptions.footer && !footerHTMLString) {
-        // eslint-disable-next-line no-param-reassign
-        footerHTMLString = defaultHTMLString;
-    }
-    const docxDocument = new DocxDocument({ zip, htmlString, ...documentOptions });
-    // Conversion to Word XML happens here
-    docxDocument.documentXML = await renderDocumentFile(docxDocument);
-    debugger;
-    zip
-        .folder(relsFolderName)
-        .file('.rels', create({ encoding: 'UTF-8', standalone: true }, relsXML).toString({ prettyPrint: true }), { createFolders: false });
-    zip.folder('docProps').file('core.xml', docxDocument.generateCoreXML(), {
-        createFolders: false,
-    });
-    if (docxDocument.header && headerHTMLString) {
-        const vTree = convertHTML(headerHTMLString);
-        docxDocument.relationshipFilename = headerFileName;
-        const { headerId, headerXML } = await docxDocument.generateHeaderXML(vTree);
-        docxDocument.relationshipFilename = documentFileName;
-        const fileNameWithExt = `${headerType}${headerId}.xml`;
-        const relationshipId = docxDocument.createDocumentRelationships(docxDocument.relationshipFilename, headerType, fileNameWithExt, internalRelationship);
-        zip.folder(wordFolder).file(fileNameWithExt, generateDocumentTemplateHeader.toString({ prettyPrint: true }), {
-            createFolders: false,
-        });
-        docxDocument.headerObjects.push({ headerId, relationshipId, type: docxDocument.headerType });
-    }
-    if (docxDocument.footer && footerHTMLString) {
-        const vTree = convertHTML(footerHTMLString);
-        docxDocument.relationshipFilename = footerFileName;
-        const { footerId, footerXML } = await docxDocument.generateFooterXML(vTree);
-        docxDocument.relationshipFilename = documentFileName;
-        const fileNameWithExt = `${footerType}${footerId}.xml`;
-        const relationshipId = docxDocument.createDocumentRelationships(docxDocument.relationshipFilename, footerType, fileNameWithExt, internalRelationship);
-        console.log(footerXML.toString({ prettyPrint: true }));
-        if (suppliedDocumentOptions.pageNumber)
-            zip.folder(wordFolder).file(fileNameWithExt, generateDocumentTemplateFooter.toString({ prettyPrint: true }), {
-                createFolders: false,
-            });
-        else
-            zip.folder(wordFolder).file(fileNameWithExt, generateDocumentTemplateFooterWithoutPaging.toString({ prettyPrint: true }), {
-                createFolders: false,
-            });
-        docxDocument.footerObjects.push({ footerId, relationshipId, type: docxDocument.footerType });
-    }
-    const themeFileNameWithExt = `${themeFileName}.xml`;
-    docxDocument.createDocumentRelationships(docxDocument.relationshipFilename, themeType, `${themeFolder}/${themeFileNameWithExt}`, internalRelationship);
-    zip
-        .folder(wordFolder)
-        .folder(themeFolder)
-        .file(themeFileNameWithExt, docxDocument.generateThemeXML(), {
-        createFolders: false,
-    });
-    zip
-        .folder(wordFolder)
-        .file('document.xml', docxDocument.generateDocumentXML(), { createFolders: false })
-        .file('afchunk.mht', getMHTdocument(htmlString), {
-        createFolders: false,
-    })
-        .file('afchunkheader.mht', getMHTdocument(headerHTMLString), {
-        createFolders: false,
-    })
-        .file('afchunkfooter.mht', getMHTdocument(footerHTMLString), {
-        createFolders: false,
-    })
-        .file('fontTable.xml', docxDocument.generateFontTableXML(), { createFolders: false })
-        .file('styles.xml', docxDocument.generateStylesXML(), { createFolders: false })
-        .file('numbering.xml', docxDocument.generateNumberingXML(), { createFolders: false })
-        .file('settings.xml', docxDocument.generateSettingsXML(), { createFolders: false })
-        .file('webSettings.xml', docxDocument.generateWebSettingsXML(), { createFolders: false });
-    const relationshipXMLs = docxDocument.generateRelsXML();
-    if (relationshipXMLs && Array.isArray(relationshipXMLs)) {
-        relationshipXMLs.forEach(({ fileName, xmlString }) => {
-            console.log(xmlString);
-            zip.folder(wordFolder).folder(relsFolderName).file(`${fileName}.xml.rels`, xmlString, {
-                createFolders: false,
-            });
-        });
-    }
-    if (relationshipXMLs && Array.isArray(relationshipXMLs)) {
-        relationshipXMLs.forEach(({ fileName, xmlString }) => {
-            zip.folder(wordFolder).folder(relsFolderName).file(`header1.xml.rels`, xmlString, {
-                createFolders: false,
-            });
-        });
-    }
-    if (relationshipXMLs && Array.isArray(relationshipXMLs)) {
-        relationshipXMLs.forEach(({ fileName, xmlString }) => {
-            zip.folder(wordFolder).folder(relsFolderName).file(`footer1.xml.rels`, xmlString, {
-                createFolders: false,
-            });
-        });
-    }
-    zip.file('[Content_Types].xml', docxDocument.generateContentTypesXML(), { createFolders: false });
-    return zip;
-}
-/* eslint-disable no-useless-escape */
-const minifyHTMLString = (htmlString) => {
-    try {
-        if (typeof htmlString === 'string' || htmlString instanceof String) {
-            const minifiedHTMLString = htmlString
-                .replace(/\n/g, ' ')
-                .replace(/\r/g, ' ')
-                .replace(/\r\n/g, ' ')
-                .replace(/[\t]+\</g, '<')
-                .replace(/\>[\t ]+\</g, '><')
-                .replace(/\>[\t ]+$/g, '>');
-            return minifiedHTMLString;
-        }
-        throw new Error('invalid html string');
-    }
-    catch (error) {
-        return null;
-    }
-};
-async function generateContainer(htmlString, headerHTMLString, documentOptions = {}, footerHTMLString) {
-    const zip = new JSZip();
-    let contentHTML = htmlString;
-    let headerHTML = headerHTMLString;
-    let footerHTML = footerHTMLString;
-    if (htmlString) {
-        contentHTML = minifyHTMLString(contentHTML);
-    }
-    if (headerHTMLString) {
-        headerHTML = minifyHTMLString(headerHTML);
-    }
-    if (footerHTMLString) {
-        footerHTML = minifyHTMLString(footerHTML);
-    }
-    await addFilesToContainer(zip, contentHTML, documentOptions, headerHTML, footerHTML);
-    const buffer = await zip.generateAsync({ type: 'arraybuffer' });
-    if (Object.prototype.hasOwnProperty.call(global, 'Buffer')) {
-        return Buffer.from(new Uint8Array(buffer));
-    }
-    if (Object.prototype.hasOwnProperty.call(global, 'Blob')) {
-        // eslint-disable-next-line no-undef
-        return new Blob([buffer], {
-            type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        });
-    }
-    throw new Error('Add blob support using a polyfill eg https://github.com/bjornstar/blob-polyfill');
-}
+/**
+ * Word Document Service
+ *
+ * Uses dynamic imports to avoid bundling word generation dependencies (~8 MB)
+ * unless the service is actually used.
+ *
+ * Dependencies (loaded on-demand):
+ * - xmlbuilder2
+ * - jszip
+ * - html-to-vdom
+ * - virtual-dom
+ * - image-size
+ * - image-to-base64
+ * - color-name
+ * - escape-html
+ * - mime-types
+ */
 class WordDocumentService {
     async generateWordByteFile(model) {
+        // Dynamic import to avoid bundling word generation dependencies
+        // unless this method is actually called
+        const { generateContainer } = await import('./bnsights-bbsf-utilities-index-C3Twnewr.mjs');
         let documentOptions = {};
         if (model.options.isLandscape)
             documentOptions.orientation = 'landscape';