@bnsights/bbsf-utilities 1.0.69 → 1.2.0

package/fesm2022/bnsights-bbsf-utilities.mjs

@@ -1,37 +1,22 @@
 import { DOCUMENT, CommonModule } from '@angular/common';
 import * as i0 from '@angular/core';
-import { Injectable, Inject, inject, NgModule } from '@angular/core';
+import { Injectable, inject, Inject, NgModule } from '@angular/core';
 import * as i1$1 from '@angular/router';
-import { RouterModule } from '@angular/router';
+import { Router, RouterModule } from '@angular/router';
 import * as i4 from '@ngx-translate/core';
 import { TranslateService } from '@ngx-translate/core';
 import * as i1$2 from 'ng-block-ui';
 import { BlockUI, BlockUIModule } from 'ng-block-ui';
-import * as i2 from 'ngx-toastr';
-import { ToastrService, ToastrModule } from 'ngx-toastr';
+import { ToastrService, provideToastr } from 'ngx-toastr';
 import * as i4$1 from 'ngx-cookie-service';
 import { CookieService } from 'ngx-cookie-service';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
-import { Subject, throwError, Observable, lastValueFrom, BehaviorSubject } from 'rxjs';
+import { Subject, throwError, of, Observable, lastValueFrom, BehaviorSubject } from 'rxjs';
 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';
+import { takeUntil, tap, map, shareReplay, take } from 'rxjs/operators';
 
 class User {
 }
@@ -66,10 +51,10 @@ class AppearanceConfigurationService {
     getLogo() {
         return this.configService.getConfigurationValue('AnonymousLayout_Logo');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppearanceConfigurationService, deps: [{ token: ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppearanceConfigurationService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: AppearanceConfigurationService, deps: [{ token: ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: AppearanceConfigurationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppearanceConfigurationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: AppearanceConfigurationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -110,10 +95,10 @@ class ConfigurationService {
             return selectedKey;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigurationService, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigurationService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: ConfigurationService, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: ConfigurationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConfigurationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: ConfigurationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -137,14 +122,6 @@ class RequestOptionsModel {
     }
 }
 
-class WordDocumentModel {
-    constructor() {
-        this.options = new DocumentOptionsModel();
-    }
-}
-class DocumentOptionsModel {
-}
-
 class LanguageDTO {
 }
 
@@ -302,13 +279,13 @@ class ControlValidationService {
         let control = form.get(controlName);
         return control;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ControlValidationService, deps: [{ token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ControlValidationService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: ControlValidationService, deps: [{ token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: ControlValidationService, providedIn: 'root' }); }
 }
 __decorate([
     BlockUI()
 ], ControlValidationService.prototype, "blockUI", void 0);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ControlValidationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: ControlValidationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -397,10 +374,10 @@ class EnvironmentService {
         let cookieName = environment["BBSF_CookieName"];
         return cookieName;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EnvironmentService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: EnvironmentService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EnvironmentService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: EnvironmentService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -466,10 +443,10 @@ class MasterLayoutService {
         params = params.append('RoleID', permissionSetID);
         return this.http.post(this.apiUrl + 'SwitchRole', null, null, params);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MasterLayoutService, deps: [{ token: i1$1.Router }, { token: RequestHandlerService }, { token: AuthService }, { token: StylesBundleService }, { token: i4.TranslateService }, { token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MasterLayoutService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: MasterLayoutService, deps: [{ token: i1$1.Router }, { token: RequestHandlerService }, { token: AuthService }, { token: StylesBundleService }, { token: i4.TranslateService }, { token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: MasterLayoutService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MasterLayoutService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: MasterLayoutService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -477,15 +454,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         }], ctorParameters: () => [{ type: i1$1.Router }, { type: RequestHandlerService }, { type: AuthService }, { type: StylesBundleService }, { type: i4.TranslateService }, { type: EnvironmentService }] });
 
 class RequestHandlerService {
-    constructor(http, authService, environmentService, utilityService, bbsfTranslateService, router) {
+    constructor(http, authService, environmentService, utilityService, bbsfTranslateService) {
         this.http = http;
         this.authService = authService;
         this.environmentService = environmentService;
         this.utilityService = utilityService;
         this.bbsfTranslateService = bbsfTranslateService;
-        this.router = router;
         this.currentLanguage = "";
         this.onDestroy$ = new Subject();
+        this.router = inject(Router);
         //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor
         this.bbsfTranslateService.onLangChange.subscribe((event) => {
             if (this.currentLanguage != event.lang) {
@@ -718,12 +695,15 @@ class RequestHandlerService {
             'Image-Upload': 'true',
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RequestHandlerService, deps: [{ token: i1.HttpClient }, { token: AuthService }, { token: EnvironmentService }, { token: UtilityService }, { token: BBSFTranslateService }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RequestHandlerService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: RequestHandlerService, deps: [{ token: i1.HttpClient }, { token: AuthService }, { token: EnvironmentService }, { token: UtilityService }, { token: BBSFTranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: RequestHandlerService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RequestHandlerService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: AuthService }, { type: EnvironmentService }, { type: UtilityService }, { type: BBSFTranslateService }, { type: i1$1.Router }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: RequestHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: AuthService }, { type: EnvironmentService }, { type: UtilityService }, { type: BBSFTranslateService }] });
 
 class StylesBundleService {
     constructor(document, translateService) {
@@ -751,22 +731,43 @@ class StylesBundleService {
     loadStyleBundle(styleName) {
         const head = this.document.getElementsByTagName('head')[0];
         let themeLink = this.document.getElementById('client-theme');
-        if (themeLink && themeLink.href.includes(styleName)) {
-            return;
-        }
-        else if (themeLink && !themeLink.href.includes(styleName)) {
-            themeLink.remove();
+        let shouldRemoveOld = false;
+        if (themeLink) {
+            // ✅ Check if current CSS already loaded (by exact filename)
+            const currentFileName = this.getFileName(themeLink.href);
+            const requestedFileName = this.getFileName(styleName);
+            if (currentFileName === requestedFileName) {
+                return; // Same CSS already loaded
+            }
+            else {
+                shouldRemoveOld = true; // Mark for removal after new CSS is added
+            }
         }
+        // ✅ Add new CSS first (prevents FOUC)
         const style = this.document.createElement('link');
         style.id = 'client-theme';
         style.rel = 'stylesheet';
         style.href = `${styleName}`;
         head.appendChild(style);
+        // ✅ Remove old CSS after new one is added (smooth transition)
+        if (shouldRemoveOld && themeLink) {
+            themeLink.remove();
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StylesBundleService, deps: [{ token: DOCUMENT }, { token: BBSFTranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StylesBundleService, providedIn: 'root' }); }
+    /**
+   * Extract filename from full path
+   * @param path Full path or just filename
+   * @returns The filename only
+   */
+    getFileName(path) {
+        // Extract just the filename from full path
+        const parts = path.split('/');
+        return parts[parts.length - 1];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: StylesBundleService, deps: [{ token: DOCUMENT }, { token: BBSFTranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: StylesBundleService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StylesBundleService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: StylesBundleService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -777,10 +778,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }] }, { type: BBSFTranslateService }] });
 
 class BBSFTranslateService extends TranslateService {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BBSFTranslateService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BBSFTranslateService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BBSFTranslateService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BBSFTranslateService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BBSFTranslateService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BBSFTranslateService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -860,3805 +861,287 @@ class UtilityService {
     stopBlockUI() {
         this.blockUI.stop();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UtilityService, deps: [{ token: BBSFTranslateService }, { token: EnvironmentService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UtilityService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: UtilityService, deps: [{ token: BBSFTranslateService }, { token: EnvironmentService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: UtilityService, providedIn: 'root' }); }
 }
 __decorate([
     BlockUI()
 ], UtilityService.prototype, "blockUI", void 0);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UtilityService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: UtilityService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], 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> */
+/**
+ * Language service with internal caching
+ */
+class LanguageService {
+    constructor(http) {
+        this.http = http;
+        this.apiUrl = '/api/Language/';
+        this._languages = [];
+        this.isLoading = false;
+        this.isLoaded = false;
+        this.loadRequest$ = null;
+    }
+    /** Pure getter - no side effects */
+    get languages() {
+        return this._languages;
+    }
+    /** Internal method - loads languages from API (race-condition safe) */
+    loadLanguages() {
+        if (this.isLoaded || this.isLoading)
+            return; // Sync guard prevents race condition
+        this.isLoading = true; // Set immediately to block concurrent calls
+        this.loadRequest$ = this.http.get(this.apiUrl + 'GetAll', null, null).pipe(tap((languages) => {
+            this._languages = languages;
+            this.isLoaded = true;
+            this.isLoading = false;
+        }), shareReplay(1));
+        // take(1) ensures auto-unsubscribe after completion
+        this.loadRequest$.pipe(take(1)).subscribe({
+            error: (err) => {
+                this.isLoading = false;
+                this.loadRequest$ = null;
+            }
+        });
+    }
+    /** Get languages as Observable - triggers load if not loaded */
+    getLanguages() {
+        if (this.isLoaded) {
+            return of(this._languages);
+        }
+        if (!this.isLoading) {
+            this.loadLanguages();
+        }
+        return this.loadRequest$ ?? of(this._languages);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: LanguageService, deps: [{ token: RequestHandlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: LanguageService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: RequestHandlerService }] });
 
-/* 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
+class SpeechRecognitionService {
+    constructor(zone, utilityService) {
+        this.zone = zone;
+        this.utilityService = utilityService;
+        this.isListening = false;
+        this.isSupported = false;
+        this.language = 'en-US';
+        const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+        if (SpeechRecognition) {
+            this.recognition = new SpeechRecognition();
+            this.recognition.continuous = true;
+            this.recognition.interimResults = false;
+            this.recognition.maxAlternatives = 1;
+            this.isSupported = true;
+        }
     }
-    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);
+    startListening(language = this.language) {
+        if (!this.isSupported) {
+            return throwError(() => new Error('Web Speech API is not supported in this browser.'));
+        }
+        return new Observable(observer => {
+            this.isListening = true;
+            this.recognition.lang = language;
+            this.recognition.start();
+            this.recognition.onresult = (event) => {
+                this.zone.run(() => {
+                    const transcript = event.results[event.results.length - 1][0].transcript;
+                    observer.next(transcript);
+                });
+            };
+            this.recognition.onspeechend = () => {
+                this.stopListening();
+            };
+            this.recognition.onerror = (event) => {
+                this.zone.run(() => {
+                    if (event.error === 'not-allowed') {
+                        this.utilityService.notifyErrorMessage(this.utilityService.getResourceValue("MicAccessDenied"));
+                        observer.error('Microphone access denied by the user.');
+                    }
+                    else {
+                        observer.error(event.error);
+                    }
+                });
+            };
+            this.recognition.onend = () => {
+                this.zone.run(() => {
+                    if (this.isListening) {
+                        this.recognition.start(); // Automatically restart
+                    }
+                    else {
+                        observer.complete();
+                    }
+                });
+            };
+        });
     }
-    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));
-};
+    stopListening() {
+        if (this.isSupported) {
+            this.isListening = false;
+            this.recognition.stop();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: SpeechRecognitionService, deps: [{ token: i0.NgZone }, { token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: SpeechRecognitionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: SpeechRecognitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: UtilityService }] });
 
-/* 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);
+class FileLoaderService {
+    // environment:any;
+    constructor(translate, http) {
+        this.translate = translate;
+        this.http = http;
+        this.availableLanguages = ['en', 'ar']; // Add more languages as needed
+        this.translate.addLangs(this.availableLanguages);
     }
-    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);
+    loadEnvironment() {
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = '/assets/config/environment.js';
+            script.onload = () => {
+                if (window.Environment) {
+                    Object.assign(environment, window.Environment);
+                    resolve();
+                }
+                else {
+                    reject('Environment variables not found.');
+                }
+            };
+            script.onerror = () => reject('Failed to load environment.js');
+            document.head.appendChild(script);
+        });
     }
-    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);
+    async preloadTranslations() {
+        try {
+            const requests = this.availableLanguages.map(async (lang) => {
+                const translations = await lastValueFrom(this.http.get(`/assets/i18n/${lang}.json`));
+                this.translate.setTranslation(lang, translations, true);
+            });
+            await Promise.all(requests);
+            this.translate.use('en'); // Set default language manually
+        }
+        catch (error) {
+            console.error('Error preloading translations:', error);
+        }
     }
-    else if (hexRegex.test(colorCodeString)) {
-        const matchedParts = colorCodeString.match(hexRegex);
-        return matchedParts[1];
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: FileLoaderService, deps: [{ token: BBSFTranslateService }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: FileLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: FileLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: BBSFTranslateService }, { type: i1.HttpClient }] });
+
+class AuthService {
+    static { this.user = null; }
+    get user() {
+        if (!this._user) {
+            this._user = this.getUserManager();
+        }
+        return this._user;
     }
-    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);
+    static { this.UserClaims = null; }
+    //refresh
+    static { this.timers = []; }
+    static { this.seconds = 0; }
+    constructor(injector, http, environmentService, translateService, router, cookieService, utilityService) {
+        this.injector = injector;
+        this.http = http;
+        this.environmentService = environmentService;
+        this.translateService = translateService;
+        this.router = router;
+        this.cookieService = cookieService;
+        this.utilityService = utilityService;
+        this.redirectUrl = '';
+        this.jwtHelper = new JwtHelperService();
+        this.isAuthenticatedSubject = new BehaviorSubject(this.hasToken());
+        this.isAuthenticate$ = this.isAuthenticatedSubject.asObservable();
     }
-    else {
-        return '000000';
+    get TOKEN_KEY() {
+        if (!this._TOKEN_KEY) {
+            this._TOKEN_KEY = this.environmentService.getCookieName();
+        }
+        return this._TOKEN_KEY;
     }
-};
-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';
+    hasToken() {
+        const token = this.cookieService.get(this.TOKEN_KEY);
+        return token && !this.jwtHelper.isTokenExpired(token);
     }
-    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);
+    getUserManager() {
+        const token = this.cookieService.get(this.TOKEN_KEY);
+        if (token) {
+            if (!this.jwtHelper.isTokenExpired(token))
+                this.handleAccessTokenWithoutLanguage(token);
+            else
+                this.cookieService.delete(this.TOKEN_KEY, '/');
         }
         else {
-            // 240 TWIP or 12 point is default line height
-            return +lineHeight * 240;
+            AuthService.timers.map(t => clearInterval(t));
+            AuthService.timers = [];
+            AuthService.user = null;
+            this._user = null;
         }
+        return AuthService.user;
     }
-    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]);
+    getUser() {
+        this._user = AuthService.user;
     }
-    else if (pixelRegex.test(fontSizeString)) {
-        const matchedParts = fontSizeString.match(pixelRegex);
-        // convert pixels to half point
-        return pixelToHIP(matchedParts[1]);
+    storUser(User) {
+        AuthService.user = this._user = this.user;
     }
-};
-// 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]);
+    getCurrentUser() {
+        return AuthService.user;
     }
-    else if (pixelRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(pixelRegex);
-        // convert pixels to half point
-        return pixelToTWIP(matchedParts[1]);
+    isAuthenticated() {
+        AuthService.user = this.user;
+        return AuthService.user != null && !this.jwtHelper.isTokenExpired(AuthService.user.access_token);
     }
-    else if (cmRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(cmRegex);
-        return cmToTWIP(matchedParts[1]);
+    isUserInRole(allowedPermission) {
+        let selectedPermissionSetID = Number.parseInt(AuthService.user.profile['selectedpermissionsetid']);
+        return allowedPermission.includes(selectedPermissionSetID);
     }
-    else if (inchRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(inchRegex);
-        return inchToTWIP(matchedParts[1]);
+    isUserPermissionSetsInRoles(allowedPermission) {
+        const permissionSetSIDString = AuthService.user.profile['permissionSetSID'];
+        if (!permissionSetSIDString) {
+            return false;
+        }
+        // Split comma-separated string and convert to numbers
+        const userPermissionSets = permissionSetSIDString
+            .split(',')
+            .map(id => Number.parseInt(id.trim()))
+            .filter(id => !isNaN(id)); // Filter out invalid numbers
+        // Check if any user permission set is in the allowed permissions
+        return userPermissionSets.some(permissionSetID => allowedPermission.includes(permissionSetID));
     }
-};
-// eslint-disable-next-line consistent-return
-const fixupColumnWidth = (columnWidthString) => {
-    if (pointRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(pointRegex);
-        return pointToTWIP(matchedParts[1]);
+    authorizationHeaderValue() {
+        return AuthService.user
+            ? `${AuthService.user.token_type} ${AuthService.user.access_token}`
+            : '';
     }
-    else if (pixelRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(pixelRegex);
-        return pixelToTWIP(matchedParts[1]);
+    name() {
+        return AuthService.user != null ? AuthService.user.profile.given_name : '';
     }
-    else if (cmRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(cmRegex);
-        return cmToTWIP(matchedParts[1]);
+    setUrl(url) {
+        localStorage.setItem('redirectUrl', url);
     }
-    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');
-}
-
-class WordDocumentService {
-    async generateWordByteFile(model) {
-        let documentOptions = {};
-        if (model.options.isLandscape)
-            documentOptions.orientation = 'landscape';
-        documentOptions.pageSize = {
-            width: model.options.pageWidth * 15,
-            height: model.options.pageHeight * 15,
-        };
-        documentOptions.margins = {
-            top: model.options.top * 15,
-            right: model.options.right * 15,
-            bottom: model.options.bottom * 15,
-            left: model.options.left * 15,
-            header: model.options.top * 15 * 2,
-            footer: model.options.bottom * 15 * 2,
-            gutter: 0,
-        };
-        documentOptions.footer = true;
-        documentOptions.header = true;
-        documentOptions.pageNumber = model.options.showPaging;
-        documentOptions.table = { row: { cantSplit: true } };
-        var fileBuffer = await generateContainer(model.body, model.header, documentOptions, model.footer);
-        return fileBuffer;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WordDocumentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WordDocumentService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: WordDocumentService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class LanguageService {
-    constructor(http) {
-        this.http = http;
-        this.apiUrl = '/api/Language/';
-    }
-    getLanguages() {
-        return this.http.get(this.apiUrl + 'GetAll', null, null);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LanguageService, deps: [{ token: RequestHandlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LanguageService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LanguageService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: RequestHandlerService }] });
-
-class SpeechRecognitionService {
-    constructor(zone, utilityService) {
-        this.zone = zone;
-        this.utilityService = utilityService;
-        this.isListening = false;
-        this.isSupported = false;
-        this.language = 'en-US';
-        const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
-        if (SpeechRecognition) {
-            this.recognition = new SpeechRecognition();
-            this.recognition.continuous = true;
-            this.recognition.interimResults = false;
-            this.recognition.maxAlternatives = 1;
-            this.isSupported = true;
-        }
-    }
-    startListening(language = this.language) {
-        if (!this.isSupported) {
-            return throwError(() => new Error('Web Speech API is not supported in this browser.'));
-        }
-        return new Observable(observer => {
-            this.isListening = true;
-            this.recognition.lang = language;
-            this.recognition.start();
-            this.recognition.onresult = (event) => {
-                this.zone.run(() => {
-                    const transcript = event.results[event.results.length - 1][0].transcript;
-                    observer.next(transcript);
-                });
-            };
-            this.recognition.onspeechend = () => {
-                this.stopListening();
-            };
-            this.recognition.onerror = (event) => {
-                this.zone.run(() => {
-                    if (event.error === 'not-allowed') {
-                        this.utilityService.notifyErrorMessage(this.utilityService.getResourceValue("MicAccessDenied"));
-                        observer.error('Microphone access denied by the user.');
-                    }
-                    else {
-                        observer.error(event.error);
-                    }
-                });
-            };
-            this.recognition.onend = () => {
-                this.zone.run(() => {
-                    if (this.isListening) {
-                        this.recognition.start(); // Automatically restart
-                    }
-                    else {
-                        observer.complete();
-                    }
-                });
-            };
-        });
-    }
-    stopListening() {
-        if (this.isSupported) {
-            this.isListening = false;
-            this.recognition.stop();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpeechRecognitionService, deps: [{ token: i0.NgZone }, { token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpeechRecognitionService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpeechRecognitionService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i0.NgZone }, { type: UtilityService }] });
-
-class FileLoaderService {
-    // environment:any;
-    constructor(translate, http) {
-        this.translate = translate;
-        this.http = http;
-        this.availableLanguages = ['en', 'ar']; // Add more languages as needed
-        this.translate.addLangs(this.availableLanguages);
-    }
-    loadEnvironment() {
-        return new Promise((resolve, reject) => {
-            const script = document.createElement('script');
-            script.src = '/assets/config/environment.js';
-            script.onload = () => {
-                if (window.Environment) {
-                    Object.assign(environment, window.Environment);
-                    resolve();
-                }
-                else {
-                    reject('Environment variables not found.');
-                }
-            };
-            script.onerror = () => reject('Failed to load environment.js');
-            document.head.appendChild(script);
-        });
-    }
-    async preloadTranslations() {
-        try {
-            const requests = this.availableLanguages.map(async (lang) => {
-                const translations = await lastValueFrom(this.http.get(`/assets/i18n/${lang}.json`));
-                this.translate.setTranslation(lang, translations, true);
-            });
-            await Promise.all(requests);
-            this.translate.use('en'); // Set default language manually
-        }
-        catch (error) {
-            console.error('Error preloading translations:', error);
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileLoaderService, deps: [{ token: BBSFTranslateService }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileLoaderService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FileLoaderService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: BBSFTranslateService }, { type: i1.HttpClient }] });
-
-class AuthService {
-    static { this.user = null; }
-    get user() {
-        if (!this._user) {
-            this._user = this.getUserManager();
-        }
-        return this._user;
-    }
-    static { this.UserClaims = null; }
-    //refresh
-    static { this.timers = []; }
-    static { this.seconds = 0; }
-    constructor(injector, http, environmentService, translateService, router, cookieService, utilityService) {
-        this.injector = injector;
-        this.http = http;
-        this.environmentService = environmentService;
-        this.translateService = translateService;
-        this.router = router;
-        this.cookieService = cookieService;
-        this.utilityService = utilityService;
-        this.redirectUrl = '';
-        this.jwtHelper = new JwtHelperService();
-        this.isAuthenticatedSubject = new BehaviorSubject(this.hasToken());
-        this.isAuthenticate$ = this.isAuthenticatedSubject.asObservable();
-    }
-    get TOKEN_KEY() {
-        if (!this._TOKEN_KEY) {
-            this._TOKEN_KEY = this.environmentService.getCookieName();
-        }
-        return this._TOKEN_KEY;
-    }
-    hasToken() {
-        const token = this.cookieService.get(this.TOKEN_KEY);
-        return token && !this.jwtHelper.isTokenExpired(token);
-    }
-    getUserManager() {
-        const token = this.cookieService.get(this.TOKEN_KEY);
-        if (token) {
-            if (!this.jwtHelper.isTokenExpired(token))
-                this.handleAccessTokenWithoutLanguage(token);
-            else
-                this.cookieService.delete(this.TOKEN_KEY, '/');
-        }
-        else {
-            AuthService.timers.map(t => clearInterval(t));
-            AuthService.timers = [];
-            AuthService.user = null;
-            this._user = null;
-        }
-        return AuthService.user;
-    }
-    getUser() {
-        this._user = AuthService.user;
-    }
-    storUser(User) {
-        AuthService.user = this._user = this.user;
-    }
-    getCurrentUser() {
-        return AuthService.user;
-    }
-    isAuthenticated() {
-        AuthService.user = this.user;
-        return AuthService.user != null && !this.jwtHelper.isTokenExpired(AuthService.user.access_token);
-    }
-    isUserInRole(allowedPermission) {
-        let selectedPermissionSetID = Number.parseInt(AuthService.user.profile['selectedpermissionsetid']);
-        return allowedPermission.includes(selectedPermissionSetID);
-    }
-    isUserPermissionSetsInRoles(allowedPermission) {
-        const permissionSetSIDString = AuthService.user.profile['permissionSetSID'];
-        if (!permissionSetSIDString) {
-            return false;
-        }
-        // Split comma-separated string and convert to numbers
-        const userPermissionSets = permissionSetSIDString
-            .split(',')
-            .map(id => Number.parseInt(id.trim()))
-            .filter(id => !isNaN(id)); // Filter out invalid numbers
-        // Check if any user permission set is in the allowed permissions
-        return userPermissionSets.some(permissionSetID => allowedPermission.includes(permissionSetID));
-    }
-    authorizationHeaderValue() {
-        return AuthService.user
-            ? `${AuthService.user.token_type} ${AuthService.user.access_token}`
-            : '';
-    }
-    name() {
-        return AuthService.user != null ? AuthService.user.profile.given_name : '';
-    }
-    setUrl(url) {
-        localStorage.setItem('redirectUrl', url);
-    }
-    getUrl() {
-        return localStorage.getItem('redirectUrl') ?? "/";
+    getUrl() {
+        return localStorage.getItem('redirectUrl') ?? "/";
     }
     signOut() {
         let isAuthenticated = this.isAuthenticated();
@@ -4803,21 +1286,47 @@ class AuthService {
         window.location.href = logoutUrl;
         return;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [{ token: i0.Injector }, { token: i1.HttpClient }, { token: EnvironmentService }, { token: BBSFTranslateService }, { token: i1$1.Router }, { token: i4$1.CookieService }, { token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: AuthService, deps: [{ token: i0.Injector }, { token: i1.HttpClient }, { token: EnvironmentService }, { token: BBSFTranslateService }, { token: i1$1.Router }, { token: i4$1.CookieService }, { token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: AuthService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: AuthService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.HttpClient }, { type: EnvironmentService }, { type: BBSFTranslateService }, { type: i1$1.Router }, { type: i4$1.CookieService }, { type: UtilityService }] });
 
+/**
+ * BBSFUtilitiesModule
+ *
+ * This module provides full backward compatibility by including ALL services and modules
+ * from the original version. Simply import this module to get all functionality.
+ *
+ * For new applications, consider using modular imports via secondary entry points:
+ * - @bnsights/bbsf-utilities/auth       - Authentication services
+ * - @bnsights/bbsf-utilities/http       - HTTP request handling
+ * - @bnsights/bbsf-utilities/translate  - Translation services
+ * - @bnsights/bbsf-utilities/ui         - UI services (BlockUI, Toastr, etc.)
+ *
+ * @example
+ * // Backward compatible usage (imports everything):
+ * import { BBSFUtilitiesModule } from '@bnsights/bbsf-utilities';
+ *
+ * @NgModule({
+ *   imports: [BBSFUtilitiesModule]
+ * })
+ * export class AppModule { }
+ */
 class BBSFUtilitiesModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BBSFUtilitiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: BBSFUtilitiesModule, imports: [CommonModule,
-            RouterModule, i1$2.BlockUIModule, i2.ToastrModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BBSFUtilitiesModule, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BBSFUtilitiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.15", ngImport: i0, type: BBSFUtilitiesModule, imports: [CommonModule,
+            RouterModule, i1$2.BlockUIModule], exports: [
+            // Re-export modules for backward compatibility
+            CommonModule,
+            RouterModule,
+            BlockUIModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BBSFUtilitiesModule, providers: [
+            // All services for backward compatibility
             UtilityService,
             EnvironmentService,
             AuthService,
@@ -4830,13 +1339,17 @@ class BBSFUtilitiesModule {
             ConfigurationService,
             CookieService,
             LanguageService,
-            SpeechRecognitionService
+            SpeechRecognitionService,
+            provideToastr()
         ], imports: [CommonModule,
             RouterModule,
-            BlockUIModule.forRoot(),
-            ToastrModule.forRoot()] }); }
+            BlockUIModule.forRoot(), 
+            // Re-export modules for backward compatibility
+            CommonModule,
+            RouterModule,
+            BlockUIModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BBSFUtilitiesModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: BBSFUtilitiesModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
@@ -4844,10 +1357,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         CommonModule,
                         RouterModule,
                         BlockUIModule.forRoot(),
-                        ToastrModule.forRoot(),
                     ],
-                    exports: [],
+                    exports: [
+                        // Re-export modules for backward compatibility
+                        CommonModule,
+                        RouterModule,
+                        BlockUIModule,
+                    ],
                     providers: [
+                        // All services for backward compatibility
                         UtilityService,
                         EnvironmentService,
                         AuthService,
@@ -4860,20 +1378,29 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         ConfigurationService,
                         CookieService,
                         LanguageService,
-                        SpeechRecognitionService
+                        SpeechRecognitionService,
+                        provideToastr()
                     ]
                 }]
         }] });
 
 /*
  * Public API Surface of @bnsights/bbsf-utilities
+ *
+ * This is the CORE entry point with minimal dependencies.
+ *
+ * For feature-specific services, use secondary entry points:
+ * - @bnsights/bbsf-utilities/auth       - Authentication services
+ * - @bnsights/bbsf-utilities/word       - Word document generation
+ * - @bnsights/bbsf-utilities/translate  - Translation services
+ * - @bnsights/bbsf-utilities/ui         - UI services (BlockUI, Toastr, etc.)
+ * - @bnsights/bbsf-utilities/http       - HTTP request handling
  */
-//Module
-//#endregion
+//Module (Note: for backward compatibility - contains ALL providers)
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AppearanceConfigurationService, AuthService, AuthenticationModes, BBSFTranslateService, BBSFUtilitiesModule, ConfigurationService, ControlValidationService, DocumentOptionsModel, EnvironmentService, FileLoaderService, LanguageDTO, LanguageService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, SpeechRecognitionService, StylesBundleService, TranslationResolverService, UtilityService, WordDocumentModel, WordDocumentService, environment };
+export { AppearanceConfigurationService, AreaModel, AuthService, AuthenticationModes, BBSFTranslateService, BBSFUtilitiesModule, ConfigurationService, ControlValidationService, EnvironmentService, ErrorModel, FileLoaderService, LanguageDTO, LanguageService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, SpeechRecognitionService, StylesBundleService, TranslationResolverService, User, UtilityService, environment };
 //# sourceMappingURL=bnsights-bbsf-utilities.mjs.map