@bnsights/bbsf-utilities 1.0.42 → 1.0.44

package/fesm2015/bnsights-bbsf-utilities.mjs

@@ -1,4555 +0,0 @@
-import { DOCUMENT, CommonModule } from '@angular/common';
-import * as i0 from '@angular/core';
-import { Injectable, Inject, inject, NgModule } from '@angular/core';
-import * as i1$1 from '@angular/router';
-import { 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 * as i4$1 from 'ngx-cookie-service';
-import { CookieService } from 'ngx-cookie-service';
-import { __decorate, __awaiter, __rest } from 'tslib';
-import * as i1 from '@angular/common/http';
-import { HttpParams, HttpHeaders } from '@angular/common/http';
-import { Subject, Observable, throwError, BehaviorSubject } from 'rxjs';
-import { JwtHelperService } from '@auth0/angular-jwt';
-import { plainToClass } from 'class-transformer';
-import { takeUntil, tap, map } from 'rxjs/operators';
-import JSZip from 'jszip';
-import { fragment, create } from 'xmlbuilder2';
-import VNode$1 from 'virtual-dom/vnode/vnode';
-import VText from 'virtual-dom/vnode/vtext';
-import HTMLToVDOM from 'html-to-vdom';
-import { cloneDeep } from 'lodash';
-import { nanoid } from 'nanoid';
-import isVNode from 'virtual-dom/vnode/is-vnode';
-import isVText from 'virtual-dom/vnode/is-vtext';
-import escape from 'escape-html';
-import colorNames from 'color-name';
-import imageToBase64 from 'image-to-base64';
-import mimeTypes from 'mime-types';
-import sizeOf from 'image-size';
-
-class User {
-}
-
-var AuthenticationModes;
-(function (AuthenticationModes) {
-    AuthenticationModes["Forms"] = "Forms";
-    AuthenticationModes["UAEPass"] = "UAEPass";
-    AuthenticationModes["WindowsAD"] = "WindowsAD";
-    AuthenticationModes["AzureAD"] = "AzureAD";
-})(AuthenticationModes || (AuthenticationModes = {}));
-
-class AppearanceConfigurationService {
-    constructor(configService) {
-        this.configService = configService;
-    }
-    getLayoutTheme() {
-        return this.configService.getConfigurationValue('AnonymousLayout_Theme');
-    }
-    getFooterText() {
-        return this.configService.getConfigurationValue('AnonymousLayout_FooterText');
-    }
-    getPageTitle() {
-        return this.configService.getConfigurationValue('AnonymousLayout_PageTitle');
-    }
-    getFavIcon() {
-        return this.configService.getConfigurationValue('AnonymousLayout_FavIcon');
-    }
-    getCustomStyles() {
-        return this.configService.getConfigurationValue('AnonymousLayout_CustomStyles');
-    }
-    getLogo() {
-        return this.configService.getConfigurationValue('AnonymousLayout_Logo');
-    }
-}
-AppearanceConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppearanceConfigurationService, deps: [{ token: ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
-AppearanceConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppearanceConfigurationService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppearanceConfigurationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: ConfigurationService }]; } });
-
-class ConfigurationService {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-        this.httpClient.get("./assets/config/configurations.json").subscribe(data => {
-            ConfigurationService.JsonData = data;
-        });
-    }
-    getConfigurationValue(key) {
-        return ConfigurationService.JsonData[key];
-    }
-}
-ConfigurationService.JsonData = [];
-ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ConfigurationService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ConfigurationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
-
-class AreaModel {
-}
-
-class ErrorModel {
-}
-
-class RequestOptionsModel {
-    constructor() {
-        this.disableSuccessNotification = false;
-        this.disableBlockUI = false;
-        this.disableErrorHandler = false;
-        this.responseType = "";
-        this.formGroup = null;
-        this.castResponsetoClass = true;
-    }
-}
-
-class WordDocumentModel {
-    constructor() {
-        this.options = new DocumentOptionsModel();
-    }
-}
-class DocumentOptionsModel {
-}
-
-class ControlValidationService {
-    constructor(utilityService) {
-        this.utilityService = utilityService;
-        this.requestOptions = new RequestOptionsModel();
-        this.isCreatedBefor = false;
-    }
-    showGlobalError(errorMessage, formId, deleteOld) {
-        let globalErorrElement = document.getElementsByClassName('alert alert-InvalidValidation bg-light-danger text-danger');
-        if (globalErorrElement.length > 0) {
-            this.removeElementsByClass('alert alert-InvalidValidation bg-light-danger text-danger');
-        }
-        if (this.isCreatedBefor == true) {
-            this.removeElementsByClass('alert alert-InvalidValidation bg-light-danger text-danger');
-        }
-        // tslint:disable-next-line: prefer-const
-        if (!formId)
-            formId = "currentForm";
-        var object = document.getElementById(formId);
-        const tagName = 'div';
-        // tslint:disable-next-line: prefer-const
-        var elementToAppend = document.createElement(tagName); // Your tag name here
-        let message = "";
-        if (!errorMessage || (typeof errorMessage == "string")) {
-            if (localStorage.getItem('language') == "ar")
-                message = errorMessage ? errorMessage : "لديك بعص الأخطاء . من فضلك قم بالمراجعه ";
-            else
-                message = errorMessage ? errorMessage : "You have some validation errors. Please check below";
-            elementToAppend.innerHTML = "<ul class='list-unstyled m-0 py-3 d-flex align-items-center fs-6'><li><i class='fa fa-times-circle text-danger me-3 fs-2'></i>" + message + "</li></ul>";
-            elementToAppend.className += 'alert alert-InvalidValidation bg-light-danger text-danger';
-            elementToAppend.id += 'errorId';
-            // tslint:disable-next-line: prefer-for-of
-            const elementToAppen = elementToAppend.cloneNode(true);
-            // let targetElement = object.getElementsByClassName("b-control")[0];
-            object.insertBefore(elementToAppen, object.firstChild);
-        }
-        else {
-            let ul = document.createElement("ul");
-            elementToAppend.appendChild(ul);
-            for (const iterator of errorMessage) {
-                let li = document.createElement("li");
-                li.innerHTML = iterator;
-                ul.appendChild(li);
-            }
-            elementToAppend.className += 'alert alert-InvalidValidation bg-light-danger text-danger';
-            elementToAppend.id += 'errorId';
-            // tslint:disable-next-line: prefer-for-of
-            const elementToAppen = elementToAppend.cloneNode(true);
-            // let targetElement = object.getElementsByClassName("b-control")[0];
-            object.insertBefore(elementToAppen, object.firstChild);
-        }
-        this.isCreatedBefor = true;
-    }
-    removeGlobalError() {
-        const removedList = document.getElementsByClassName('alert alert-InvalidValidation bg-light-danger text-danger');
-        // tslint:disable-next-line: prefer-for-of
-        for (let index = 0; index < removedList.length; index++) {
-            const element = removedList[index];
-            element.remove();
-        }
-        this.isCreatedBefor = false;
-    }
-    showInputErro(errors) {
-        // show error on top of form 
-        this.showGlobalError();
-        // remove old error from server
-        this.removeElementsByClass('errortemplet');
-        // Looping in error Object
-        for (const key in errors) {
-            if (errors.hasOwnProperty(key)) {
-                for (const iterator of errors[key]) {
-                    const input = document.querySelectorAll('[ng-reflect-name=' + key + ']')[0];
-                    if (input.attributes['ng-reflect-name'].value === key) {
-                        this.removeElementsByClass('erroclass-' + key);
-                        const tagName = 'p';
-                        const elementToAppend = document.createElement(tagName); // Your tag name here
-                        elementToAppend.innerHTML = iterator;
-                        elementToAppend.style.color = 'red';
-                        elementToAppend.className += 'errortemplet erroclass-' + key;
-                        const elementToappen = elementToAppend.cloneNode(true);
-                        input.parentNode.insertBefore(elementToappen, input.lastChild);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    removeElementsByClass(className) {
-        const elements = document.getElementsByClassName(className);
-        while (elements.length > 0) {
-            elements[0].parentNode.removeChild(elements[0]);
-        }
-    }
-    renderServerErrors(form, err, requestOptions, formId) {
-        if (err.error == null) {
-            return;
-        }
-        let errorsArray = [];
-        this.requestOptions = requestOptions;
-        if (err.error.validation_errors) {
-            err.error.validation_errors.forEach((element) => {
-                let fieldName = element.field;
-                let controlName = element.controlName;
-                let message = element.message;
-                if (form == null) {
-                    this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
-                }
-                else if (controlName && !this.hasControlName(form, controlName)) {
-                    errorsArray.push(`${fieldName}: ${message}`);
-                }
-                else {
-                    this.setFieldError(form, controlName, fieldName, message);
-                    this.showGlobalError(null, formId);
-                }
-            });
-            if (errorsArray.length > 0)
-                this.showGlobalError(errorsArray, formId);
-        }
-    }
-    hasControlName(form, controlName) {
-        let control = form.get(controlName);
-        return control != null;
-    }
-    setFieldError(form, controlName, fieldName, message) {
-        let control = null;
-        if (controlName)
-            control = this.getControlFormNameByFieldName(form, controlName);
-        else
-            control = this.getControlFormNameByFieldName(form, fieldName.split('.')[0]);
-        let errors = { "errorMassage": message };
-        let fieldNameArray = fieldName.split('.');
-        if (fieldNameArray.length >= 1) {
-            switch (fieldNameArray[fieldNameArray.length - 1].toLocaleLowerCase()) {
-                case "english":
-                    let englishControl = control.get("English");
-                    englishControl.setErrors(errors);
-                    break;
-                case "arabic":
-                    let arabicControl = control.get("Arabic");
-                    arabicControl.setErrors(errors);
-                    break;
-                default:
-                    control.setErrors(errors);
-            }
-        }
-        else {
-            this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
-        }
-    }
-    getControlFormNameByFieldName(form, fieldName) {
-        const formControls = form.controls;
-        let controlName = Object.keys(formControls).find(c => c.toLocaleLowerCase() === fieldName.toLocaleLowerCase());
-        let control = form.get(controlName);
-        return control;
-    }
-}
-ControlValidationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlValidationService, deps: [{ token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable });
-ControlValidationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlValidationService, providedIn: 'root' });
-__decorate([
-    BlockUI()
-], ControlValidationService.prototype, "blockUI", void 0);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlValidationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: UtilityService }]; }, propDecorators: { blockUI: [] } });
-
-// This file can be replaced during build by using the `fileReplacements` array.
-// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
-// The list of file replacements can be found in `angular.json`.
-const environment = Object.assign({}, window.Environment);
-/*
- * In development mode, to ignore zone related error stack frames such as
- * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
- * import the following file, but please comment it out in production mode
- * because it will have performance impact when throw error
- */
-// import 'zone.js/dist/zone-error';  // Included with Angular CLI.
-
-class EnvironmentService {
-    getEnvironmentObject() {
-        return environment;
-    }
-    getBaseUrl() {
-        return environment["BBSF_BaseURL"];
-    }
-    getApiUrl() {
-        return environment["BBSF_ApiUrl"];
-    }
-    getProductionMode() {
-        return environment["BBSF_IsProduction"];
-    }
-    getDefaultLanguage() {
-        return environment["BBSF_DefaultLanguage"];
-    }
-    getIdentityServerUrl() {
-        return environment["BBSF_IdentityServerUrl"];
-    }
-    getIsIdentityServerExternal() {
-        return environment["BBSF_IsExternalIdentityServer"];
-    }
-    getIsIdentityServerClientId() {
-        return environment["BBSF_IdentityServer_Client_Id"];
-    }
-    getIsIdentityServerClientSecret() {
-        return environment["BBSF_IdentityServer_Client_Secret"];
-    }
-    getBBSFAuthenticationMode() {
-        let Mode = environment["BBSF_AuthenticationMode"];
-        return Mode;
-    }
-    getUAEPassBaseUrl() {
-        let Mode = environment["UAEPass_BaseUrl"];
-        return Mode;
-    }
-    getUAEPassClientID() {
-        let Mode = environment["UAEPass_ClientID"];
-        return Mode;
-    }
-    getUAEPassRedirectUrl() {
-        let Mode = environment["UAEPass_RedirectUrl"];
-        return Mode;
-    }
-    getUAEPassAuthorizationEndPoint() {
-        let Mode = environment["UAEPass_AuthorizationEndPoint"];
-        return Mode;
-    }
-    getUAEPassRedirectLogoutUrl() {
-        let Mode = environment["UAEPass_RedirectLogoutUrl"];
-        return Mode;
-    }
-    getUAEPassLogoutEndPoint() {
-        let Mode = environment["UAEPass_LogoutEndPoint"];
-        return Mode;
-    }
-    getIsEnableWindowsAuthentication() {
-        let Mode = environment["BBSF_Enable_WindowsAuthentication"];
-        return Mode.toLocaleLowerCase() == 'true';
-    }
-}
-EnvironmentService.areaList = [];
-EnvironmentService.AreaList = [];
-EnvironmentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-EnvironmentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EnvironmentService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
-class MasterLayoutService {
-    constructor(router, http, authService, stylesBundleService, translate, environmentService) {
-        this.router = router;
-        this.http = http;
-        this.authService = authService;
-        this.stylesBundleService = stylesBundleService;
-        this.translate = translate;
-        this.environmentService = environmentService;
-        this.apiUrl = '/api/Home/';
-    }
-    switchLang(lang, bundleEnglishName, bundleArabicName) {
-        this.changeLanguage(lang).subscribe((result) => {
-            this.updateUserInfo().subscribe((Value) => {
-                let UserInfoObject = Value;
-                this.authService.handleAccessToken(UserInfoObject.token);
-                this.stylesBundleService.loadThemes(lang, bundleEnglishName, bundleArabicName);
-                localStorage.setItem('language', lang);
-                this.translate.use(lang);
-            });
-        });
-    }
-    reloadComponent() {
-        let currentUrl = this.router.url;
-        this.router.routeReuseStrategy.shouldReuseRoute = () => false;
-        this.router.onSameUrlNavigation = 'reload';
-        this.router.navigate([currentUrl]);
-    }
-    changeLanguage(key) {
-        let params = new HttpParams();
-        params = params.append('UserId', this.authService.user.profile.id);
-        params = params.append('LanguageKey', key);
-        return this.http.post(this.apiUrl + 'UpdateLanguage', null, null, params);
-    }
-    logError(error) {
-        let params = new HttpParams();
-        params = params.append('error', error);
-        return this.http.post(this.apiUrl + 'LogError', null, null, params);
-    }
-    updateUserInfo() {
-        return this.http.get(this.apiUrl + 'UpdateUserInfo', null, null);
-    }
-    switchRole(permissionSetID) {
-        this.updateRole(permissionSetID).subscribe((result) => {
-            this.updateUserInfo().subscribe((Value) => {
-                let UserInfoObject = Value;
-                this.authService.handleAccessToken(UserInfoObject.token);
-            });
-        });
-    }
-    updateRole(permissionSetID) {
-        let params = new HttpParams();
-        params = params.append('UserId', this.authService.user.profile.id);
-        params = params.append('RoleID', permissionSetID);
-        return this.http.post(this.apiUrl + 'SwitchRole', null, null, params);
-    }
-}
-MasterLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MasterLayoutService, deps: [{ token: i1$1.Router }, { token: RequestHandlerService }, { token: AuthService }, { token: StylesBundleService }, { token: i4.TranslateService }, { token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable });
-MasterLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MasterLayoutService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MasterLayoutService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: RequestHandlerService }, { type: AuthService }, { type: StylesBundleService }, { type: i4.TranslateService }, { type: EnvironmentService }]; } });
-
-class RequestHandlerService {
-    constructor(http, authService, environmentService, utilityService, bbsfTranslateService, router) {
-        this.http = http;
-        this.authService = authService;
-        this.environmentService = environmentService;
-        this.utilityService = utilityService;
-        this.bbsfTranslateService = bbsfTranslateService;
-        this.router = router;
-        this.requestOptions = new RequestOptionsModel();
-        this.currentLanguage = "";
-        this.onDestroy$ = new Subject();
-        //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) {
-                this.currentLanguage = event.lang;
-            }
-        });
-    }
-    getLuckyNumber() {
-        return Observable.create((subject) => {
-            setInterval(() => {
-                const number = Math.floor(Math.random() * 10);
-                console.log(number);
-                subject.next(number);
-            }, 1000);
-        }).pipe(takeUntil(this.onDestroy$));
-    }
-    get(Url, params, responseType, requestOptions) {
-        if (requestOptions)
-            this.requestOptions = requestOptions;
-        let headers = this.getHeaders();
-        if (!this.requestOptions.disableBlockUI)
-            this.utilityService.startBlockUI();
-        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
-            if (!this.requestOptions.disableBlockUI)
-                this.utilityService.stopBlockUI();
-        }, error => {
-            if (!this.requestOptions.disableErrorHandler)
-                this.handleError(error);
-        }), map((data) => {
-            if (this.requestOptions.castResponsetoClass)
-                return plainToClass(responseType, data, { excludeExtraneousValues: true });
-            else
-                return data;
-        }));
-    }
-    post(Url, model, responseType, params, requestOptions) {
-        if (requestOptions)
-            this.requestOptions = requestOptions;
-        let headers = this.getHeaders();
-        if (!this.requestOptions.disableBlockUI)
-            this.utilityService.startBlockUI();
-        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
-            if (!this.requestOptions.disableBlockUI)
-                this.utilityService.stopBlockUI();
-        }, error => {
-            if (!this.requestOptions.disableErrorHandler)
-                this.handleError(error);
-        }), map((data) => {
-            if (this.requestOptions.castResponsetoClass)
-                return plainToClass(responseType, data, { excludeExtraneousValues: true });
-            else
-                return data;
-        }));
-    }
-    delete(Url, deletedId, requestOptions, responseType, params) {
-        if (requestOptions)
-            this.requestOptions = requestOptions;
-        let headers = this.getHeaders();
-        if (!this.requestOptions.disableBlockUI)
-            this.utilityService.startBlockUI();
-        return this.http.delete(this.environmentService.getApiUrl() + Url + `/${deletedId}`, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
-            if (!this.requestOptions.disableBlockUI)
-                this.utilityService.stopBlockUI();
-        }, error => {
-            if (!this.requestOptions.disableErrorHandler)
-                this.handleError(error);
-        }), map((data) => {
-            if (this.requestOptions.castResponsetoClass)
-                return plainToClass(responseType, data, { excludeExtraneousValues: true });
-            else
-                return data;
-        }));
-    }
-    put(Url, model, params, responseType, requestOptions) {
-        if (requestOptions)
-            this.requestOptions = requestOptions;
-        let headers = this.getHeaders();
-        if (!this.requestOptions.disableBlockUI)
-            this.utilityService.startBlockUI();
-        return this.http.put(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
-            if (!this.requestOptions.disableBlockUI)
-                this.utilityService.stopBlockUI();
-        }, error => {
-            if (!this.requestOptions.disableErrorHandler)
-                this.handleError(error);
-        }), map((data) => {
-            if (this.requestOptions.castResponsetoClass)
-                return plainToClass(responseType, data, { excludeExtraneousValues: true });
-            else
-                return data;
-        }));
-    }
-    patch(Url, model, responseType, params, requestOptions) {
-        if (requestOptions)
-            this.requestOptions = requestOptions;
-        let headers = new HttpHeaders({
-            'Content-Type': 'application/json',
-            'Authorization': this.authService.authorizationHeaderValue(),
-        });
-        this.currentLanguage = localStorage.getItem('language');
-        headers = headers.set('Accept-Language', this.currentLanguage.toString());
-        headers = headers.set('ignore-cookies', 'true');
-        if (!this.requestOptions.disableBlockUI)
-            this.utilityService.startBlockUI();
-        return this.http.patch(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
-            if (!this.requestOptions.disableBlockUI)
-                this.utilityService.stopBlockUI();
-        }, error => {
-            if (!this.requestOptions.disableErrorHandler)
-                this.handleError(error);
-        }), map((data) => {
-            if (this.requestOptions.castResponsetoClass)
-                return plainToClass(responseType, data, { excludeExtraneousValues: true });
-            else
-                return data;
-        }));
-    }
-    download(Url, params, requestOptions) {
-        if (requestOptions)
-            this.requestOptions = requestOptions;
-        let headers = this.getHeaders();
-        if (!this.requestOptions.disableBlockUI)
-            this.utilityService.startBlockUI();
-        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
-            if (!this.requestOptions.disableBlockUI)
-                this.utilityService.stopBlockUI();
-        }, error => {
-            if (!this.requestOptions.disableErrorHandler)
-                this.handleError(error);
-        }));
-    }
-    destroyHandler() {
-        this.onDestroy$.next();
-    }
-    ngOnDestroy() {
-        console.log("clearInterval");
-        this.destroyHandler();
-    }
-    handleError(err) {
-        var isEnglish = this.utilityService.getCurrentLanguage() == "en";
-        if (err.error instanceof ErrorEvent) {
-            this.utilityService.notifyErrorMessage();
-        }
-        else {
-            if (err.status == 400)
-                throwError(err); //error 400 is thrown to be catch by the Form component to handle Fluent validation errors
-            else if (err.status == 401)
-                this.router.navigate(["/Admin/account/login"]);
-            else if (err.status == 403)
-                this.utilityService.notifyErrorMessage(isEnglish ? "Sorry, You're not authorized to access this action" : "عذرا ليس لديك الصلاحيه لهذا الطلب");
-            else if (err.status == 510)
-                this.utilityService.notifyErrorMessage(isEnglish ? "Can not delete this item as it is related to others" : "لا يمكن حذف هذا العنصر لأنه مرتبط بعناصر أخرى");
-            else if (err.status == 515)
-                this.utilityService.notifyErrorMessage((err.error ? err.error.Message : err.message));
-            else {
-                console.log(`error message is: ${err.error ? err.error.Message : err.message}`);
-                this.utilityService.notifyErrorMessage(this.utilityService.getResourceValue("ErrorMassage"));
-            }
-        }
-        this.utilityService.stopBlockUI();
-    }
-    getHeaders() {
-        return new HttpHeaders({
-            'Content-Type': 'application/json',
-            'Authorization': this.authService.authorizationHeaderValue(),
-            'Client-Local-Time-Zone': Intl.DateTimeFormat().resolvedOptions().timeZone,
-            'Accept-Language': localStorage.getItem('language'),
-            'ignore-cookies': 'true'
-        });
-    }
-}
-RequestHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService, deps: [{ token: i1.HttpClient }, { token: AuthService }, { token: EnvironmentService }, { token: UtilityService }, { token: BBSFTranslateService }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-RequestHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: AuthService }, { type: EnvironmentService }, { type: UtilityService }, { type: BBSFTranslateService }, { type: i1$1.Router }]; } });
-
-class StylesBundleService {
-    constructor(document, translateService) {
-        this.document = document;
-        this.translateService = translateService;
-    }
-    loadThemes(lang, bundleEnglishName, bundleArabicName) {
-        if (lang == "ar") {
-            this.loadStyleBundle(bundleArabicName.toString());
-            document.querySelector('html').setAttribute("b-lang", "ar"); //use b-lang instead of lang to fix firefox number inputs in Arabic locale
-            document.querySelector('html').setAttribute("dir", "rtl");
-        }
-        else {
-            this.loadStyleBundle(bundleEnglishName.toString());
-            document.querySelector('html').setAttribute("b-lang", "en");
-            document.querySelector('html').setAttribute("dir", "ltr");
-        }
-    }
-    loadThemesColor(theme, bundleDarkName, bundleLightName) {
-        if (theme == "Light")
-            this.loadStyleBundle(bundleLightName.toString());
-        else
-            this.loadStyleBundle(bundleDarkName.toString());
-    }
-    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();
-        }
-        const style = this.document.createElement('link');
-        style.id = 'client-theme';
-        style.rel = 'stylesheet';
-        style.href = `${styleName}`;
-        head.appendChild(style);
-    }
-}
-StylesBundleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, deps: [{ token: DOCUMENT }, { token: BBSFTranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
-StylesBundleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () {
-        return [{ type: Document, decorators: [{
-                        type: Inject,
-                        args: [DOCUMENT]
-                    }] }, { type: BBSFTranslateService }];
-    } });
-
-class BBSFTranslateService extends TranslateService {
-}
-BBSFTranslateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFTranslateService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-BBSFTranslateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFTranslateService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFTranslateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
-const TranslationResolverService = () => {
-    let translateService = inject(BBSFTranslateService);
-    return translateService.getTranslation(translateService.currentLang);
-};
-
-class UtilityService {
-    constructor(translator, environmentService, injector) {
-        this.translator = translator;
-        this.environmentService = environmentService;
-        this.injector = injector;
-        this.isCreatedBefore = false;
-    }
-    getResourceValue(Key) {
-        let ResourceValue = this.translator.instant(Key);
-        return ResourceValue;
-    }
-    getCurrentLanguage() {
-        let currentLanguage = this.environmentService.getDefaultLanguage();
-        let lang = localStorage.getItem('language');
-        if (lang)
-            currentLanguage = lang;
-        else
-            localStorage.setItem('language', currentLanguage);
-        return currentLanguage;
-    }
-    isCurrentLanguageEnglish() {
-        return this.getCurrentLanguage() == "en";
-    }
-    isCurrentLanguageArabic() {
-        return this.getCurrentLanguage() == "ar";
-    }
-    notifySuccessMessage(Message, title, time, showHeader = true) {
-        let MessageTemplate = this.getResourceValue("SuccessMessage");
-        let titleTemplate;
-        if (Message) {
-            MessageTemplate = Message;
-        }
-        if (title) {
-            titleTemplate = title;
-        }
-        let toaster = this.injector.get(ToastrService);
-        showHeader ? toaster.success(MessageTemplate, titleTemplate) : toaster.success(MessageTemplate);
-    }
-    notifyErrorMessage(Message, title, time, showHeader = true) {
-        let MessageTemplate = this.getResourceValue("ErrorMessage");
-        let titleTemplate = this.getResourceValue("Error");
-        if (Message) {
-            MessageTemplate = Message;
-        }
-        if (title) {
-            titleTemplate = title;
-        }
-        const toaster = this.injector.get(ToastrService);
-        showHeader ? toaster.error(MessageTemplate, titleTemplate) : toaster.error(MessageTemplate);
-    }
-    notifyWarningMessage(Message, title, time, showHeader = true) {
-        let MessageTemplate = this.getResourceValue("WarningMessage");
-        let titleTemplate = this.getResourceValue("Warning");
-        if (Message) {
-            MessageTemplate = Message;
-        }
-        if (title) {
-            titleTemplate = title;
-        }
-        const toaster = this.injector.get(ToastrService);
-        showHeader ? toaster.warning(MessageTemplate, titleTemplate) : toaster.warning(MessageTemplate);
-    }
-    startBlockUI() {
-        this.blockUI.start();
-    }
-    stopBlockUI() {
-        this.blockUI.stop();
-    }
-}
-UtilityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, deps: [{ token: BBSFTranslateService }, { token: EnvironmentService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-UtilityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, providedIn: 'root' });
-__decorate([
-    BlockUI()
-], UtilityService.prototype, "blockUI", void 0);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: BBSFTranslateService }, { type: EnvironmentService }, { type: i0.Injector }]; }, propDecorators: { blockUI: [] } });
-
-const contentTypesXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
-        <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
-        <Default Extension="jpeg" ContentType="image/jpeg"/>
-        <Default Extension="png" ContentType="image/png"/>
-        <Default Extension="xml" ContentType="application/xml"/>
-        <Override PartName="/_rels/.rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-        <Override PartName="/word/_rels/document.xml.rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-        <Override PartName="/word/_rels/footer1.xml.rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-        <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
-        <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
-        <Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>
-        <Override PartName="/word/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/>
-        <Override PartName="/word/fontTable.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>
-        <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
-        <Override PartName="/word/settings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>
-        <Override PartName="/word/webSettings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"/>
-        <Override PartName="/word/afchunk.mht" ContentType="message/rfc822"/>
-        <Override PartName="/word/afchunkheader.mht" ContentType="message/rfc822"/>
-        <Override PartName="/word/afchunkfooter.mht" ContentType="message/rfc822"/>
-    </Types>
-`;
-
-const namespaces = {
-    a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
-    b: 'http://schemas.openxmlformats.org/officeDocument/2006/bibliography',
-    cdr: 'http://schemas.openxmlformats.org/drawingml/2006/chartDrawing',
-    dc: 'http://purl.org/dc/elements/1.1/',
-    dcmitype: 'http://purl.org/dc/dcmitype/',
-    dcterms: 'http://purl.org/dc/terms/',
-    o: 'urn:schemas-microsoft-com:office:office',
-    pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
-    r: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
-    v: 'urn:schemas-microsoft-com:vml',
-    ve: 'http://schemas.openxmlformats.org/markup-compatibility/2006',
-    vt: 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes',
-    w: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
-    w10: 'urn:schemas-microsoft-com:office:word',
-    wp: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
-    wne: 'http://schemas.microsoft.com/office/word/2006/wordml',
-    xsd: 'http://www.w3.org/2001/XMLSchema',
-    xsi: 'http://www.w3.org/2001/XMLSchema-instance',
-    numbering: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering',
-    hyperlinks: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink',
-    images: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image',
-    styles: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles',
-    headers: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header',
-    footers: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer',
-    themes: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme',
-    coreProperties: 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties',
-    officeDocumentRelation: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument',
-    corePropertiesRelation: 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties',
-    settingsRelation: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings',
-    webSettingsRelation: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings',
-    sl: 'http://schemas.openxmlformats.org/schemaLibrary/2006/main',
-    contentTypes: 'http://schemas.openxmlformats.org/package/2006/content-types',
-    relationship: 'http://schemas.openxmlformats.org/package/2006/relationships',
-};
-
-const applicationName = 'html-to-docx';
-const defaultOrientation = 'portrait';
-const landscapeWidth = 15840;
-const landscapeHeight = 12240;
-const landscapeMargins = {
-    top: 1800,
-    right: 1440,
-    bottom: 1800,
-    left: 1440,
-    header: 720,
-    footer: 720,
-    gutter: 0,
-};
-const portraitMargins = {
-    top: 1440,
-    right: 1800,
-    bottom: 1440,
-    left: 1800,
-    header: 720,
-    footer: 720,
-    gutter: 0,
-};
-const defaultFont = 'Times New Roman';
-const defaultFontSize = 22;
-const defaultDocumentOptions = {
-    orientation: defaultOrientation,
-    margins: cloneDeep(portraitMargins),
-    title: '',
-    subject: '',
-    creator: applicationName,
-    keywords: [applicationName],
-    description: '',
-    lastModifiedBy: applicationName,
-    revision: 1,
-    createdAt: new Date(),
-    modifiedAt: new Date(),
-    headerType: 'default',
-    header: false,
-    footerType: 'default',
-    footer: false,
-    font: defaultFont,
-    fontSize: defaultFontSize,
-    complexScriptFontSize: defaultFontSize,
-    table: {
-        row: {
-            cantSplit: false,
-        },
-    },
-    pageSize: {
-        width: landscapeHeight,
-        height: landscapeWidth,
-    },
-    pageNumber: false,
-    skipFirstHeaderFooter: false,
-    lineNumber: false,
-    lineNumberOptions: {
-        countBy: 1,
-        start: 0,
-        restart: 'continuous',
-    },
-    numbering: {
-        defaultOrderedListStyleType: 'decimal',
-    },
-};
-const defaultHTMLString = '<p></p>';
-const relsFolderName = '_rels';
-const headerFileName = 'header1';
-const footerFileName = 'footer1';
-const themeFileName = 'theme1';
-const documentFileName = 'document';
-const headerType = 'header';
-const footerType = 'footer';
-const themeType = 'theme';
-const hyperlinkType = 'hyperlink';
-const imageType = 'image';
-const internalRelationship = 'Internal';
-const wordFolder = 'word';
-const themeFolder = 'theme';
-const paragraphBordersObject = {
-    top: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-    left: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-    bottom: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-    right: {
-        size: 0,
-        spacing: 3,
-        color: 'FFFFFF',
-    },
-};
-const colorlessColors = ['transparent', 'auto'];
-const verticalAlignValues = ['top', 'middle', 'bottom'];
-
-const generateCoreXML = (title = '', subject = '', creator = applicationName, keywords = [applicationName], description = '', lastModifiedBy = applicationName, revision = 1, createdAt = new Date(), modifiedAt = new Date()) => `
-        <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-        <cp:coreProperties
-          xmlns:cp="${namespaces.coreProperties}"
-          xmlns:dc="${namespaces.dc}"
-          xmlns:dcterms="${namespaces.dcterms}"
-          xmlns:dcmitype="${namespaces.dcmitype}"
-          xmlns:xsi="${namespaces.xsi}"
-          >
-            <dc:title>${title}</dc:title>
-            <dc:subject>${subject}</dc:subject>
-            <dc:creator>${creator}</dc:creator>
-            ${keywords && Array.isArray(keywords)
-    ? `<cp:keywords>${keywords.join(', ')}</cp:keywords>`
-    : ''}
-            <dc:description>${description}</dc:description>
-            <cp:lastModifiedBy>${lastModifiedBy}</cp:lastModifiedBy>
-            <cp:revision>${revision}</cp:revision>
-            <dcterms:created xsi:type="dcterms:W3CDTF">${createdAt instanceof Date ? createdAt.toISOString() : new Date().toISOString()}</dcterms:created>
-            <dcterms:modified xsi:type="dcterms:W3CDTF">${modifiedAt instanceof Date ? modifiedAt.toISOString() : new Date().toISOString()}</dcterms:modified>
-        </cp:coreProperties>
-    `;
-
-const documentRelsXML = `
-  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-  <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-    <Relationship Id="rId1" Type="${namespaces.numbering}" Target="numbering.xml"/>
-    <Relationship Id="rId2" Type="${namespaces.styles}" Target="styles.xml"/>
-    <Relationship Id="rId3" Type="${namespaces.settingsRelation}" Target="settings.xml"/>
-    <Relationship Id="rId4" Type="${namespaces.webSettingsRelation}" Target="webSettings.xml"/>
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunk.mht" Id="htmlChunk" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkheader.mht" Id="htmlChunkHeader" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkfooter.mht" Id="htmlChunkFooter" />
-  </Relationships>
-`;
-
-const relsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-        <Relationship Id="rId1" Type="${namespaces.officeDocumentRelation}" Target="word/document.xml"/>
-        <Relationship Id="rId2" Type="${namespaces.corePropertiesRelation}" Target="docProps/core.xml"/>
-    </Relationships>
-`;
-
-const generateNumberingXMLTemplate = () => `
-        <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-        <w:numbering
-        xmlns:w="${namespaces.w}"
-        xmlns:ve="${namespaces.ve}"
-        xmlns:o="${namespaces.o}"
-        xmlns:r="${namespaces.r}"
-        xmlns:v="${namespaces.v}"
-        xmlns:wp="${namespaces.wp}"
-        xmlns:w10="${namespaces.w10}"
-        xmlns:wne="${namespaces.wne}">
-        </w:numbering>
-    `;
-
-const generateStylesXML = (font = defaultFont, fontSize = defaultFontSize, complexScriptFontSize = defaultFontSize) => `
-  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-  <w:styles xmlns:w="${namespaces.w}" xmlns:r="${namespaces.r}">
-	<w:docDefaults>
-	  <w:rPrDefault>
-		<w:rPr>
-		  <w:rFonts w:ascii="${font}" w:eastAsiaTheme="minorHAnsi" w:hAnsiTheme="minorHAnsi" w:cstheme="minorBidi" />
-		  <w:sz w:val="${fontSize}" />
-		  <w:szCs w:val="${complexScriptFontSize}" />
-		  <w:lang w:val="en-US" w:eastAsia="en-US" w:bidi="ar-SA" />
-		</w:rPr>
-	  </w:rPrDefault>
-	  <w:pPrDefault>
-		<w:pPr>
-		  <w:spacing w:after="120" w:line="240" w:lineRule="atLeast" />
-		</w:pPr>
-	  </w:pPrDefault>
-	</w:docDefaults>
-	<w:style w:type="character" w:styleId="Hyperlink">
-	  <w:name w:val="Hyperlink" />
-	  <w:rPr>
-		<w:color w:val="0000FF" />
-		<w:u w:val="single" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading1">
-	  <w:name w:val="heading 1" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="480" />
-		<w:outlineLvl w:val="0" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="48" />
-		<w:szCs w:val="48" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading2">
-	  <w:name w:val="heading 2" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="360" w:after="80" />
-		<w:outlineLvl w:val="1" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="36" />
-		<w:szCs w:val="36" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading3">
-	  <w:name w:val="heading 3" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="280" w:after="80" />
-		<w:outlineLvl w:val="2" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="28" />
-		<w:szCs w:val="28" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading4">
-	  <w:name w:val="heading 4" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="240" w:after="40" />
-		<w:outlineLvl w:val="3" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="24" />
-		<w:szCs w:val="24" />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading5">
-	  <w:name w:val="heading 5" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="220" w:after="40" />
-		<w:outlineLvl w:val="4" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-	  </w:rPr>
-	</w:style>
-	<w:style w:type="paragraph" w:styleId="Heading6">
-	  <w:name w:val="heading 6" />
-	  <w:basedOn w:val="Normal" />
-	  <w:next w:val="Normal" />
-	  <w:uiPriority w:val="9" />
-	  <w:semiHidden />
-	  <w:unhideWhenUsed />
-	  <w:qFormat />
-	  <w:pPr>
-		<w:keepNext />
-		<w:keepLines />
-		<w:spacing w:before="200" w:after="40" />
-		<w:outlineLvl w:val="5" />
-	  </w:pPr>
-	  <w:rPr>
-		<w:b />
-		<w:sz w:val="20" />
-		<w:szCs w:val="20" />
-	  </w:rPr>
-	</w:style>
-  </w:styles>
-  `;
-
-const fontTableXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <w:fonts
-      xmlns:r="${namespaces.r}"
-      xmlns:w="${namespaces.w}"
-      >
-        <w:font w:name="Symbol">
-            <w:panose1 w:val="05050102010706020507"/>
-            <w:charset w:val="02"/>
-            <w:family w:val="decorative"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="00000000" w:usb1="10000000" w:usb2="00000000" w:usb3="00000000" w:csb0="80000000" w:csb1="00000000"/>
-        </w:font>
-        <w:font w:name="Calibri">
-            <w:panose1 w:val="020F0502020204030204"/>
-            <w:charset w:val="00"/>
-            <w:family w:val="swiss"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="E4002EFF" w:usb1="C000247B" w:usb2="00000009" w:usb3="00000000" w:csb0="000001FF" w:csb1="00000000"/>
-        </w:font>
-        <w:font w:name="Times New Roman">
-            <w:panose1 w:val="02020603050405020304"/>
-            <w:charset w:val="00"/>
-            <w:family w:val="roman"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="E0002EFF" w:usb1="C000785B" w:usb2="00000009" w:usb3="00000000" w:csb0="000001FF" w:csb1="00000000"/>
-        </w:font>
-        <w:font w:name="Calibri Light">
-            <w:panose1 w:val="020F0302020204030204"/>
-            <w:charset w:val="00"/>
-            <w:family w:val="swiss"/>
-            <w:pitch w:val="variable"/>
-            <w:sig w:usb0="E4002EFF" w:usb1="C000247B" w:usb2="00000009" w:usb3="00000000" w:csb0="000001FF" w:csb1="00000000"/>
-        </w:font>
-    </w:fonts>
-`;
-
-const generateThemeXML = (font = defaultFont) => `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Office Theme">
-    <a:themeElements>
-      <a:clrScheme name="Office">
-        <a:dk1>
-          <a:sysClr val="windowText" lastClr="000000"/>
-        </a:dk1>
-        <a:lt1>
-          <a:sysClr val="window" lastClr="FFFFFF"/>
-        </a:lt1>
-        <a:dk2>
-          <a:srgbClr val="44546A"/>
-        </a:dk2>
-        <a:lt2>
-          <a:srgbClr val="E7E6E6"/>
-        </a:lt2>
-        <a:accent1>
-          <a:srgbClr val="4472C4"/>
-        </a:accent1>
-        <a:accent2>
-          <a:srgbClr val="ED7D31"/>
-        </a:accent2>
-        <a:accent3>
-          <a:srgbClr val="A5A5A5"/>
-        </a:accent3>
-        <a:accent4>
-          <a:srgbClr val="FFC000"/>
-        </a:accent4>
-        <a:accent5>
-          <a:srgbClr val="5B9BD5"/>
-        </a:accent5>
-        <a:accent6>
-          <a:srgbClr val="70AD47"/>
-        </a:accent6>
-        <a:hlink>
-          <a:srgbClr val="0563C1"/>
-        </a:hlink>
-        <a:folHlink>
-          <a:srgbClr val="954F72"/>
-        </a:folHlink>
-      </a:clrScheme>
-      <a:fontScheme name="Office">
-        <a:majorFont>
-          <a:latin typeface="${font}"/>
-          <a:ea typeface="${font}"/>
-          <a:cs typeface=""/>
-        </a:majorFont>
-        <a:minorFont>
-          <a:latin typeface="${font}"/>
-          <a:ea typeface="${font}"/>
-          <a:cs typeface=""/>
-        </a:minorFont>
-      </a:fontScheme>
-      <a:fmtScheme name="Office">
-        <a:fillStyleLst>
-          <a:solidFill>
-            <a:schemeClr val="phClr"/>
-          </a:solidFill>
-          <a:gradFill rotWithShape="1">
-            <a:gsLst>
-              <a:gs pos="0">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="110000"/>
-                  <a:satMod val="105000"/>
-                  <a:tint val="67000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="50000">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="105000"/>
-                  <a:satMod val="103000"/>
-                  <a:tint val="73000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="100000">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="105000"/>
-                  <a:satMod val="109000"/>
-                  <a:tint val="81000"/>
-                </a:schemeClr>
-              </a:gs>
-            </a:gsLst>
-            <a:lin ang="5400000" scaled="0"/>
-          </a:gradFill>
-          <a:gradFill rotWithShape="1">
-            <a:gsLst>
-              <a:gs pos="0">
-                <a:schemeClr val="phClr">
-                  <a:satMod val="103000"/>
-                  <a:lumMod val="102000"/>
-                  <a:tint val="94000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="50000">
-                <a:schemeClr val="phClr">
-                  <a:satMod val="110000"/>
-                  <a:lumMod val="100000"/>
-                  <a:shade val="100000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="100000">
-                <a:schemeClr val="phClr">
-                  <a:lumMod val="99000"/>
-                  <a:satMod val="120000"/>
-                  <a:shade val="78000"/>
-                </a:schemeClr>
-              </a:gs>
-            </a:gsLst>
-            <a:lin ang="5400000" scaled="0"/>
-          </a:gradFill>
-        </a:fillStyleLst>
-        <a:lnStyleLst>
-          <a:ln w="6350" cap="flat" cmpd="sng" algn="ctr">
-            <a:solidFill>
-              <a:schemeClr val="phClr"/>
-            </a:solidFill>
-            <a:prstDash val="solid"/>
-            <a:miter lim="800000"/>
-          </a:ln>
-          <a:ln w="12700" cap="flat" cmpd="sng" algn="ctr">
-            <a:solidFill>
-              <a:schemeClr val="phClr"/>
-            </a:solidFill>
-            <a:prstDash val="solid"/>
-            <a:miter lim="800000"/>
-          </a:ln>
-          <a:ln w="19050" cap="flat" cmpd="sng" algn="ctr">
-            <a:solidFill>
-              <a:schemeClr val="phClr"/>
-            </a:solidFill>
-            <a:prstDash val="solid"/>
-            <a:miter lim="800000"/>
-          </a:ln>
-        </a:lnStyleLst>
-        <a:effectStyleLst>
-          <a:effectStyle>
-            <a:effectLst/>
-          </a:effectStyle>
-          <a:effectStyle>
-            <a:effectLst/>
-          </a:effectStyle>
-          <a:effectStyle>
-            <a:effectLst>
-              <a:outerShdw blurRad="57150" dist="19050" dir="5400000" algn="ctr" rotWithShape="0">
-                <a:srgbClr val="000000">
-                  <a:alpha val="63000"/>
-                </a:srgbClr>
-              </a:outerShdw>
-            </a:effectLst>
-          </a:effectStyle>
-        </a:effectStyleLst>
-        <a:bgFillStyleLst>
-          <a:solidFill>
-            <a:schemeClr val="phClr"/>
-          </a:solidFill>
-          <a:solidFill>
-            <a:schemeClr val="phClr">
-              <a:tint val="95000"/>
-              <a:satMod val="170000"/>
-            </a:schemeClr>
-          </a:solidFill>
-          <a:gradFill rotWithShape="1">
-            <a:gsLst>
-              <a:gs pos="0">
-                <a:schemeClr val="phClr">
-                  <a:tint val="93000"/>
-                  <a:satMod val="150000"/>
-                  <a:shade val="98000"/>
-                  <a:lumMod val="102000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="50000">
-                <a:schemeClr val="phClr">
-                  <a:tint val="98000"/>
-                  <a:satMod val="130000"/>
-                  <a:shade val="90000"/>
-                  <a:lumMod val="103000"/>
-                </a:schemeClr>
-              </a:gs>
-              <a:gs pos="100000">
-                <a:schemeClr val="phClr">
-                  <a:shade val="63000"/>
-                  <a:satMod val="120000"/>
-                </a:schemeClr>
-              </a:gs>
-            </a:gsLst>
-            <a:lin ang="5400000" scaled="0"/>
-          </a:gradFill>
-        </a:bgFillStyleLst>
-      </a:fmtScheme>
-    </a:themeElements>
-  </a:theme>
-`;
-
-const settingsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <w:settings xmlns:w="${namespaces.w}" xmlns:o="${namespaces.o}" xmlns:r="${namespaces.r}" xmlns:v="${namespaces.v}" xmlns:w10="${namespaces.w10}" xmlns:sl="${namespaces.sl}">
-        <w:zoom w:percent="100"/>
-        <w:defaultTabStop w:val="720"/>
-        <w:decimalSymbol w:val="."/>
-        <w:listSeparator w:val=","/>
-    </w:settings>
-`;
-
-const webSettingsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <w:webSettings xmlns:w="${namespaces.w}" xmlns:r="${namespaces.r}">
-    </w:webSettings>
-`;
-
-const genericRelsXML = `
-    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-
-    <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunk.mht" Id="htmlChunk" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkheader.mht" Id="htmlChunkHeader" />
-    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk"   Target="/word/afchunkfooter.mht" Id="htmlChunkFooter" />
-    </Relationships>
-`;
-
-const generateDocumentTemplate = (width, height, orientation, margins) => `
-  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-    <w:document
-        xmlns:a="${namespaces.a}"
-        xmlns:cdr="${namespaces.cdr}"
-        xmlns:o="${namespaces.o}"
-        xmlns:pic="${namespaces.pic}"
-        xmlns:r="${namespaces.r}"
-        xmlns:v="${namespaces.v}"
-        xmlns:ve="${namespaces.ve}"
-        xmlns:vt="${namespaces.vt}"
-        xmlns:w="${namespaces.w}"
-        xmlns:w10="${namespaces.w10}"
-        xmlns:wp="${namespaces.wp}"
-        xmlns:wne="${namespaces.wne}"
-        >
-        <w:body>
-
-        <w:altChunk r:id="htmlChunk" />
-            <w:sectPr>
-                <w:pgSz w:w="${width}" w:h="${height}" w:orient="${orientation}" />
-                <w:pgMar w:top="${margins.top}"
-                        w:right="${margins.right}"
-                        w:bottom="${margins.bottom}"
-                        w:left="${margins.left}"
-                        w:header="${margins.header}"
-                        w:footer="${margins.footer}"
-                        w:gutter="${margins.gutter}"/>
-            </w:sectPr>
-        </w:body>
-    </w:document>
-  `;
-const generateDocumentTemplateHeader = `
-<w:hdr
-xmlns:a="${namespaces.a}"
-xmlns:cdr="${namespaces.cdr}"
-xmlns:o="${namespaces.o}"
-xmlns:pic="${namespaces.pic}"
-xmlns:r="${namespaces.r}"
-xmlns:v="${namespaces.v}"
-xmlns:ve="${namespaces.ve}"
-xmlns:vt="${namespaces.vt}"
-xmlns:w="${namespaces.w}"
-xmlns:w10="${namespaces.w10}"
-xmlns:wp="${namespaces.wp}"
-xmlns:wne="${namespaces.wne}"
->
-<w:altChunk r:id="htmlChunkHeader" />
-</w:hdr>
-  `;
-const generateDocumentTemplateFooter = `
-  <w:ftr
-  xmlns:a="${namespaces.a}"
-  xmlns:cdr="${namespaces.cdr}"
-  xmlns:o="${namespaces.o}"
-  xmlns:pic="${namespaces.pic}"
-  xmlns:r="${namespaces.r}"
-  xmlns:v="${namespaces.v}"
-  xmlns:ve="${namespaces.ve}"
-  xmlns:vt="${namespaces.vt}"
-  xmlns:w="${namespaces.w}"
-  xmlns:w10="${namespaces.w10}"
-  xmlns:wp="${namespaces.wp}"
-  >
-  <w:altChunk r:id="htmlChunkFooter" />
-	<w:p w:rsidR="0014021C" w:rsidRDefault="0014021C" w:rsidP="0014021C">
-			<w:pPr>
-				<w:pStyle w:val="Footer"/>
-				<w:jc w:val="center"/>
-			</w:pPr>
-      <w:fldSimple xmlns:ns2="http://schemas.openxmlformats.org/wordprocessingml/2006/main" ns2:instr="PAGE">
-      <w:r/>
-    </w:fldSimple>
-		</w:p>
-	</w:ftr>
-  `;
-const generateDocumentTemplateFooterWithoutPaging = `
-  <w:ftr
-  xmlns:a="${namespaces.a}"
-  xmlns:cdr="${namespaces.cdr}"
-  xmlns:o="${namespaces.o}"
-  xmlns:pic="${namespaces.pic}"
-  xmlns:r="${namespaces.r}"
-  xmlns:v="${namespaces.v}"
-  xmlns:ve="${namespaces.ve}"
-  xmlns:vt="${namespaces.vt}"
-  xmlns:w="${namespaces.w}"
-  xmlns:w10="${namespaces.w10}"
-  xmlns:wp="${namespaces.wp}"
-  >
-  <w:altChunk r:id="htmlChunkFooter" />
-	</w:ftr>
-  `;
-{ /* <w:altChunk r:id="htmlChunkFooter" /> */ }
-{
-    /* <w:altChunk r:id="htmlChunkFooter" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" /> */
-}
-{
-    /* <w:ftr xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <fldSimple xmlns:ns2="http://schemas.openxmlformats.org/wordprocessingml/2006/main" ns2:instr="PAGE">
-  </fldSimple>
-  <w:altChunk r:id="htmlChunkFooter" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" />
-   </w:ftr> */
-}
-
-/* eslint-disable no-param-reassign */
-const rgbRegex = /rgb\((\d+),\s*([\d.]+),\s*([\d.]+)\)/i;
-const hslRegex = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/i;
-const hexRegex = /#([0-9A-F]{6})/i;
-const hex3Regex = /#([0-9A-F])([0-9A-F])([0-9A-F])/i;
-// eslint-disable-next-line import/prefer-default-export
-const rgbToHex = (red, green, blue) => {
-    const hexColorCode = [red, green, blue]
-        .map((x) => {
-        // eslint-disable-next-line radix, no-param-reassign
-        x = parseInt(x).toString(16);
-        return x.length === 1 ? `0${x}` : x;
-    })
-        .join('');
-    return hexColorCode;
-};
-const hslToHex = (hue, saturation, luminosity) => {
-    hue /= 360;
-    saturation /= 100;
-    luminosity /= 100;
-    // eslint-disable-next-line one-var
-    let red, green, blue;
-    if (saturation === 0) {
-        // eslint-disable-next-line no-multi-assign
-        red = green = blue = luminosity; // achromatic
-    }
-    else {
-        const hue2rgb = (p, q, t) => {
-            if (t < 0)
-                t += 1;
-            if (t > 1)
-                t -= 1;
-            if (t < 1 / 6)
-                return p + (q - p) * 6 * t;
-            if (t < 1 / 2)
-                return q;
-            if (t < 2 / 3)
-                return p + (q - p) * (2 / 3 - t) * 6;
-            return p;
-        };
-        const q = luminosity < 0.5
-            ? luminosity * (1 + saturation)
-            : luminosity + saturation - luminosity * saturation;
-        const p = 2 * luminosity - q;
-        red = hue2rgb(p, q, hue + 1 / 3);
-        green = hue2rgb(p, q, hue);
-        blue = hue2rgb(p, q, hue - 1 / 3);
-    }
-    return [red, green, blue]
-        .map((x) => {
-        const hex = Math.round(x * 255).toString(16);
-        return hex.length === 1 ? `0${hex}` : hex;
-    })
-        .join('');
-};
-const hex3ToHex = (red, green, blue) => {
-    const hexColorCode = [red, green, blue].map((x) => `${x}${x}`).join('');
-    return hexColorCode;
-};
-
-const pixelRegex = /([\d.]+)px/i;
-const percentageRegex = /([\d.]+)%/i;
-const pointRegex = /([\d.]+)pt/i;
-const cmRegex = /([\d.]+)cm/i;
-const inchRegex = /([\d.]+)in/i;
-const pixelToEMU = (pixelValue) => Math.round(pixelValue * 9525);
-const EMUToPixel = (EMUValue) => Math.round(EMUValue / 9525);
-const TWIPToEMU = (TWIPValue) => Math.round(TWIPValue * 635);
-const EMUToTWIP = (EMUValue) => Math.round(EMUValue / 635);
-const pointToTWIP = (pointValue) => Math.round(pointValue * 20);
-const TWIPToPoint = (TWIPValue) => Math.round(TWIPValue / 20);
-const pointToHIP = (pointValue) => Math.round(pointValue * 2);
-const HIPToPoint = (HIPValue) => Math.round(HIPValue / 2);
-const HIPToTWIP = (HIPValue) => Math.round(HIPValue * 10);
-const TWIPToHIP = (TWIPValue) => Math.round(TWIPValue / 10);
-const pixelToTWIP = (pixelValue) => EMUToTWIP(pixelToEMU(pixelValue));
-const TWIPToPixel = (TWIPValue) => EMUToPixel(TWIPToEMU(TWIPValue));
-const pixelToHIP = (pixelValue) => TWIPToHIP(EMUToTWIP(pixelToEMU(pixelValue)));
-const HIPToPixel = (HIPValue) => EMUToPixel(TWIPToEMU(HIPToTWIP(HIPValue)));
-const inchToPoint = (inchValue) => Math.round(inchValue * 72);
-const inchToTWIP = (inchValue) => pointToTWIP(inchToPoint(inchValue));
-const cmToInch = (cmValue) => cmValue * 0.3937008;
-const cmToTWIP = (cmValue) => inchToTWIP(cmToInch(cmValue));
-const pixelToPoint = (pixelValue) => HIPToPoint(pixelToHIP(pixelValue));
-const pointToPixel = (pointValue) => HIPToPixel(pointToHIP(pointValue));
-const EIPToPoint = (EIPValue) => Math.round(EIPValue / 8);
-const pointToEIP = (PointValue) => Math.round(PointValue * 8);
-const pixelToEIP = (pixelValue) => pointToEIP(pixelToPoint(pixelValue));
-const EIPToPixel = (EIPValue) => pointToPixel(EIPToPoint(EIPValue));
-
-// eslint-disable-next-line import/prefer-default-export
-const vNodeHasChildren = (vNode) => vNode && vNode.children && Array.isArray(vNode.children) && vNode.children.length;
-
-const isValidUrl = (urlString) => {
-    const urlRegex = /http(s)?:\/\/(\w+:?\w*@)?(\S+)(:\d+)?((?<=\.)\w+)+(\/([\w#!:.?+=&%@!\-/])*)?/gi;
-    return Boolean(urlRegex.test(urlString));
-};
-
-// eslint-disable-next-line consistent-return
-const fixupColorCode = (colorCodeString) => {
-    if (Object.prototype.hasOwnProperty.call(colorNames, colorCodeString.toLowerCase())) {
-        const [red, green, blue] = colorNames[colorCodeString.toLowerCase()];
-        return rgbToHex(red, green, blue);
-    }
-    else if (rgbRegex.test(colorCodeString)) {
-        const matchedParts = colorCodeString.match(rgbRegex);
-        const red = matchedParts[1];
-        const green = matchedParts[2];
-        const blue = matchedParts[3];
-        return rgbToHex(red, green, blue);
-    }
-    else if (hslRegex.test(colorCodeString)) {
-        const matchedParts = colorCodeString.match(hslRegex);
-        const hue = matchedParts[1];
-        const saturation = matchedParts[2];
-        const luminosity = matchedParts[3];
-        return hslToHex(hue, saturation, luminosity);
-    }
-    else if (hexRegex.test(colorCodeString)) {
-        const matchedParts = colorCodeString.match(hexRegex);
-        return matchedParts[1];
-    }
-    else if (hex3Regex.test(colorCodeString)) {
-        const matchedParts = colorCodeString.match(hex3Regex);
-        const red = matchedParts[1];
-        const green = matchedParts[2];
-        const blue = matchedParts[3];
-        return hex3ToHex(red, green, blue);
-    }
-    else {
-        return '000000';
-    }
-};
-const buildRunFontFragment = (fontName = defaultFont) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'rFonts')
-    .att('@w', 'ascii', fontName)
-    .att('@w', 'hAnsi', fontName)
-    .up();
-const buildRunStyleFragment = (type = 'Hyperlink') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'rStyle')
-    .att('@w', 'val', type)
-    .up();
-const buildTableRowHeight = (tableRowHeight) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'trHeight')
-    .att('@w', 'val', tableRowHeight)
-    .att('@w', 'hRule', 'atLeast')
-    .up();
-const buildVerticalAlignment = (verticalAlignment) => {
-    if (verticalAlignment.toLowerCase() === 'middle') {
-        verticalAlignment = 'center';
-    }
-    return fragment({ namespaceAlias: { w: namespaces.w } })
-        .ele('@w', 'vAlign')
-        .att('@w', 'val', verticalAlignment)
-        .up();
-};
-const buildVerticalMerge = (verticalMerge = 'continue') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'vMerge')
-    .att('@w', 'val', verticalMerge)
-    .up();
-const buildColor = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'color')
-    .att('@w', 'val', colorCode)
-    .up();
-const buildFontSize = (fontSize) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'sz')
-    .att('@w', 'val', fontSize)
-    .up();
-const buildShading = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'shd')
-    .att('@w', 'val', 'clear')
-    .att('@w', 'fill', colorCode)
-    .up();
-const buildHighlight = (color = 'yellow') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'highlight')
-    .att('@w', 'val', color)
-    .up();
-const buildVertAlign = (type = 'baseline') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'vertAlign')
-    .att('@w', 'val', type)
-    .up();
-const buildStrike = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'strike')
-    .att('@w', 'val', true)
-    .up();
-const buildBold = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'b')
-    .up();
-const buildItalics = () => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'i')
-    .up();
-const buildUnderline = (type = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'u')
-    .att('@w', 'val', type)
-    .up();
-const buildLineBreak = (type = 'textWrapping') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 'br')
-    .att('@w', 'type', type)
-    .up();
-const buildBorder = (borderSide = 'top', borderSize = 0, borderSpacing = 0, borderColor = fixupColorCode('black'), borderStroke = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', borderSide)
-    .att('@w', 'val', borderStroke)
-    .att('@w', 'sz', borderSize)
-    .att('@w', 'space', borderSpacing)
-    .att('@w', 'color', borderColor)
-    .up();
-const buildTextElement = (text) => fragment({ namespaceAlias: { w: namespaces.w } })
-    .ele('@w', 't')
-    .att('@xml', 'space', 'preserve')
-    .txt(text)
-    .up();
-// eslint-disable-next-line consistent-return
-const fixupLineHeight = (lineHeight, fontSize) => {
-    // FIXME: If line height is anything other than a number
-    // eslint-disable-next-line no-restricted-globals
-    if (!isNaN(lineHeight)) {
-        if (fontSize) {
-            const actualLineHeight = +lineHeight * fontSize;
-            return HIPToTWIP(actualLineHeight);
-        }
-        else {
-            // 240 TWIP or 12 point is default line height
-            return +lineHeight * 240;
-        }
-    }
-    else {
-        // 240 TWIP or 12 point is default line height
-        return 240;
-    }
-};
-// eslint-disable-next-line consistent-return
-const fixupFontSize$1 = (fontSizeString) => {
-    if (pointRegex.test(fontSizeString)) {
-        const matchedParts = fontSizeString.match(pointRegex);
-        // convert point to half point
-        return pointToHIP(matchedParts[1]);
-    }
-    else if (pixelRegex.test(fontSizeString)) {
-        const matchedParts = fontSizeString.match(pixelRegex);
-        // convert pixels to half point
-        return pixelToHIP(matchedParts[1]);
-    }
-};
-// eslint-disable-next-line consistent-return
-const fixupRowHeight = (rowHeightString) => {
-    if (pointRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(pointRegex);
-        // convert point to half point
-        return pointToTWIP(matchedParts[1]);
-    }
-    else if (pixelRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(pixelRegex);
-        // convert pixels to half point
-        return pixelToTWIP(matchedParts[1]);
-    }
-    else if (cmRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(cmRegex);
-        return cmToTWIP(matchedParts[1]);
-    }
-    else if (inchRegex.test(rowHeightString)) {
-        const matchedParts = rowHeightString.match(inchRegex);
-        return inchToTWIP(matchedParts[1]);
-    }
-};
-// eslint-disable-next-line consistent-return
-const fixupColumnWidth = (columnWidthString) => {
-    if (pointRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(pointRegex);
-        return pointToTWIP(matchedParts[1]);
-    }
-    else if (pixelRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(pixelRegex);
-        return pixelToTWIP(matchedParts[1]);
-    }
-    else if (cmRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(cmRegex);
-        return cmToTWIP(matchedParts[1]);
-    }
-    else if (inchRegex.test(columnWidthString)) {
-        const matchedParts = columnWidthString.match(inchRegex);
-        return inchToTWIP(matchedParts[1]);
-    }
-};
-// eslint-disable-next-line consistent-return
-const fixupMargin = (marginString) => {
-    if (pointRegex.test(marginString)) {
-        const matchedParts = marginString.match(pointRegex);
-        // convert point to half point
-        return pointToTWIP(matchedParts[1]);
-    }
-    else if (pixelRegex.test(marginString)) {
-        const matchedParts = marginString.match(pixelRegex);
-        // convert pixels to half point
-        return pixelToTWIP(matchedParts[1]);
-    }
-};
-const modifiedStyleAttributesBuilder = (vNode, attributes, options) => {
-    const modifiedAttributes = Object.assign({}, attributes);
-    // styles
-    if (isVNode(vNode) && vNode.properties && vNode.properties.style) {
-        if (vNode.properties.style.color && !colorlessColors.includes(vNode.properties.style.color)) {
-            modifiedAttributes.color = fixupColorCode(vNode.properties.style.color);
-        }
-        if (vNode.properties.style['background-color'] &&
-            !colorlessColors.includes(vNode.properties.style['background-color'])) {
-            modifiedAttributes.backgroundColor = fixupColorCode(vNode.properties.style['background-color']);
-        }
-        if (vNode.properties.style['vertical-align'] &&
-            verticalAlignValues.includes(vNode.properties.style['vertical-align'])) {
-            modifiedAttributes.verticalAlign = vNode.properties.style['vertical-align'];
-        }
-        if (vNode.properties.style['text-align'] &&
-            ['left', 'right', 'center', 'justify'].includes(vNode.properties.style['text-align'])) {
-            modifiedAttributes.textAlign = vNode.properties.style['text-align'];
-        }
-        // FIXME: remove bold check when other font weights are handled.
-        if (vNode.properties.style['font-weight'] && vNode.properties.style['font-weight'] === 'bold') {
-            modifiedAttributes.strong = vNode.properties.style['font-weight'];
-        }
-        if (vNode.properties.style['font-size']) {
-            modifiedAttributes.fontSize = fixupFontSize$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 = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    const runFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
-    const runPropertiesFragment = buildRunProperties(cloneDeep(attributes));
-    // case where we have recursive spans representing font changes
-    if (isVNode(vNode) && vNode.tagName === 'span') {
-        // eslint-disable-next-line no-use-before-define
-        return buildRunOrRuns(vNode, attributes, docxDocumentInstance);
-    }
-    if (isVNode(vNode) &&
-        [
-            'strong',
-            'b',
-            'em',
-            'i',
-            'u',
-            'ins',
-            'strike',
-            'del',
-            's',
-            'sub',
-            'sup',
-            'mark',
-            'blockquote',
-            'code',
-            'pre',
-        ].includes(vNode.tagName)) {
-        const runFragmentsArray = [];
-        let vNodes = [vNode];
-        // create temp run fragments to split the paragraph into different runs
-        let tempAttributes = cloneDeep(attributes);
-        let tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
-        while (vNodes.length) {
-            const tempVNode = vNodes.shift();
-            if (isVText(tempVNode)) {
-                const textFragment = buildTextElement(tempVNode.text);
-                const tempRunPropertiesFragment = buildRunProperties(Object.assign(Object.assign({}, attributes), tempAttributes));
-                tempRunFragment.import(tempRunPropertiesFragment);
-                tempRunFragment.import(textFragment);
-                runFragmentsArray.push(tempRunFragment);
-                // re initialize temp run fragments with new fragment
-                tempAttributes = cloneDeep(attributes);
-                tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
-            }
-            else if (isVNode(tempVNode)) {
-                if ([
-                    'strong',
-                    'b',
-                    'em',
-                    'i',
-                    'u',
-                    'ins',
-                    'strike',
-                    'del',
-                    's',
-                    'sub',
-                    'sup',
-                    'mark',
-                    'code',
-                    'pre',
-                ].includes(tempVNode.tagName)) {
-                    tempAttributes = {};
-                    switch (tempVNode.tagName) {
-                        case 'strong':
-                        case 'b':
-                            tempAttributes.strong = true;
-                            break;
-                        case 'i':
-                            tempAttributes.i = true;
-                            break;
-                        case 'u':
-                            tempAttributes.u = true;
-                            break;
-                        case 'sub':
-                            tempAttributes.sub = true;
-                            break;
-                        case 'sup':
-                            tempAttributes.sup = true;
-                            break;
-                    }
-                    const formattingFragment = buildFormatting(tempVNode);
-                    if (formattingFragment) {
-                        runPropertiesFragment.import(formattingFragment);
-                    }
-                    // go a layer deeper if there is a span somewhere in the children
-                }
-                else if (tempVNode.tagName === 'span') {
-                    // eslint-disable-next-line no-use-before-define
-                    const spanFragment = yield buildRunOrRuns(tempVNode, Object.assign(Object.assign({}, attributes), tempAttributes), docxDocumentInstance);
-                    // if spanFragment is an array, we need to add each fragment to the runFragmentsArray. If the fragment is an array, perform a depth first search on the array to add each fragment to the runFragmentsArray
-                    if (Array.isArray(spanFragment)) {
-                        spanFragment.flat(Infinity);
-                        runFragmentsArray.push(...spanFragment);
-                    }
-                    else {
-                        runFragmentsArray.push(spanFragment);
-                    }
-                    // do not slice and concat children since this is already accounted for in the buildRunOrRuns function
-                    // eslint-disable-next-line no-continue
-                    continue;
-                }
-            }
-            if (tempVNode.children && tempVNode.children.length) {
-                if (tempVNode.children.length > 1) {
-                    attributes = Object.assign(Object.assign({}, attributes), tempAttributes);
-                }
-                vNodes = tempVNode.children.slice().concat(vNodes);
-            }
-        }
-        if (runFragmentsArray.length) {
-            return runFragmentsArray;
-        }
-    }
-    runFragment.import(runPropertiesFragment);
-    if (isVText(vNode)) {
-        const textFragment = buildTextElement(vNode.text);
-        runFragment.import(textFragment);
-    }
-    else if (attributes && attributes.type === 'picture') {
-        let response = null;
-        const base64Uri = decodeURIComponent(vNode.properties.src);
-        if (base64Uri) {
-            response = docxDocumentInstance.createMediaFile(base64Uri);
-        }
-        if (response) {
-            docxDocumentInstance.zip
-                .folder('word')
-                .folder('media')
-                .file(response.fileNameWithExtension, Buffer.from(response.fileContent, 'base64'), {
-                createFolders: false,
-            });
-            const documentRelsId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, imageType, `media/${response.fileNameWithExtension}`, internalRelationship);
-            attributes.inlineOrAnchored = true;
-            attributes.relationshipId = documentRelsId;
-            attributes.id = response.id;
-            attributes.fileContent = response.fileContent;
-            attributes.fileNameWithExtension = response.fileNameWithExtension;
-        }
-        const { type, inlineOrAnchored } = attributes, otherAttributes = __rest(attributes, ["type", "inlineOrAnchored"]);
-        // eslint-disable-next-line no-use-before-define
-        const imageFragment = buildDrawing(inlineOrAnchored, type, otherAttributes);
-        runFragment.import(imageFragment);
-    }
-    else if (isVNode(vNode) && vNode.tagName === 'br') {
-        const lineBreakFragment = buildLineBreak();
-        runFragment.import(lineBreakFragment);
-    }
-    runFragment.up();
-    return runFragment;
-});
-const buildRunOrRuns = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    if (isVNode(vNode) && vNode.tagName === 'span') {
-        let runFragments = [];
-        for (let index = 0; index < vNode.children.length; index++) {
-            const childVNode = vNode.children[index];
-            const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes);
-            const tempRunFragments = yield buildRun(childVNode, modifiedAttributes, docxDocumentInstance);
-            runFragments = runFragments.concat(Array.isArray(tempRunFragments) ? tempRunFragments : [tempRunFragments]);
-        }
-        return runFragments;
-    }
-    else {
-        const tempRunFragments = yield buildRun(vNode, attributes, docxDocumentInstance);
-        return tempRunFragments;
-    }
-});
-const buildRunOrHyperLink = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    if (isVNode(vNode) && vNode.tagName === 'a') {
-        const relationshipId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, hyperlinkType, vNode.properties && vNode.properties.href ? vNode.properties.href : '');
-        const hyperlinkFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })
-            .ele('@w', 'hyperlink')
-            .att('@r', 'id', `rId${relationshipId}`);
-        const modifiedAttributes = Object.assign({}, attributes);
-        modifiedAttributes.hyperlink = true;
-        const runFragments = yield buildRunOrRuns(vNode.children[0], modifiedAttributes, docxDocumentInstance);
-        if (Array.isArray(runFragments)) {
-            for (let index = 0; index < runFragments.length; index++) {
-                const runFragment = runFragments[index];
-                hyperlinkFragment.import(runFragment);
-            }
-        }
-        else {
-            hyperlinkFragment.import(runFragments);
-        }
-        hyperlinkFragment.up();
-        return hyperlinkFragment;
-    }
-    const runFragments = yield buildRunOrRuns(vNode, attributes, docxDocumentInstance);
-    return runFragments;
-});
-const 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 = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'p');
-    const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes, {
-        isParagraph: true,
-    });
-    const paragraphPropertiesFragment = buildParagraphProperties(modifiedAttributes);
-    paragraphFragment.import(paragraphPropertiesFragment);
-    if (isVNode(vNode) && vNodeHasChildren(vNode)) {
-        if ([
-            'span',
-            'strong',
-            'b',
-            'em',
-            'i',
-            'u',
-            'ins',
-            'strike',
-            'del',
-            's',
-            'sub',
-            'sup',
-            'mark',
-            'a',
-            'code',
-            'pre',
-        ].includes(vNode.tagName)) {
-            const runOrHyperlinkFragments = yield buildRunOrHyperLink(vNode, modifiedAttributes, docxDocumentInstance);
-            if (Array.isArray(runOrHyperlinkFragments)) {
-                for (let iteratorIndex = 0; iteratorIndex < runOrHyperlinkFragments.length; iteratorIndex++) {
-                    const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];
-                    paragraphFragment.import(runOrHyperlinkFragment);
-                }
-            }
-            else {
-                paragraphFragment.import(runOrHyperlinkFragments);
-            }
-        }
-        else if (vNode.tagName === 'blockquote') {
-            const runFragmentOrFragments = yield buildRun(vNode, attributes);
-            if (Array.isArray(runFragmentOrFragments)) {
-                for (let index = 0; index < runFragmentOrFragments.length; index++) {
-                    paragraphFragment.import(runFragmentOrFragments[index]);
-                }
-            }
-            else {
-                paragraphFragment.import(runFragmentOrFragments);
-            }
-        }
-        else {
-            for (let index = 0; index < vNode.children.length; index++) {
-                const childVNode = vNode.children[index];
-                if (childVNode.tagName === 'img') {
-                    let base64String;
-                    const imageSource = childVNode.properties.src;
-                    if (isValidUrl(imageSource)) {
-                        base64String = yield imageToBase64(imageSource).catch((error) => {
-                            // eslint-disable-next-line no-console
-                            console.warning(`skipping image download and conversion due to ${error}`);
-                        });
-                        if (base64String && mimeTypes.lookup(imageSource)) {
-                            childVNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                    else {
-                        // eslint-disable-next-line no-useless-escape, prefer-destructuring
-                        base64String = imageSource.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/)[2];
-                    }
-                    const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');
-                    const imageProperties = sizeOf(imageBuffer);
-                    modifiedAttributes.maximumWidth =
-                        modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;
-                    modifiedAttributes.originalWidth = imageProperties.width;
-                    modifiedAttributes.originalHeight = imageProperties.height;
-                    computeImageDimensions(childVNode, modifiedAttributes);
-                }
-                const runOrHyperlinkFragments = yield buildRunOrHyperLink(childVNode, isVNode(childVNode) && childVNode.tagName === 'img'
-                    ? Object.assign(Object.assign({}, modifiedAttributes), { type: 'picture' }) : modifiedAttributes, docxDocumentInstance);
-                if (Array.isArray(runOrHyperlinkFragments)) {
-                    for (let iteratorIndex = 0; iteratorIndex < runOrHyperlinkFragments.length; iteratorIndex++) {
-                        const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];
-                        paragraphFragment.import(runOrHyperlinkFragment);
-                    }
-                }
-                else {
-                    paragraphFragment.import(runOrHyperlinkFragments);
-                }
-            }
-        }
-    }
-    else {
-        // In case paragraphs has to be rendered where vText is present. Eg. table-cell
-        // Or in case the vNode is something like img
-        if (isVNode(vNode) && vNode.tagName === 'img') {
-            const imageSource = vNode.properties.src;
-            let base64String = imageSource;
-            if (isValidUrl(imageSource)) {
-                base64String = yield imageToBase64(imageSource).catch((error) => {
-                    // eslint-disable-next-line no-console
-                    console.warning(`skipping image download and conversion due to ${error}`);
-                });
-                if (base64String && mimeTypes.lookup(imageSource)) {
-                    vNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
-                }
-                else {
-                    paragraphFragment.up();
-                    return paragraphFragment;
-                }
-            }
-            else {
-                // eslint-disable-next-line no-useless-escape, prefer-destructuring
-                base64String = base64String.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/)[2];
-            }
-            const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');
-            const imageProperties = sizeOf(imageBuffer);
-            modifiedAttributes.maximumWidth =
-                modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;
-            modifiedAttributes.originalWidth = imageProperties.width;
-            modifiedAttributes.originalHeight = imageProperties.height;
-            computeImageDimensions(vNode, modifiedAttributes);
-        }
-        const runFragments = yield buildRunOrRuns(vNode, modifiedAttributes, docxDocumentInstance);
-        if (Array.isArray(runFragments)) {
-            for (let index = 0; index < runFragments.length; index++) {
-                const runFragment = runFragments[index];
-                paragraphFragment.import(runFragment);
-            }
-        }
-        else {
-            paragraphFragment.import(runFragments);
-        }
-    }
-    paragraphFragment.up();
-    return paragraphFragment;
-});
-const 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 } = tableCellBorder, borders = __rest(tableCellBorder, ["color", "stroke"]);
-    Object.keys(borders).forEach((border) => {
-        if (tableCellBorder[border]) {
-            const borderFragment = buildBorder(border, tableCellBorder[border], 0, color, stroke);
-            tableCellBordersFragment.import(borderFragment);
-        }
-    });
-    tableCellBordersFragment.up();
-    return tableCellBordersFragment;
-};
-const 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 = Object.assign(Object.assign({}, attributes.tableCellBorder), { top: 0 });
-    }
-    else if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] !== '0') {
-        // eslint-disable-next-line no-use-before-define
-        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-top']);
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { top: borderSize, color: borderColor, stroke: borderStroke });
-    }
-    if (vNode.properties.style['border-left'] && vNode.properties.style['border-left'] === '0') {
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { left: 0 });
-    }
-    else if (vNode.properties.style['border-left'] &&
-        vNode.properties.style['border-left'] !== '0') {
-        // eslint-disable-next-line no-use-before-define
-        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-left']);
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { left: borderSize, color: borderColor, stroke: borderStroke });
-    }
-    if (vNode.properties.style['border-bottom'] && vNode.properties.style['border-bottom'] === '0') {
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { bottom: 0 });
-    }
-    else if (vNode.properties.style['border-bottom'] &&
-        vNode.properties.style['border-bottom'] !== '0') {
-        // eslint-disable-next-line no-use-before-define
-        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-bottom']);
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { bottom: borderSize, color: borderColor, stroke: borderStroke });
-    }
-    if (vNode.properties.style['border-right'] && vNode.properties.style['border-right'] === '0') {
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: 0 });
-    }
-    else if (vNode.properties.style['border-right'] &&
-        vNode.properties.style['border-right'] !== '0') {
-        // eslint-disable-next-line no-use-before-define
-        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-right']);
-        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: borderSize, color: borderColor, stroke: borderStroke });
-    }
-};
-const buildTableCell = (vNode, attributes, rowSpanMap, columnIndex, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    const tableCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
-    let modifiedAttributes = Object.assign({}, attributes);
-    if (isVNode(vNode) && vNode.properties) {
-        if (vNode.properties.rowSpan) {
-            rowSpanMap.set(columnIndex.index, { rowSpan: vNode.properties.rowSpan - 1, colSpan: 0 });
-            modifiedAttributes.rowSpan = 'restart';
-        }
-        else {
-            const previousSpanObject = rowSpanMap.get(columnIndex.index);
-            rowSpanMap.set(columnIndex.index, 
-            // eslint-disable-next-line prefer-object-spread
-            Object.assign({}, previousSpanObject, {
-                rowSpan: 0,
-                colSpan: (previousSpanObject && previousSpanObject.colSpan) || 0,
-            }));
-        }
-        if (vNode.properties.colSpan ||
-            (vNode.properties.style && vNode.properties.style['column-span'])) {
-            modifiedAttributes.colSpan =
-                vNode.properties.colSpan ||
-                    (vNode.properties.style && vNode.properties.style['column-span']);
-            const previousSpanObject = rowSpanMap.get(columnIndex.index);
-            rowSpanMap.set(columnIndex.index, 
-            // eslint-disable-next-line prefer-object-spread
-            Object.assign({}, previousSpanObject, {
-                colSpan: parseInt(modifiedAttributes.colSpan) || 0,
-            }));
-            columnIndex.index += parseInt(modifiedAttributes.colSpan) - 1;
-        }
-        if (vNode.properties.style) {
-            modifiedAttributes = Object.assign(Object.assign({}, modifiedAttributes), modifiedStyleAttributesBuilder(vNode, attributes));
-            fixupTableCellBorder(vNode, modifiedAttributes);
-        }
-    }
-    const tableCellPropertiesFragment = buildTableCellProperties(modifiedAttributes);
-    tableCellFragment.import(tableCellPropertiesFragment);
-    if (vNodeHasChildren(vNode)) {
-        for (let index = 0; index < vNode.children.length; index++) {
-            const childVNode = vNode.children[index];
-            if (isVNode(childVNode) && childVNode.tagName === 'img') {
-                const imageFragment = yield buildImage(docxDocumentInstance, childVNode, modifiedAttributes.maximumWidth);
-                if (imageFragment) {
-                    tableCellFragment.import(imageFragment);
-                }
-            }
-            else if (isVNode(childVNode) && childVNode.tagName === 'figure') {
-                if (vNodeHasChildren(childVNode)) {
-                    // eslint-disable-next-line no-plusplus
-                    for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
-                        const grandChildVNode = childVNode.children[iteratorIndex];
-                        if (grandChildVNode.tagName === 'img') {
-                            const imageFragment = yield buildImage(docxDocumentInstance, grandChildVNode, modifiedAttributes.maximumWidth);
-                            if (imageFragment) {
-                                tableCellFragment.import(imageFragment);
-                            }
-                        }
-                    }
-                }
-            }
-            else if (isVNode(childVNode) && ['ul', 'ol'].includes(childVNode.tagName)) {
-                // render list in table
-                if (vNodeHasChildren(childVNode)) {
-                    yield buildList(childVNode, docxDocumentInstance, tableCellFragment);
-                }
-            }
-            else {
-                const paragraphFragment = yield buildParagraph(childVNode, modifiedAttributes, docxDocumentInstance);
-                tableCellFragment.import(paragraphFragment);
-            }
-        }
-    }
-    else {
-        // TODO: Figure out why building with buildParagraph() isn't working
-        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
-            .ele('@w', 'p')
-            .up();
-        tableCellFragment.import(paragraphFragment);
-    }
-    tableCellFragment.up();
-    return tableCellFragment;
-});
-const buildRowSpanCell = (rowSpanMap, columnIndex, attributes) => {
-    const rowSpanCellFragments = [];
-    let spanObject = rowSpanMap.get(columnIndex.index);
-    while (spanObject && spanObject.rowSpan) {
-        const rowSpanCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
-        const tableCellPropertiesFragment = buildTableCellProperties(Object.assign(Object.assign({}, attributes), { rowSpan: 'continue', colSpan: spanObject.colSpan ? spanObject.colSpan : 0 }));
-        rowSpanCellFragment.import(tableCellPropertiesFragment);
-        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
-            .ele('@w', 'p')
-            .up();
-        rowSpanCellFragment.import(paragraphFragment);
-        rowSpanCellFragment.up();
-        rowSpanCellFragments.push(rowSpanCellFragment);
-        if (spanObject.rowSpan - 1 === 0) {
-            rowSpanMap.delete(columnIndex.index);
-        }
-        else {
-            rowSpanMap.set(columnIndex.index, {
-                rowSpan: spanObject.rowSpan - 1,
-                colSpan: spanObject.colSpan || 0,
-            });
-        }
-        columnIndex.index += spanObject.colSpan || 1;
-        spanObject = rowSpanMap.get(columnIndex.index);
-    }
-    return rowSpanCellFragments;
-};
-const 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 = (vNode, attributes, rowSpanMap, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    const tableRowFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tr');
-    const modifiedAttributes = Object.assign({}, attributes);
-    if (isVNode(vNode) && vNode.properties) {
-        // FIXME: find a better way to get row height from cell style
-        if ((vNode.properties.style && vNode.properties.style.height) ||
-            (vNode.children[0] &&
-                isVNode(vNode.children[0]) &&
-                vNode.children[0].properties.style &&
-                vNode.children[0].properties.style.height)) {
-            modifiedAttributes.tableRowHeight = fixupRowHeight((vNode.properties.style && vNode.properties.style.height) ||
-                (vNode.children[0] &&
-                    isVNode(vNode.children[0]) &&
-                    vNode.children[0].properties.style &&
-                    vNode.children[0].properties.style.height
-                    ? vNode.children[0].properties.style.height
-                    : undefined));
-        }
-        if (vNode.properties.style) {
-            fixupTableCellBorder(vNode, modifiedAttributes);
-        }
-    }
-    const tableRowPropertiesFragment = buildTableRowProperties(modifiedAttributes);
-    tableRowFragment.import(tableRowPropertiesFragment);
-    const columnIndex = { index: 0 };
-    if (vNodeHasChildren(vNode)) {
-        const tableColumns = vNode.children.filter((childVNode) => ['td', 'th'].includes(childVNode.tagName));
-        const maximumColumnWidth = docxDocumentInstance.availableDocumentSpace / tableColumns.length;
-        // eslint-disable-next-line no-restricted-syntax
-        for (const column of tableColumns) {
-            const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);
-            if (Array.isArray(rowSpanCellFragments)) {
-                for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {
-                    const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];
-                    tableRowFragment.import(rowSpanCellFragment);
-                }
-            }
-            const tableCellFragment = yield buildTableCell(column, Object.assign(Object.assign({}, modifiedAttributes), { maximumWidth: maximumColumnWidth }), rowSpanMap, columnIndex, docxDocumentInstance);
-            columnIndex.index++;
-            tableRowFragment.import(tableCellFragment);
-        }
-    }
-    if (columnIndex.index < rowSpanMap.size) {
-        const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);
-        if (Array.isArray(rowSpanCellFragments)) {
-            for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {
-                const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];
-                tableRowFragment.import(rowSpanCellFragment);
-            }
-        }
-    }
-    tableRowFragment.up();
-    return tableRowFragment;
-});
-const 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 } = tableBorder, borders = __rest(tableBorder, ["color", "stroke"]);
-    Object.keys(borders).forEach((border) => {
-        if (borders[border]) {
-            const borderFragment = buildBorder(border, borders[border], 0, color, stroke);
-            tableBordersFragment.import(borderFragment);
-        }
-    });
-    tableBordersFragment.up();
-    return tableBordersFragment;
-};
-const 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 = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
-    const tableFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tbl');
-    const modifiedAttributes = Object.assign({}, attributes);
-    if (isVNode(vNode) && vNode.properties) {
-        const tableAttributes = vNode.properties.attributes || {};
-        const tableStyles = vNode.properties.style || {};
-        const tableBorders = {};
-        const tableCellBorders = {};
-        let [borderSize, borderStrike, borderColor] = [2, 'single', '000000'];
-        // eslint-disable-next-line no-restricted-globals
-        if (!isNaN(tableAttributes.border)) {
-            borderSize = parseInt(tableAttributes.border, 10);
-        }
-        // css style overrides table border properties
-        if (tableStyles.border) {
-            const [cssSize, cssStroke, cssColor] = cssBorderParser(tableStyles.border);
-            borderSize = cssSize || borderSize;
-            borderColor = cssColor || borderColor;
-            borderStrike = cssStroke || borderStrike;
-        }
-        tableBorders.top = borderSize;
-        tableBorders.bottom = borderSize;
-        tableBorders.left = borderSize;
-        tableBorders.right = borderSize;
-        tableBorders.stroke = borderStrike;
-        tableBorders.color = borderColor;
-        if (tableStyles['border-collapse'] === 'collapse') {
-            tableBorders.insideV = borderSize;
-            tableBorders.insideH = borderSize;
-        }
-        else {
-            tableBorders.insideV = 0;
-            tableBorders.insideH = 0;
-            tableCellBorders.top = 1;
-            tableCellBorders.bottom = 1;
-            tableCellBorders.left = 1;
-            tableCellBorders.right = 1;
-        }
-        modifiedAttributes.tableBorder = tableBorders;
-        modifiedAttributes.tableCellSpacing = 0;
-        if (Object.keys(tableCellBorders).length) {
-            modifiedAttributes.tableCellBorder = tableCellBorders;
-        }
-        let minimumWidth;
-        let maximumWidth;
-        let width;
-        // Calculate minimum width of table
-        if (pixelRegex.test(tableStyles['min-width'])) {
-            minimumWidth = pixelToTWIP(tableStyles['min-width'].match(pixelRegex)[1]);
-        }
-        else if (percentageRegex.test(tableStyles['min-width'])) {
-            const percentageValue = tableStyles['min-width'].match(percentageRegex)[1];
-            minimumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);
-        }
-        // Calculate maximum width of table
-        if (pixelRegex.test(tableStyles['max-width'])) {
-            pixelRegex.lastIndex = 0;
-            maximumWidth = pixelToTWIP(tableStyles['max-width'].match(pixelRegex)[1]);
-        }
-        else if (percentageRegex.test(tableStyles['max-width'])) {
-            percentageRegex.lastIndex = 0;
-            const percentageValue = tableStyles['max-width'].match(percentageRegex)[1];
-            maximumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);
-        }
-        // Calculate specified width of table
-        if (pixelRegex.test(tableStyles.width)) {
-            pixelRegex.lastIndex = 0;
-            width = pixelToTWIP(tableStyles.width.match(pixelRegex)[1]);
-        }
-        else if (percentageRegex.test(tableStyles.width)) {
-            percentageRegex.lastIndex = 0;
-            const percentageValue = tableStyles.width.match(percentageRegex)[1];
-            width = Math.round((percentageValue / 100) * attributes.maximumWidth);
-        }
-        // If width isn't supplied, we should have min-width as the width.
-        if (width) {
-            modifiedAttributes.width = width;
-            if (maximumWidth) {
-                modifiedAttributes.width = Math.min(modifiedAttributes.width, maximumWidth);
-            }
-            if (minimumWidth) {
-                modifiedAttributes.width = Math.max(modifiedAttributes.width, minimumWidth);
-            }
-        }
-        else if (minimumWidth) {
-            modifiedAttributes.width = minimumWidth;
-        }
-        if (modifiedAttributes.width) {
-            modifiedAttributes.width = Math.min(modifiedAttributes.width, attributes.maximumWidth);
-        }
-    }
-    const tablePropertiesFragment = buildTableProperties(modifiedAttributes);
-    tableFragment.import(tablePropertiesFragment);
-    const rowSpanMap = new Map();
-    if (vNodeHasChildren(vNode)) {
-        for (let index = 0; index < vNode.children.length; index++) {
-            const childVNode = vNode.children[index];
-            if (childVNode.tagName === 'colgroup') {
-                const tableGridFragment = buildTableGrid(childVNode, modifiedAttributes);
-                tableFragment.import(tableGridFragment);
-            }
-            else if (childVNode.tagName === 'thead') {
-                for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
-                    const grandChildVNode = childVNode.children[iteratorIndex];
-                    if (grandChildVNode.tagName === 'tr') {
-                        if (iteratorIndex === 0) {
-                            const tableGridFragment = buildTableGridFromTableRow(grandChildVNode, modifiedAttributes);
-                            tableFragment.import(tableGridFragment);
-                        }
-                        const tableRowFragment = yield buildTableRow(grandChildVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
-                        tableFragment.import(tableRowFragment);
-                    }
-                }
-            }
-            else if (childVNode.tagName === 'tbody') {
-                for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
-                    const grandChildVNode = childVNode.children[iteratorIndex];
-                    if (grandChildVNode.tagName === 'tr') {
-                        if (iteratorIndex === 0) {
-                            const tableGridFragment = buildTableGridFromTableRow(grandChildVNode, modifiedAttributes);
-                            tableFragment.import(tableGridFragment);
-                        }
-                        const tableRowFragment = yield buildTableRow(grandChildVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
-                        tableFragment.import(tableRowFragment);
-                    }
-                }
-            }
-            else if (childVNode.tagName === 'tr') {
-                if (index === 0) {
-                    const tableGridFragment = buildTableGridFromTableRow(childVNode, modifiedAttributes);
-                    tableFragment.import(tableGridFragment);
-                }
-                const tableRowFragment = yield buildTableRow(childVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
-                tableFragment.import(tableRowFragment);
-            }
-        }
-    }
-    tableFragment.up();
-    return tableFragment;
-});
-const 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 = (docxDocumentInstance, vNode, maximumWidth = null) => __awaiter(void 0, void 0, void 0, function* () {
-    let response = null;
-    let base64Uri = null;
-    try {
-        const imageSource = vNode.properties.src;
-        if (isValidUrl(imageSource)) {
-            const base64String = yield 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 = yield xmlBuilder.buildParagraph(vNode, Object.assign(Object.assign({ type: 'picture', inlineOrAnchored: true, relationshipId: documentRelsId }, response), { maximumWidth: maximumWidth || docxDocumentInstance.availableDocumentSpace, originalWidth: imageProperties.width, originalHeight: imageProperties.height }), docxDocumentInstance);
-        return imageFragment;
-    }
-});
-const buildList = (vNode, docxDocumentInstance, xmlFragment) => __awaiter(void 0, void 0, void 0, function* () {
-    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 = yield 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;
-});
-
-const convertHTML$1 = HTMLToVDOM({
-    VNode: VNode$1,
-    VText,
-});
-function findXMLEquivalent(docxDocumentInstance, vNode, xmlFragment) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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 = yield 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 = yield 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 = yield buildTable(childVNode, {
-                                maximumWidth: docxDocumentInstance.availableDocumentSpace,
-                                rowCantSplit: docxDocumentInstance.tableRowCantSplit,
-                            }, docxDocumentInstance);
-                            xmlFragment.import(tableFragment);
-                            // Adding empty paragraph for space after table
-                            const emptyParagraphFragment = yield buildParagraph(null, {});
-                            xmlFragment.import(emptyParagraphFragment);
-                        }
-                        else if (childVNode.tagName === 'img') {
-                            const imageFragment = yield buildImage(docxDocumentInstance, childVNode);
-                            if (imageFragment) {
-                                xmlFragment.import(imageFragment);
-                            }
-                        }
-                    }
-                }
-                return;
-            case 'table':
-                const tableFragment = yield buildTable(vNode, {
-                    maximumWidth: docxDocumentInstance.availableDocumentSpace,
-                    rowCantSplit: docxDocumentInstance.tableRowCantSplit,
-                }, docxDocumentInstance);
-                xmlFragment.import(tableFragment);
-                // Adding empty paragraph for space after table
-                const emptyParagraphFragment = yield buildParagraph(null, {});
-                xmlFragment.import(emptyParagraphFragment);
-                return;
-            case 'ol':
-            case 'ul':
-                yield buildList(vNode, docxDocumentInstance, xmlFragment);
-                return;
-            case 'img':
-                const imageFragment = yield buildImage(docxDocumentInstance, vNode);
-                if (imageFragment) {
-                    xmlFragment.import(imageFragment);
-                }
-                return;
-            case 'br':
-                const linebreakFragment = yield 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
-                yield convertVTreeToXML(docxDocumentInstance, childVNode, xmlFragment);
-            }
-        }
-    });
-}
-// eslint-disable-next-line consistent-return
-function convertVTreeToXML(docxDocumentInstance, vTree, xmlFragment) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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];
-                yield convertVTreeToXML(docxDocumentInstance, vNode, xmlFragment);
-            }
-        }
-        else if (isVNode(vTree)) {
-            yield findXMLEquivalent(docxDocumentInstance, vTree, xmlFragment);
-        }
-        else if (isVText(vTree)) {
-            buildTextElement(xmlFragment, escape(String(vTree.text)));
-        }
-        return xmlFragment;
-    });
-}
-function renderDocumentFile(docxDocumentInstance) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const vTree = convertHTML$1(docxDocumentInstance.htmlString);
-        const xmlFragment = fragment({ namespaceAlias: { w: namespaces.w } });
-        const populatedXmlFragment = yield 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 });
-}
-function generateSectionXML(vTree, type = 'header') {
-    return __awaiter(this, void 0, void 0, function* () {
-        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();
-        yield 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) => (Object.assign(Object.assign({}, 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 = Object.assign({}, 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
-function addFilesToContainer(zip, htmlString, suppliedDocumentOptions, headerHTMLString, footerHTMLString) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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(Object.assign({ zip, htmlString }, documentOptions));
-        // Conversion to Word XML happens here
-        docxDocument.documentXML = yield 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 } = yield 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 } = yield 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;
-    });
-}
-
-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;
-    }
-};
-function generateContainer(htmlString, headerHTMLString, documentOptions = {}, footerHTMLString) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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);
-        }
-        yield addFilesToContainer(zip, contentHTML, documentOptions, headerHTML, footerHTML);
-        const buffer = yield 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 {
-    generateWordByteFile(model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = yield generateContainer(model.body, model.header, documentOptions, model.footer);
-            return fileBuffer;
-        });
-    }
-}
-WordDocumentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WordDocumentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-WordDocumentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WordDocumentService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WordDocumentService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-const TOKEN_KEY = 'access_token';
-class AuthService {
-    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();
-        this.user = this.getUserManager();
-    }
-    hasToken() {
-        const token = this.cookieService.get(TOKEN_KEY);
-        return token && !this.jwtHelper.isTokenExpired(token);
-    }
-    getUserManager() {
-        const token = this.cookieService.get(TOKEN_KEY);
-        if (token)
-            this.handleAccessTokenWithoutLanguage(token);
-        return AuthService.user;
-    }
-    getUser() {
-        this.user = AuthService.user;
-    }
-    storUser(User) {
-        AuthService.user = this.user = this.user;
-    }
-    getCurrentUser() {
-        return AuthService.user;
-    }
-    isAuthenticated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return AuthService.user != null && !this.jwtHelper.isTokenExpired(AuthService.user.access_token);
-        });
-    }
-    isUserInRole(allowedPermission) {
-        let selectedPermissionSetID = Number.parseInt(this.user.profile['selectedpermissionsetid']);
-        return allowedPermission.includes(selectedPermissionSetID);
-    }
-    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() {
-        var _a;
-        return (_a = localStorage.getItem('redirectUrl')) !== null && _a !== void 0 ? _a : "/";
-    }
-    signOut() {
-        AuthService.timers.map(t => clearInterval(t));
-        AuthService.timers = [];
-        if (!this.isAuthenticated()) {
-            this.cookieService.delete(TOKEN_KEY);
-            this.router.navigate(['/Admin/account/login']);
-        }
-        this.logout().subscribe(res => {
-            this.cookieService.delete(TOKEN_KEY);
-            if (this.environmentService.getBBSFAuthenticationMode() == AuthenticationModes.UAEPass)
-                this.logoutFromUAEPass();
-            else
-                this.router.navigate(['/Admin/account/login']);
-        });
-    }
-    logout() {
-        const httpOptions = {
-            headers: new HttpHeaders({
-                'Content-Type': 'application/json',
-            }),
-        };
-        let ApiUrl = '/Account/';
-        return this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'Logout', httpOptions);
-    }
-    clearUserSessionClaims() {
-        const httpOptions = {
-            headers: new HttpHeaders({
-                'Content-Type': 'application/json',
-            }),
-        };
-        let ApiUrl = '/api/Home/';
-        return this.http.get(this.environmentService.getBaseUrl() + ApiUrl + 'ClearCurrentUserSession', httpOptions);
-    }
-    handleAccessToken(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = response;
-            AuthService.user = new User();
-            AuthService.user.token_type = "Bearer";
-            AuthService.user.access_token = token;
-            AuthService.user.profile = this.jwtHelper.decodeToken(token);
-            AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
-            AuthService.timers.map(t => clearInterval(t));
-            AuthService.timers = [];
-            this.setTokenSeconds();
-            AuthService.timers.push(this.checkRefreshToken());
-            this.user = AuthService.user;
-            yield this.updateLanguage();
-            this.cookieService.set(TOKEN_KEY, token, null, null, null, true, 'Strict');
-            this.isAuthenticatedSubject.next(true);
-        });
-    }
-    handleAccessTokenWithoutLanguage(response) {
-        const token = response;
-        AuthService.user = new User();
-        AuthService.user.token_type = "Bearer";
-        AuthService.user.access_token = token;
-        AuthService.user.profile = this.jwtHelper.decodeToken(token);
-        AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
-        this.setTokenSeconds();
-        this.user = AuthService.user;
-        this.cookieService.set(TOKEN_KEY, token, null, null, null, true, 'Strict');
-        this.isAuthenticatedSubject.next(true);
-    }
-    updateLanguage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!localStorage.getItem('language') ||
-                localStorage.getItem('language') == this.user.profile.locale)
-                localStorage.setItem('language', this.user.profile.locale);
-            if (this.translateService.currentLang != localStorage.getItem('language')) {
-                this.translateService.resetLang(this.translateService.currentLang);
-                yield this.translateService
-                    .reloadLang(localStorage.getItem('language'))
-                    .subscribe((res) => {
-                    console.log(res);
-                });
-            }
-        });
-    }
-    checkRefreshToken() {
-        let date = new Date();
-        return setInterval(() => {
-            if (Math.floor(AuthService.seconds) < 120 && this.isAuthenticated())
-                this.refresh();
-            AuthService.seconds--;
-        }, 1000);
-    }
-    setTokenSeconds() {
-        let date = new Date();
-        AuthService.seconds = (AuthService.user.expires_at - date) / 1000;
-    }
-    refresh() {
-        const httpOptions = {
-            headers: new HttpHeaders({
-                'Content-Type': 'application/json',
-                'Authorization': this.authorizationHeaderValue(),
-            }),
-        };
-        let ApiUrl = '/api/Home/';
-        this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'RefreshAccessToken', httpOptions).subscribe((res) => {
-            this.cookieService.delete(TOKEN_KEY);
-            this.handleAccessTokenWithoutLanguage(res.val);
-        });
-    }
-    loginWithUAEPass() {
-        const authEndpoint = `${this.environmentService.getUAEPassBaseUrl()}${this.environmentService.getUAEPassAuthorizationEndPoint()}`;
-        const queryParams = {
-            response_type: 'code',
-            client_id: `${this.environmentService.getUAEPassClientID()}`,
-            redirect_uri: `${this.environmentService.getBaseUrl()}${this.environmentService.getUAEPassRedirectUrl()}`,
-            scope: 'urn:uae:digitalid:profile:general urn:uae:digitalid:profile:general:profileType urn:uae:digitalid:profile:general:unifiedId',
-            state: 'pd3PgezRwk596u2yfRwqOgru',
-            acr_values: 'urn:safelayer:tws:policies:authentication:level:low'
-        };
-        const queryParamsString = Object.entries(queryParams)
-            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-            .join('&');
-        const loginUrl = `${authEndpoint}?${queryParamsString}`;
-        window.location.href = loginUrl;
-        return;
-    }
-    logoutFromUAEPass() {
-        const logoutEndpoint = `${this.environmentService.getUAEPassBaseUrl()}${this.environmentService.getUAEPassLogoutEndPoint()}`;
-        const queryParams = {
-            redirect_uri: `${this.environmentService.getBaseUrl()}`,
-        };
-        const queryParamsString = Object.entries(queryParams)
-            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-            .join('&');
-        const logoutUrl = `${logoutEndpoint}?${queryParamsString}`;
-        window.location.href = logoutUrl;
-        return;
-    }
-}
-AuthService.user = null;
-AuthService.UserClaims = null;
-//refresh
-AuthService.timers = [];
-AuthService.seconds = 0;
-AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", 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 });
-AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.HttpClient }, { type: EnvironmentService }, { type: BBSFTranslateService }, { type: i1$1.Router }, { type: i4$1.CookieService }, { type: UtilityService }]; } });
-
-class BBSFUtilitiesModule {
-}
-BBSFUtilitiesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-BBSFUtilitiesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, imports: [CommonModule,
-        RouterModule, i1$2.BlockUIModule, i2.ToastrModule] });
-BBSFUtilitiesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, providers: [
-        UtilityService,
-        EnvironmentService,
-        AuthService,
-        RequestHandlerService,
-        StylesBundleService,
-        TranslateService,
-        BBSFTranslateService,
-        ControlValidationService,
-        MasterLayoutService,
-        ConfigurationService,
-        CookieService
-    ], imports: [CommonModule,
-        RouterModule,
-        BlockUIModule.forRoot(),
-        ToastrModule.forRoot()] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [
-                        CommonModule,
-                        RouterModule,
-                        BlockUIModule.forRoot(),
-                        ToastrModule.forRoot(),
-                    ],
-                    exports: [],
-                    providers: [
-                        UtilityService,
-                        EnvironmentService,
-                        AuthService,
-                        RequestHandlerService,
-                        StylesBundleService,
-                        TranslateService,
-                        BBSFTranslateService,
-                        ControlValidationService,
-                        MasterLayoutService,
-                        ConfigurationService,
-                        CookieService
-                    ]
-                }]
-        }] });
-
-/*
- * Public API Surface of @bnsights/bbsf-utilities
- */
-//Module
-//#endregion
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AppearanceConfigurationService, AuthService, AuthenticationModes, BBSFTranslateService, BBSFUtilitiesModule, ConfigurationService, ControlValidationService, DocumentOptionsModel, EnvironmentService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, StylesBundleService, TranslationResolverService, UtilityService, WordDocumentModel, WordDocumentService, environment };
-//# sourceMappingURL=bnsights-bbsf-utilities.mjs.map