@bnsights/bbsf-utilities 1.0.32 → 1.0.33

package/fesm2015/bnsights-bbsf-utilities.js

@@ -0,0 +1,4634 @@
+import * as i1$1 from '@angular/common';
+import { DOCUMENT, CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Injectable, Inject, Injector, NgModule } from '@angular/core';
+import * as i1$2 from '@angular/router';
+import { Router, RouterModule } from '@angular/router';
+import * as i1 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BlockUI, BlockUIModule } from 'ng-block-ui';
+import { ToastrService, ToastrModule } from 'ngx-toastr';
+import { HttpModule } from '@angular/http';
+import { __awaiter, __decorate, __rest } from 'tslib';
+import * as i1$3 from '@angular/common/http';
+import { HttpHeaders, HttpClient, HttpParams } from '@angular/common/http';
+import { UserManager, WebStorageStateStore } from 'oidc-client';
+import { Subject, Observable, throwError, BehaviorSubject } from 'rxjs';
+import { takeUntil, tap, map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import JSZip from 'jszip';
+import { fragment, create } from 'xmlbuilder2';
+import VNode 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 sizeOf from 'image-size';
+import imageToBase64 from 'image-to-base64';
+import mimeTypes from 'mime-types';
+import colorNames from 'color-name';
+
+// 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() {
+        let Url = environment["BBSF_BaseURL"];
+        return Url;
+    }
+    getApiUrl() {
+        let Url = environment["BBSF_ApiUrl"];
+        return Url;
+    }
+    getProductionMode() {
+        let Mode = environment["BBSF_IsProduction"];
+        return Mode;
+    }
+    getDefaultLanguage() {
+        let Mode = environment["BBSF_DefaultLanguage"];
+        return Mode;
+    }
+    getIdentityServerUrl() {
+        let Url = environment["BBSF_IdentityServerUrl"];
+        return Url;
+    }
+    getIsIdentityServerExternal() {
+        let Mode = environment["BBSF_IsExternalIdentityServer"];
+        return Mode;
+    }
+    getIsIdentityServerClientId() {
+        let Mode = environment["BBSF_IdentityServer_Client_Id"];
+        return Mode;
+    }
+    getIsIdentityServerClientSecret() {
+        let Mode = environment["BBSF_IdentityServer_Client_Secret"];
+        return Mode;
+    }
+}
+EnvironmentService.AreaList = [];
+EnvironmentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnvironmentService_Factory() { return new EnvironmentService(); }, token: EnvironmentService, providedIn: "root" });
+EnvironmentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+
+class BBSFTranslateService extends TranslateService {
+}
+BBSFTranslateService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BBSFTranslateService_Factory() { return new BBSFTranslateService(i0.ɵɵinject(i1.TranslateStore), i0.ɵɵinject(i1.TranslateLoader), i0.ɵɵinject(i1.TranslateCompiler), i0.ɵɵinject(i1.TranslateParser), i0.ɵɵinject(i1.MissingTranslationHandler), i0.ɵɵinject(i1.USE_DEFAULT_LANG), i0.ɵɵinject(i1.USE_STORE), i0.ɵɵinject(i1.USE_EXTEND), i0.ɵɵinject(i1.DEFAULT_LANGUAGE)); }, token: BBSFTranslateService, providedIn: "root" });
+BBSFTranslateService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+
+class RequestOptionsModel {
+    constructor() {
+        this.disableSuccessNotification = false;
+        this.disableBlockUI = false;
+        this.disableErrorHandler = false;
+        this.responseType = "";
+        this.formGroup = null;
+        this.castResponsetoClass = true;
+    }
+}
+
+class RequestHandlerService {
+    constructor(http, authService, environmentService, utilityService, bbsfTranslateService, router) {
+        //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor
+        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();
+        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();
+        let object;
+        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.decorators = [
+    { type: Injectable }
+];
+RequestHandlerService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: AuthService },
+    { type: EnvironmentService },
+    { type: UtilityService },
+    { type: BBSFTranslateService },
+    { type: 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.ɵprov = i0.ɵɵdefineInjectable({ factory: function StylesBundleService_Factory() { return new StylesBundleService(i0.ɵɵinject(i1$1.DOCUMENT), i0.ɵɵinject(BBSFTranslateService)); }, token: StylesBundleService, providedIn: "root" });
+StylesBundleService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+StylesBundleService.ctorParameters = () => [
+    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: BBSFTranslateService }
+];
+
+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.getUser();
+                this.authService.user.profile = Object.assign(this.authService.user.profile, UserInfoObject);
+                this.authService.storUser(this.authService.user);
+                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);
+    }
+    getUserClaims() {
+        return this.http.get(this.ApiUrl + 'GetUserClaims', null, null);
+    }
+    logError(error) {
+        let params = new HttpParams();
+        params = params.append('error', error);
+        return this.http.post(this.ApiUrl + 'LogError', null, null, params);
+    }
+    updateUserInfo() {
+        let isExternal = this.environmentService.getIsIdentityServerExternal().toLowerCase() == 'true';
+        if (isExternal)
+            return this.getUserClaims();
+        return this.http.get('/connect/userinfo');
+    }
+    switchRole(permissionSetID) {
+        this.updateRole(permissionSetID).subscribe((result) => {
+            this.updateUserInfo().subscribe((Value) => {
+                let UserInfoObject = Value;
+                this.authService.getUser();
+                this.authService.user.profile = Object.assign(this.authService.user.profile, UserInfoObject);
+                this.authService.storUser(this.authService.user);
+            });
+        });
+    }
+    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.ɵprov = i0.ɵɵdefineInjectable({ factory: function MasterLayoutService_Factory() { return new MasterLayoutService(i0.ɵɵinject(i1$2.Router), i0.ɵɵinject(RequestHandlerService), i0.ɵɵinject(AuthService), i0.ɵɵinject(StylesBundleService), i0.ɵɵinject(i1.TranslateService), i0.ɵɵinject(EnvironmentService)); }, token: MasterLayoutService, providedIn: "root" });
+MasterLayoutService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+MasterLayoutService.ctorParameters = () => [
+    { type: Router },
+    { type: RequestHandlerService },
+    { type: AuthService },
+    { type: StylesBundleService },
+    { type: TranslateService },
+    { type: EnvironmentService }
+];
+
+class AuthService {
+    constructor(injector, http, environmentService, translateService, router) {
+        this.injector = injector;
+        this.http = http;
+        this.environmentService = environmentService;
+        this.translateService = translateService;
+        this.router = router;
+        // Observable navItem source
+        this._authNavStatusSource = new BehaviorSubject(false);
+        // Observable navItem stream
+        this.authNavStatus$ = this._authNavStatusSource.asObservable();
+        // Observable navItem source
+        this._userSource = new Subject();
+        this.UserStatus$ = this._userSource.asObservable();
+        this.manager = this.getUserManager();
+        this.redirectUrl = '';
+        this.manager.getUser().then((user) => __awaiter(this, void 0, void 0, function* () {
+            this.manager.storeUser(user);
+            AuthService.user = user;
+            this.user = user;
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+        }));
+        this.manager.events.addAccessTokenExpired((_) => {
+            this._authNavStatusSource.next(false);
+        });
+    }
+    getUserManager() {
+        let user = null;
+        let isExternal = this.environmentService.getIsIdentityServerExternal().toLowerCase() ==
+            'true';
+        if (isExternal) {
+            user = new UserManager({
+                authority: this.environmentService.getIdentityServerUrl(),
+                client_id: this.environmentService.getIsIdentityServerClientId(),
+                client_secret: this.environmentService.getIsIdentityServerClientSecret(),
+                redirect_uri: this.environmentService.getBaseUrl() +
+                    '/Admin/authentication/auth-callback',
+                post_logout_redirect_uri: this.environmentService.getBaseUrl(),
+                response_type: 'code',
+                scope: 'openid profile email',
+                filterProtocolClaims: true,
+                loadUserInfo: true,
+                automaticSilentRenew: true,
+                silent_redirect_uri: this.environmentService.getBaseUrl() + '/assets/silent-callback.html',
+                userStore: new WebStorageStateStore({ store: window.localStorage }),
+            });
+        }
+        else {
+            user = new UserManager({
+                authority: this.environmentService.getIdentityServerUrl(),
+                client_id: 'angular_spa',
+                redirect_uri: this.environmentService.getBaseUrl() +
+                    '/Admin/authentication/auth-callback',
+                post_logout_redirect_uri: this.environmentService.getBaseUrl(),
+                response_type: 'id_token token',
+                scope: 'openid profile email IdentityServerApi',
+                filterProtocolClaims: true,
+                loadUserInfo: true,
+                automaticSilentRenew: true,
+                silent_redirect_uri: this.environmentService.getBaseUrl() + '/assets/silent-callback.html',
+                userStore: new WebStorageStateStore({ store: window.localStorage }),
+            });
+        }
+        return user;
+    }
+    login() {
+        return this.manager.signinRedirect();
+    }
+    getUser() {
+        this.manager.getUser().then((user) => __awaiter(this, void 0, void 0, function* () {
+            AuthService.user = user;
+            this.user = user;
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+        }));
+    }
+    storUser(User) {
+        this.manager.storeUser(User);
+    }
+    revokeAccessToken() {
+        this.manager.revokeAccessToken();
+    }
+    signinSilent() {
+        let x = this.manager.signinSilentCallback();
+        x.then((s) => {
+            //console.log(s)
+        });
+    }
+    completeAuthentication() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.user = yield this.manager.signinRedirectCallback();
+            AuthService.user = this.user;
+            this._userSource.next(AuthService.user);
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+            let isExternal = this.environmentService.getIsIdentityServerExternal().toLowerCase() ==
+                'true';
+            if (isExternal) {
+                const masterLayoutService = this.injector.get(MasterLayoutService);
+                let userClaims = yield masterLayoutService
+                    .getUserClaims()
+                    .toPromise()
+                    .then((e) => {
+                    AuthService.UserClaims = e;
+                }, (error) => {
+                    console.log(error);
+                });
+                AuthService.user.profile = Object.assign(AuthService.user.profile, AuthService.UserClaims);
+            }
+            this.storUser(AuthService.user);
+            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);
+                });
+            }
+            this._userSource.next(AuthService.user);
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+            this.user = AuthService.user;
+        });
+    }
+    refreshToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    Authorization: token,
+                }),
+            };
+            this.manager.revokeAccessToken();
+            return yield this.http
+                .post(`${this.environmentService.getIdentityServerUrl()}/users/refresh-token`, httpOptions, { withCredentials: true })
+                .subscribe((user) => {
+                this._userSource.next(user);
+                AuthService.user = user;
+                this.user = user;
+            });
+        });
+    }
+    getCurrentUser() {
+        return this.manager.getUser();
+    }
+    isAuthenticated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = yield this.manager.getUser().then((user) => {
+                return user;
+            });
+            return this.user != null && !this.user.expired;
+        });
+    }
+    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() {
+        return localStorage.getItem('redirectUrl');
+    }
+    signinSilentCallback() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = yield this.manager.signinSilentCallback();
+            //await this.manager.storeUser(user);
+            AuthService.user = user;
+            console.log('Token from  signinSilentCallback :' + AuthService.user);
+            this.user = user;
+        });
+    }
+    signout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield !this.isAuthenticated())
+                this.router.navigate(['/Admin/account/login']), localStorage.clear();
+            let isExternal = this.environmentService.getIsIdentityServerExternal().toLowerCase() ==
+                'true';
+            if (isExternal) {
+                yield this.clearUserSessionClaims()
+                    .toPromise()
+                    .then((res) => {
+                    let result = res;
+                });
+            }
+            yield this.manager.signoutRedirect();
+        });
+    }
+    clearUserSessionClaims() {
+        const httpOptions = {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+            }),
+        };
+        let ApiUrl = '/api/Home/';
+        return this.http.get(this.environmentService.getBaseUrl() + ApiUrl + 'ClearCurrentUserSession', httpOptions);
+    }
+}
+AuthService.user = null;
+AuthService.UserClaims = null;
+AuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1$3.HttpClient), i0.ɵɵinject(EnvironmentService), i0.ɵɵinject(BBSFTranslateService), i0.ɵɵinject(i1$2.Router)); }, token: AuthService, providedIn: "root" });
+AuthService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+AuthService.ctorParameters = () => [
+    { type: Injector },
+    { type: HttpClient },
+    { type: EnvironmentService },
+    { type: BBSFTranslateService },
+    { type: Router }
+];
+
+class UtilityService {
+    constructor(translator, authService, environmentService) {
+        this.translator = translator;
+        this.authService = authService;
+        this.environmentService = environmentService;
+        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 = AppInjector.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 = AppInjector.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 = AppInjector.get(ToastrService);
+        showHeader ? toaster.warning(MessageTemplate, titleTemplate) : toaster.warning(MessageTemplate);
+    }
+    startBlockUI() {
+        this.blockUI.start();
+    }
+    stopBlockUI() {
+        this.blockUI.stop();
+    }
+}
+UtilityService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UtilityService_Factory() { return new UtilityService(i0.ɵɵinject(BBSFTranslateService), i0.ɵɵinject(AuthService), i0.ɵɵinject(EnvironmentService)); }, token: UtilityService, providedIn: "root" });
+UtilityService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UtilityService.ctorParameters = () => [
+    { type: BBSFTranslateService },
+    { type: AuthService },
+    { type: EnvironmentService }
+];
+__decorate([
+    BlockUI()
+], UtilityService.prototype, "blockUI", void 0);
+
+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 {
+            elementToAppend.innerHTML = "<ul>";
+            for (const iterator of errorMessage) {
+                elementToAppend.innerHTML = "<li>" + iterator + "</li>";
+            }
+            elementToAppend.innerHTML = "</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);
+        }
+        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;
+        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}`);
+                // this.showGlobalError(`${fieldName}: ${message}`,formId )
+            }
+            else {
+                this.setFieldError(form, controlName, fieldName, message);
+            }
+        });
+        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 = form.get(controlName);
+        else
+            control = form.get(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 if (fieldNameArray.length == 1) {
+            control.setErrors(errors);
+        }
+        else {
+            this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
+        }
+    }
+}
+ControlValidationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ControlValidationService_Factory() { return new ControlValidationService(i0.ɵɵinject(UtilityService)); }, token: ControlValidationService, providedIn: "root" });
+ControlValidationService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ControlValidationService.ctorParameters = () => [
+    { type: UtilityService }
+];
+__decorate([
+    BlockUI()
+], ControlValidationService.prototype, "blockUI", void 0);
+
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function ConfigurationService_Factory() { return new ConfigurationService(i0.ɵɵinject(i1$3.HttpClient)); }, token: ConfigurationService, providedIn: "root" });
+ConfigurationService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ConfigurationService.ctorParameters = () => [
+    { type: HttpClient }
+];
+
+let AppInjector;
+class BBSFUtilitiesModule {
+    constructor(injector) {
+        this.injector = injector;
+        AppInjector = this.injector;
+    }
+}
+BBSFUtilitiesModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                imports: [
+                    CommonModule,
+                    BlockUIModule.forRoot(),
+                    HttpModule,
+                    RouterModule,
+                    ToastrModule.forRoot(),
+                ],
+                exports: [],
+                providers: [
+                    UtilityService,
+                    EnvironmentService,
+                    AuthService,
+                    RequestHandlerService,
+                    StylesBundleService,
+                    TranslateService,
+                    BBSFTranslateService,
+                    ControlValidationService,
+                    MasterLayoutService,
+                    ConfigurationService
+                ]
+            },] }
+];
+BBSFUtilitiesModule.ctorParameters = () => [
+    { type: Injector }
+];
+
+class TranslationResolverService {
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    resolve() {
+        return this.translateService.getTranslation(this.translateService.currentLang);
+    }
+}
+TranslationResolverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TranslationResolverService_Factory() { return new TranslationResolverService(i0.ɵɵinject(BBSFTranslateService)); }, token: TranslationResolverService, providedIn: "root" });
+TranslationResolverService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+TranslationResolverService.ctorParameters = () => [
+    { type: BBSFTranslateService }
+];
+
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function AppearanceConfigurationService_Factory() { return new AppearanceConfigurationService(i0.ɵɵinject(ConfigurationService)); }, token: AppearanceConfigurationService, providedIn: "root" });
+AppearanceConfigurationService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+AppearanceConfigurationService.ctorParameters = () => [
+    { type: ConfigurationService }
+];
+
+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 ɵ0$8 = generateCoreXML;
+
+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 ɵ0$7 = generateNumberingXMLTemplate;
+
+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 ɵ0$6 = generateStylesXML;
+
+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 ɵ0$5 = generateThemeXML;
+
+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 ɵ0$4 = generateDocumentTemplate;
+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));
+};
+const ɵ0$3 = isValidUrl;
+
+// eslint-disable-next-line consistent-return
+const fixupColorCode = (colorCodeString) => {
+    if (Object.prototype.hasOwnProperty.call(colorNames, colorCodeString.toLowerCase())) {
+        const [red, green, blue] = colorNames[colorCodeString.toLowerCase()];
+        return rgbToHex(red, green, blue);
+    }
+    else if (rgbRegex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(rgbRegex);
+        const red = matchedParts[1];
+        const green = matchedParts[2];
+        const blue = matchedParts[3];
+        return rgbToHex(red, green, blue);
+    }
+    else if (hslRegex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(hslRegex);
+        const hue = matchedParts[1];
+        const saturation = matchedParts[2];
+        const luminosity = matchedParts[3];
+        return hslToHex(hue, saturation, luminosity);
+    }
+    else if (hexRegex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(hexRegex);
+        return matchedParts[1];
+    }
+    else if (hex3Regex.test(colorCodeString)) {
+        const matchedParts = colorCodeString.match(hex3Regex);
+        const red = matchedParts[1];
+        const green = matchedParts[2];
+        const blue = matchedParts[3];
+        return hex3ToHex(red, green, blue);
+    }
+    else {
+        return '000000';
+    }
+};
+const ɵ0$2 = fixupColorCode;
+const buildRunFontFragment = (fontName = defaultFont) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'rFonts')
+    .att('@w', 'ascii', fontName)
+    .att('@w', 'hAnsi', fontName)
+    .up();
+const ɵ1$1 = buildRunFontFragment;
+const buildRunStyleFragment = (type = 'Hyperlink') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'rStyle')
+    .att('@w', 'val', type)
+    .up();
+const ɵ2$1 = buildRunStyleFragment;
+const buildTableRowHeight = (tableRowHeight) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'trHeight')
+    .att('@w', 'val', tableRowHeight)
+    .att('@w', 'hRule', 'atLeast')
+    .up();
+const ɵ3$1 = buildTableRowHeight;
+const buildVerticalAlignment = (verticalAlignment) => {
+    if (verticalAlignment.toLowerCase() === 'middle') {
+        verticalAlignment = 'center';
+    }
+    return fragment({ namespaceAlias: { w: namespaces.w } })
+        .ele('@w', 'vAlign')
+        .att('@w', 'val', verticalAlignment)
+        .up();
+};
+const ɵ4 = buildVerticalAlignment;
+const buildVerticalMerge = (verticalMerge = 'continue') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'vMerge')
+    .att('@w', 'val', verticalMerge)
+    .up();
+const ɵ5 = buildVerticalMerge;
+const buildColor = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'color')
+    .att('@w', 'val', colorCode)
+    .up();
+const ɵ6 = buildColor;
+const buildFontSize = (fontSize) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'sz')
+    .att('@w', 'val', fontSize)
+    .up();
+const ɵ7 = buildFontSize;
+const buildShading = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'shd')
+    .att('@w', 'val', 'clear')
+    .att('@w', 'fill', colorCode)
+    .up();
+const ɵ8 = buildShading;
+const buildHighlight = (color = 'yellow') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'highlight')
+    .att('@w', 'val', color)
+    .up();
+const ɵ9 = buildHighlight;
+const buildVertAlign = (type = 'baseline') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'vertAlign')
+    .att('@w', 'val', type)
+    .up();
+const ɵ10 = buildVertAlign;
+const buildStrike = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'strike')
+    .att('@w', 'val', true)
+    .up();
+const ɵ11 = buildStrike;
+const buildBold = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'b')
+    .up();
+const ɵ12 = buildBold;
+const buildItalics = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'i')
+    .up();
+const ɵ13 = buildItalics;
+const buildUnderline = (type = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'u')
+    .att('@w', 'val', type)
+    .up();
+const ɵ14 = buildUnderline;
+const buildLineBreak = (type = 'textWrapping') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'br')
+    .att('@w', 'type', type)
+    .up();
+const ɵ15 = buildLineBreak;
+const buildBorder = (borderSide = 'top', borderSize = 0, borderSpacing = 0, borderColor = fixupColorCode('black'), borderStroke = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', borderSide)
+    .att('@w', 'val', borderStroke)
+    .att('@w', 'sz', borderSize)
+    .att('@w', 'space', borderSpacing)
+    .att('@w', 'color', borderColor)
+    .up();
+const ɵ16 = buildBorder;
+const buildTextElement = (text) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 't')
+    .att('@xml', 'space', 'preserve')
+    .txt(text)
+    .up();
+const ɵ17 = buildTextElement;
+// eslint-disable-next-line consistent-return
+const fixupLineHeight = (lineHeight, fontSize) => {
+    // FIXME: If line height is anything other than a number
+    // eslint-disable-next-line no-restricted-globals
+    if (!isNaN(lineHeight)) {
+        if (fontSize) {
+            const actualLineHeight = +lineHeight * fontSize;
+            return HIPToTWIP(actualLineHeight);
+        }
+        else {
+            // 240 TWIP or 12 point is default line height
+            return +lineHeight * 240;
+        }
+    }
+    else {
+        // 240 TWIP or 12 point is default line height
+        return 240;
+    }
+};
+const ɵ18 = fixupLineHeight;
+// eslint-disable-next-line consistent-return
+const fixupFontSize$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]);
+    }
+};
+const ɵ19 = fixupFontSize$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]);
+    }
+};
+const ɵ20 = fixupRowHeight;
+// eslint-disable-next-line consistent-return
+const fixupColumnWidth = (columnWidthString) => {
+    if (pointRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(pointRegex);
+        return pointToTWIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(pixelRegex);
+        return pixelToTWIP(matchedParts[1]);
+    }
+    else if (cmRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(cmRegex);
+        return cmToTWIP(matchedParts[1]);
+    }
+    else if (inchRegex.test(columnWidthString)) {
+        const matchedParts = columnWidthString.match(inchRegex);
+        return inchToTWIP(matchedParts[1]);
+    }
+};
+const ɵ21 = fixupColumnWidth;
+// eslint-disable-next-line consistent-return
+const fixupMargin = (marginString) => {
+    if (pointRegex.test(marginString)) {
+        const matchedParts = marginString.match(pointRegex);
+        // convert point to half point
+        return pointToTWIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(marginString)) {
+        const matchedParts = marginString.match(pixelRegex);
+        // convert pixels to half point
+        return pixelToTWIP(matchedParts[1]);
+    }
+};
+const ɵ22 = fixupMargin;
+const modifiedStyleAttributesBuilder = (vNode, attributes, options) => {
+    const modifiedAttributes = Object.assign({}, attributes);
+    // styles
+    if (isVNode(vNode) && vNode.properties && vNode.properties.style) {
+        if (vNode.properties.style.color && !colorlessColors.includes(vNode.properties.style.color)) {
+            modifiedAttributes.color = fixupColorCode(vNode.properties.style.color);
+        }
+        if (vNode.properties.style['background-color'] &&
+            !colorlessColors.includes(vNode.properties.style['background-color'])) {
+            modifiedAttributes.backgroundColor = fixupColorCode(vNode.properties.style['background-color']);
+        }
+        if (vNode.properties.style['vertical-align'] &&
+            verticalAlignValues.includes(vNode.properties.style['vertical-align'])) {
+            modifiedAttributes.verticalAlign = vNode.properties.style['vertical-align'];
+        }
+        if (vNode.properties.style['text-align'] &&
+            ['left', 'right', 'center', 'justify'].includes(vNode.properties.style['text-align'])) {
+            modifiedAttributes.textAlign = vNode.properties.style['text-align'];
+        }
+        // FIXME: remove bold check when other font weights are handled.
+        if (vNode.properties.style['font-weight'] && vNode.properties.style['font-weight'] === 'bold') {
+            modifiedAttributes.strong = vNode.properties.style['font-weight'];
+        }
+        if (vNode.properties.style['font-size']) {
+            modifiedAttributes.fontSize = fixupFontSize$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;
+};
+const ɵ23 = modifiedStyleAttributesBuilder;
+// html tag to formatting function
+// options are passed to the formatting function if needed
+const buildFormatting = (htmlTag, options) => {
+    switch (htmlTag) {
+        case 'strong':
+        case 'b':
+            return buildBold();
+        case 'em':
+        case 'i':
+            return buildItalics();
+        case 'ins':
+        case 'u':
+            return buildUnderline();
+        case 'strike':
+        case 'del':
+        case 's':
+            return buildStrike();
+        case 'sub':
+            return buildVertAlign('subscript');
+        case 'sup':
+            return buildVertAlign('superscript');
+        case 'mark':
+            return buildHighlight();
+        case 'code':
+            return buildHighlight('lightGray');
+        case 'highlightColor':
+            return buildHighlight(options && options.color ? options.color : 'lightGray');
+        case 'font':
+        case 'pre':
+            return buildRunFontFragment('Courier');
+        case 'color':
+            return buildColor(options && options.color ? options.color : 'black');
+        case 'backgroundColor':
+            return buildShading(options && options.color ? options.color : 'black');
+        case 'fontSize':
+            // does this need a unit of measure?
+            return buildFontSize(options && options.fontSize ? options.fontSize : 10);
+        case 'hyperlink':
+            return buildRunStyleFragment('Hyperlink');
+    }
+    return null;
+};
+const ɵ24 = buildFormatting;
+const buildRunProperties = (attributes) => {
+    const runPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'rPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            const options = {};
+            if (key === 'color' || key === 'backgroundColor' || key === 'highlightColor') {
+                options.color = attributes[key];
+            }
+            if (key === 'fontSize') {
+                options.fontSize = attributes[key];
+            }
+            const formattingFragment = buildFormatting(key, options);
+            if (formattingFragment) {
+                runPropertiesFragment.import(formattingFragment);
+            }
+        });
+    }
+    runPropertiesFragment.up();
+    return runPropertiesFragment;
+};
+const ɵ25 = buildRunProperties;
+const buildRun = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const runFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
+    const runPropertiesFragment = buildRunProperties(cloneDeep(attributes));
+    // case where we have recursive spans representing font changes
+    if (isVNode(vNode) && vNode.tagName === 'span') {
+        // eslint-disable-next-line no-use-before-define
+        return buildRunOrRuns(vNode, attributes, docxDocumentInstance);
+    }
+    if (isVNode(vNode) &&
+        [
+            'strong',
+            'b',
+            'em',
+            'i',
+            'u',
+            'ins',
+            'strike',
+            'del',
+            's',
+            'sub',
+            'sup',
+            'mark',
+            'blockquote',
+            'code',
+            'pre',
+        ].includes(vNode.tagName)) {
+        const runFragmentsArray = [];
+        let vNodes = [vNode];
+        // create temp run fragments to split the paragraph into different runs
+        let tempAttributes = cloneDeep(attributes);
+        let tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
+        while (vNodes.length) {
+            const tempVNode = vNodes.shift();
+            if (isVText(tempVNode)) {
+                const textFragment = buildTextElement(tempVNode.text);
+                const tempRunPropertiesFragment = buildRunProperties(Object.assign(Object.assign({}, attributes), tempAttributes));
+                tempRunFragment.import(tempRunPropertiesFragment);
+                tempRunFragment.import(textFragment);
+                runFragmentsArray.push(tempRunFragment);
+                // re initialize temp run fragments with new fragment
+                tempAttributes = cloneDeep(attributes);
+                tempRunFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
+            }
+            else if (isVNode(tempVNode)) {
+                if ([
+                    'strong',
+                    'b',
+                    'em',
+                    'i',
+                    'u',
+                    'ins',
+                    'strike',
+                    'del',
+                    's',
+                    'sub',
+                    'sup',
+                    'mark',
+                    'code',
+                    'pre',
+                ].includes(tempVNode.tagName)) {
+                    tempAttributes = {};
+                    switch (tempVNode.tagName) {
+                        case 'strong':
+                        case 'b':
+                            tempAttributes.strong = true;
+                            break;
+                        case 'i':
+                            tempAttributes.i = true;
+                            break;
+                        case 'u':
+                            tempAttributes.u = true;
+                            break;
+                        case 'sub':
+                            tempAttributes.sub = true;
+                            break;
+                        case 'sup':
+                            tempAttributes.sup = true;
+                            break;
+                    }
+                    const formattingFragment = buildFormatting(tempVNode);
+                    if (formattingFragment) {
+                        runPropertiesFragment.import(formattingFragment);
+                    }
+                    // go a layer deeper if there is a span somewhere in the children
+                }
+                else if (tempVNode.tagName === 'span') {
+                    // eslint-disable-next-line no-use-before-define
+                    const spanFragment = yield buildRunOrRuns(tempVNode, Object.assign(Object.assign({}, attributes), tempAttributes), docxDocumentInstance);
+                    // if spanFragment is an array, we need to add each fragment to the runFragmentsArray. If the fragment is an array, perform a depth first search on the array to add each fragment to the runFragmentsArray
+                    if (Array.isArray(spanFragment)) {
+                        spanFragment.flat(Infinity);
+                        runFragmentsArray.push(...spanFragment);
+                    }
+                    else {
+                        runFragmentsArray.push(spanFragment);
+                    }
+                    // do not slice and concat children since this is already accounted for in the buildRunOrRuns function
+                    // eslint-disable-next-line no-continue
+                    continue;
+                }
+            }
+            if (tempVNode.children && tempVNode.children.length) {
+                if (tempVNode.children.length > 1) {
+                    attributes = Object.assign(Object.assign({}, attributes), tempAttributes);
+                }
+                vNodes = tempVNode.children.slice().concat(vNodes);
+            }
+        }
+        if (runFragmentsArray.length) {
+            return runFragmentsArray;
+        }
+    }
+    runFragment.import(runPropertiesFragment);
+    if (isVText(vNode)) {
+        const textFragment = buildTextElement(vNode.text);
+        runFragment.import(textFragment);
+    }
+    else if (attributes && attributes.type === 'picture') {
+        let response = null;
+        const base64Uri = decodeURIComponent(vNode.properties.src);
+        if (base64Uri) {
+            response = docxDocumentInstance.createMediaFile(base64Uri);
+        }
+        if (response) {
+            docxDocumentInstance.zip
+                .folder('word')
+                .folder('media')
+                .file(response.fileNameWithExtension, Buffer.from(response.fileContent, 'base64'), {
+                createFolders: false,
+            });
+            const documentRelsId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, imageType, `media/${response.fileNameWithExtension}`, internalRelationship);
+            attributes.inlineOrAnchored = true;
+            attributes.relationshipId = documentRelsId;
+            attributes.id = response.id;
+            attributes.fileContent = response.fileContent;
+            attributes.fileNameWithExtension = response.fileNameWithExtension;
+        }
+        const { type, inlineOrAnchored } = attributes, otherAttributes = __rest(attributes, ["type", "inlineOrAnchored"]);
+        // eslint-disable-next-line no-use-before-define
+        const imageFragment = buildDrawing(inlineOrAnchored, type, otherAttributes);
+        runFragment.import(imageFragment);
+    }
+    else if (isVNode(vNode) && vNode.tagName === 'br') {
+        const lineBreakFragment = buildLineBreak();
+        runFragment.import(lineBreakFragment);
+    }
+    runFragment.up();
+    return runFragment;
+});
+const ɵ26 = buildRun;
+const buildRunOrRuns = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isVNode(vNode) && vNode.tagName === 'span') {
+        let runFragments = [];
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes);
+            const tempRunFragments = yield buildRun(childVNode, modifiedAttributes, docxDocumentInstance);
+            runFragments = runFragments.concat(Array.isArray(tempRunFragments) ? tempRunFragments : [tempRunFragments]);
+        }
+        return runFragments;
+    }
+    else {
+        const tempRunFragments = yield buildRun(vNode, attributes, docxDocumentInstance);
+        return tempRunFragments;
+    }
+});
+const ɵ27 = buildRunOrRuns;
+const buildRunOrHyperLink = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isVNode(vNode) && vNode.tagName === 'a') {
+        const relationshipId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, hyperlinkType, vNode.properties && vNode.properties.href ? vNode.properties.href : '');
+        const hyperlinkFragment = fragment({ namespaceAlias: { w: namespaces.w, r: namespaces.r } })
+            .ele('@w', 'hyperlink')
+            .att('@r', 'id', `rId${relationshipId}`);
+        const modifiedAttributes = Object.assign({}, attributes);
+        modifiedAttributes.hyperlink = true;
+        const runFragments = yield buildRunOrRuns(vNode.children[0], modifiedAttributes, docxDocumentInstance);
+        if (Array.isArray(runFragments)) {
+            for (let index = 0; index < runFragments.length; index++) {
+                const runFragment = runFragments[index];
+                hyperlinkFragment.import(runFragment);
+            }
+        }
+        else {
+            hyperlinkFragment.import(runFragments);
+        }
+        hyperlinkFragment.up();
+        return hyperlinkFragment;
+    }
+    const runFragments = yield buildRunOrRuns(vNode, attributes, docxDocumentInstance);
+    return runFragments;
+});
+const ɵ28 = buildRunOrHyperLink;
+const buildNumberingProperties = (levelId, numberingId) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'numPr')
+    .ele('@w', 'ilvl')
+    .att('@w', 'val', String(levelId))
+    .up()
+    .ele('@w', 'numId')
+    .att('@w', 'val', String(numberingId))
+    .up()
+    .up();
+const ɵ29 = buildNumberingProperties;
+const buildNumberingInstances = () => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'num')
+    .ele('@w', 'abstractNumId')
+    .up()
+    .up();
+const ɵ30 = buildNumberingInstances;
+const buildSpacing = (lineSpacing, beforeSpacing, afterSpacing) => {
+    const spacingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'spacing');
+    if (lineSpacing) {
+        spacingFragment.att('@w', 'line', lineSpacing);
+    }
+    if (beforeSpacing) {
+        spacingFragment.att('@w', 'before', beforeSpacing);
+    }
+    if (afterSpacing) {
+        spacingFragment.att('@w', 'after', afterSpacing);
+    }
+    spacingFragment.att('@w', 'lineRule', 'auto').up();
+    return spacingFragment;
+};
+const ɵ31 = buildSpacing;
+const buildIndentation = ({ left, right }) => {
+    const indentationFragment = fragment({
+        namespaceAlias: { w: namespaces.w },
+    }).ele('@w', 'ind');
+    if (left) {
+        indentationFragment.att('@w', 'left', left);
+    }
+    if (right) {
+        indentationFragment.att('@w', 'right', right);
+    }
+    indentationFragment.up();
+    return indentationFragment;
+};
+const ɵ32 = buildIndentation;
+const buildPStyle = (style = 'Normal') => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'pStyle')
+    .att('@w', 'val', style)
+    .up();
+const ɵ33 = buildPStyle;
+const buildHorizontalAlignment = (horizontalAlignment) => {
+    if (horizontalAlignment === 'justify') {
+        horizontalAlignment = 'both';
+    }
+    return fragment({ namespaceAlias: { w: namespaces.w } })
+        .ele('@w', 'jc')
+        .att('@w', 'val', horizontalAlignment)
+        .up();
+};
+const ɵ34 = buildHorizontalAlignment;
+const buildParagraphBorder = () => {
+    const paragraphBorderFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'pBdr');
+    const bordersObject = cloneDeep(paragraphBordersObject);
+    Object.keys(bordersObject).forEach((borderName) => {
+        if (bordersObject[borderName]) {
+            const { size, spacing, color } = bordersObject[borderName];
+            const borderFragment = buildBorder(borderName, size, spacing, color);
+            paragraphBorderFragment.import(borderFragment);
+        }
+    });
+    paragraphBorderFragment.up();
+    return paragraphBorderFragment;
+};
+const ɵ35 = buildParagraphBorder;
+const buildParagraphProperties = (attributes) => {
+    const paragraphPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'pPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'numbering':
+                    const { levelId, numberingId } = attributes[key];
+                    const numberingPropertiesFragment = buildNumberingProperties(levelId, numberingId);
+                    paragraphPropertiesFragment.import(numberingPropertiesFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.numbering;
+                    break;
+                case 'textAlign':
+                    const horizontalAlignmentFragment = buildHorizontalAlignment(attributes[key]);
+                    paragraphPropertiesFragment.import(horizontalAlignmentFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.textAlign;
+                    break;
+                case 'backgroundColor':
+                    // Add shading to Paragraph Properties only if display is block
+                    // Essentially if background color needs to be across the row
+                    if (attributes.display === 'block') {
+                        const shadingFragment = buildShading(attributes[key]);
+                        paragraphPropertiesFragment.import(shadingFragment);
+                        // FIXME: Inner padding in case of shaded paragraphs.
+                        const paragraphBorderFragment = buildParagraphBorder();
+                        paragraphPropertiesFragment.import(paragraphBorderFragment);
+                        // eslint-disable-next-line no-param-reassign
+                        delete attributes.backgroundColor;
+                    }
+                    break;
+                case 'paragraphStyle':
+                    const pStyleFragment = buildPStyle(attributes.paragraphStyle);
+                    paragraphPropertiesFragment.import(pStyleFragment);
+                    delete attributes.paragraphStyle;
+                    break;
+                case 'indentation':
+                    const indentationFragment = buildIndentation(attributes[key]);
+                    paragraphPropertiesFragment.import(indentationFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.indentation;
+                    break;
+            }
+        });
+        const spacingFragment = buildSpacing(attributes.lineHeight, attributes.beforeSpacing, attributes.afterSpacing);
+        // eslint-disable-next-line no-param-reassign
+        delete attributes.lineHeight;
+        // eslint-disable-next-line no-param-reassign
+        delete attributes.beforeSpacing;
+        // eslint-disable-next-line no-param-reassign
+        delete attributes.afterSpacing;
+        paragraphPropertiesFragment.import(spacingFragment);
+    }
+    paragraphPropertiesFragment.up();
+    return paragraphPropertiesFragment;
+};
+const ɵ36 = buildParagraphProperties;
+const computeImageDimensions = (vNode, attributes) => {
+    const { maximumWidth, originalWidth, originalHeight } = attributes;
+    const aspectRatio = originalWidth / originalHeight;
+    const maximumWidthInEMU = TWIPToEMU(maximumWidth);
+    let originalWidthInEMU = pixelToEMU(originalWidth);
+    let originalHeightInEMU = pixelToEMU(originalHeight);
+    if (originalWidthInEMU > maximumWidthInEMU) {
+        originalWidthInEMU = maximumWidthInEMU;
+        originalHeightInEMU = Math.round(originalWidthInEMU / aspectRatio);
+    }
+    let modifiedHeight;
+    let modifiedWidth;
+    if (vNode.properties && vNode.properties.style) {
+        if (vNode.properties.style.width) {
+            if (vNode.properties.style.width !== 'auto') {
+                if (pixelRegex.test(vNode.properties.style.width)) {
+                    modifiedWidth = pixelToEMU(vNode.properties.style.width.match(pixelRegex)[1]);
+                }
+                else if (percentageRegex.test(vNode.properties.style.width)) {
+                    const percentageValue = vNode.properties.style.width.match(percentageRegex)[1];
+                    modifiedWidth = Math.round((percentageValue / 100) * originalWidthInEMU);
+                }
+            }
+            else {
+                // eslint-disable-next-line no-lonely-if
+                if (vNode.properties.style.height && vNode.properties.style.height === 'auto') {
+                    modifiedWidth = originalWidthInEMU;
+                    modifiedHeight = originalHeightInEMU;
+                }
+            }
+        }
+        if (vNode.properties.style.height) {
+            if (vNode.properties.style.height !== 'auto') {
+                if (pixelRegex.test(vNode.properties.style.height)) {
+                    modifiedHeight = pixelToEMU(vNode.properties.style.height.match(pixelRegex)[1]);
+                }
+                else if (percentageRegex.test(vNode.properties.style.height)) {
+                    const percentageValue = vNode.properties.style.width.match(percentageRegex)[1];
+                    modifiedHeight = Math.round((percentageValue / 100) * originalHeightInEMU);
+                    if (!modifiedWidth) {
+                        modifiedWidth = Math.round(modifiedHeight * aspectRatio);
+                    }
+                }
+            }
+            else {
+                // eslint-disable-next-line no-lonely-if
+                if (modifiedWidth) {
+                    if (!modifiedHeight) {
+                        modifiedHeight = Math.round(modifiedWidth / aspectRatio);
+                    }
+                }
+                else {
+                    modifiedHeight = originalHeightInEMU;
+                    modifiedWidth = originalWidthInEMU;
+                }
+            }
+        }
+        if (modifiedWidth && !modifiedHeight) {
+            modifiedHeight = Math.round(modifiedWidth / aspectRatio);
+        }
+        else if (modifiedHeight && !modifiedWidth) {
+            modifiedWidth = Math.round(modifiedHeight * aspectRatio);
+        }
+    }
+    else {
+        modifiedWidth = originalWidthInEMU;
+        modifiedHeight = originalHeightInEMU;
+    }
+    // eslint-disable-next-line no-param-reassign
+    attributes.width = modifiedWidth;
+    // eslint-disable-next-line no-param-reassign
+    attributes.height = modifiedHeight;
+};
+const ɵ37 = computeImageDimensions;
+const buildParagraph = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'p');
+    const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes, {
+        isParagraph: true,
+    });
+    const paragraphPropertiesFragment = buildParagraphProperties(modifiedAttributes);
+    paragraphFragment.import(paragraphPropertiesFragment);
+    if (isVNode(vNode) && vNodeHasChildren(vNode)) {
+        if ([
+            'span',
+            'strong',
+            'b',
+            'em',
+            'i',
+            'u',
+            'ins',
+            'strike',
+            'del',
+            's',
+            'sub',
+            'sup',
+            'mark',
+            'a',
+            'code',
+            'pre',
+        ].includes(vNode.tagName)) {
+            const runOrHyperlinkFragments = yield buildRunOrHyperLink(vNode, modifiedAttributes, docxDocumentInstance);
+            if (Array.isArray(runOrHyperlinkFragments)) {
+                for (let iteratorIndex = 0; iteratorIndex < runOrHyperlinkFragments.length; iteratorIndex++) {
+                    const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];
+                    paragraphFragment.import(runOrHyperlinkFragment);
+                }
+            }
+            else {
+                paragraphFragment.import(runOrHyperlinkFragments);
+            }
+        }
+        else if (vNode.tagName === 'blockquote') {
+            const runFragmentOrFragments = yield buildRun(vNode, attributes);
+            if (Array.isArray(runFragmentOrFragments)) {
+                for (let index = 0; index < runFragmentOrFragments.length; index++) {
+                    paragraphFragment.import(runFragmentOrFragments[index]);
+                }
+            }
+            else {
+                paragraphFragment.import(runFragmentOrFragments);
+            }
+        }
+        else {
+            for (let index = 0; index < vNode.children.length; index++) {
+                const childVNode = vNode.children[index];
+                if (childVNode.tagName === 'img') {
+                    let base64String;
+                    const imageSource = childVNode.properties.src;
+                    if (isValidUrl(imageSource)) {
+                        base64String = yield imageToBase64(imageSource).catch((error) => {
+                            // eslint-disable-next-line no-console
+                            console.warning(`skipping image download and conversion due to ${error}`);
+                        });
+                        if (base64String && mimeTypes.lookup(imageSource)) {
+                            childVNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    else {
+                        // eslint-disable-next-line no-useless-escape, prefer-destructuring
+                        base64String = imageSource.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/)[2];
+                    }
+                    const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');
+                    const imageProperties = sizeOf(imageBuffer);
+                    modifiedAttributes.maximumWidth =
+                        modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;
+                    modifiedAttributes.originalWidth = imageProperties.width;
+                    modifiedAttributes.originalHeight = imageProperties.height;
+                    computeImageDimensions(childVNode, modifiedAttributes);
+                }
+                const runOrHyperlinkFragments = yield buildRunOrHyperLink(childVNode, isVNode(childVNode) && childVNode.tagName === 'img'
+                    ? Object.assign(Object.assign({}, modifiedAttributes), { type: 'picture' }) : modifiedAttributes, docxDocumentInstance);
+                if (Array.isArray(runOrHyperlinkFragments)) {
+                    for (let iteratorIndex = 0; iteratorIndex < runOrHyperlinkFragments.length; iteratorIndex++) {
+                        const runOrHyperlinkFragment = runOrHyperlinkFragments[iteratorIndex];
+                        paragraphFragment.import(runOrHyperlinkFragment);
+                    }
+                }
+                else {
+                    paragraphFragment.import(runOrHyperlinkFragments);
+                }
+            }
+        }
+    }
+    else {
+        // In case paragraphs has to be rendered where vText is present. Eg. table-cell
+        // Or in case the vNode is something like img
+        if (isVNode(vNode) && vNode.tagName === 'img') {
+            const imageSource = vNode.properties.src;
+            let base64String = imageSource;
+            if (isValidUrl(imageSource)) {
+                base64String = yield imageToBase64(imageSource).catch((error) => {
+                    // eslint-disable-next-line no-console
+                    console.warning(`skipping image download and conversion due to ${error}`);
+                });
+                if (base64String && mimeTypes.lookup(imageSource)) {
+                    vNode.properties.src = `data:${mimeTypes.lookup(imageSource)};base64, ${base64String}`;
+                }
+                else {
+                    paragraphFragment.up();
+                    return paragraphFragment;
+                }
+            }
+            else {
+                // eslint-disable-next-line no-useless-escape, prefer-destructuring
+                base64String = base64String.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/)[2];
+            }
+            const imageBuffer = Buffer.from(decodeURIComponent(base64String), 'base64');
+            const imageProperties = sizeOf(imageBuffer);
+            modifiedAttributes.maximumWidth =
+                modifiedAttributes.maximumWidth || docxDocumentInstance.availableDocumentSpace;
+            modifiedAttributes.originalWidth = imageProperties.width;
+            modifiedAttributes.originalHeight = imageProperties.height;
+            computeImageDimensions(vNode, modifiedAttributes);
+        }
+        const runFragments = yield buildRunOrRuns(vNode, modifiedAttributes, docxDocumentInstance);
+        if (Array.isArray(runFragments)) {
+            for (let index = 0; index < runFragments.length; index++) {
+                const runFragment = runFragments[index];
+                paragraphFragment.import(runFragment);
+            }
+        }
+        else {
+            paragraphFragment.import(runFragments);
+        }
+    }
+    paragraphFragment.up();
+    return paragraphFragment;
+});
+const ɵ38 = buildParagraph;
+const buildGridSpanFragment = (spanValue) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'gridSpan')
+    .att('@w', 'val', spanValue)
+    .up();
+const ɵ39 = buildGridSpanFragment;
+const buildTableCellSpacing = (cellSpacing = 0) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'tblCellSpacing')
+    .att('@w', 'w', cellSpacing)
+    .att('@w', 'type', 'dxa')
+    .up();
+const ɵ40 = buildTableCellSpacing;
+const buildTableCellBorders = (tableCellBorder) => {
+    const tableCellBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcBorders');
+    const { color, stroke } = tableCellBorder, borders = __rest(tableCellBorder, ["color", "stroke"]);
+    Object.keys(borders).forEach((border) => {
+        if (tableCellBorder[border]) {
+            const borderFragment = buildBorder(border, tableCellBorder[border], 0, color, stroke);
+            tableCellBordersFragment.import(borderFragment);
+        }
+    });
+    tableCellBordersFragment.up();
+    return tableCellBordersFragment;
+};
+const ɵ41 = buildTableCellBorders;
+const buildTableCellWidth = (tableCellWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'tcW')
+    .att('@w', 'w', fixupColumnWidth(tableCellWidth))
+    .att('@w', 'type', 'dxa')
+    .up();
+const ɵ42 = buildTableCellWidth;
+const buildTableCellProperties = (attributes) => {
+    const tableCellPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'backgroundColor':
+                    const shadingFragment = buildShading(attributes[key]);
+                    tableCellPropertiesFragment.import(shadingFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.backgroundColor;
+                    break;
+                case 'verticalAlign':
+                    const verticalAlignmentFragment = buildVerticalAlignment(attributes[key]);
+                    tableCellPropertiesFragment.import(verticalAlignmentFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.verticalAlign;
+                    break;
+                case 'colSpan':
+                    const gridSpanFragment = buildGridSpanFragment(attributes[key]);
+                    tableCellPropertiesFragment.import(gridSpanFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.colSpan;
+                    break;
+                case 'tableCellBorder':
+                    const tableCellBorderFragment = buildTableCellBorders(attributes[key]);
+                    tableCellPropertiesFragment.import(tableCellBorderFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableCellBorder;
+                    break;
+                case 'rowSpan':
+                    const verticalMergeFragment = buildVerticalMerge(attributes[key]);
+                    tableCellPropertiesFragment.import(verticalMergeFragment);
+                    delete attributes.rowSpan;
+                    break;
+                case 'width':
+                    const widthFragment = buildTableCellWidth(attributes[key]);
+                    tableCellPropertiesFragment.import(widthFragment);
+                    delete attributes.width;
+                    break;
+            }
+        });
+    }
+    tableCellPropertiesFragment.up();
+    return tableCellPropertiesFragment;
+};
+const ɵ43 = buildTableCellProperties;
+const fixupTableCellBorder = (vNode, attributes) => {
+    if (Object.prototype.hasOwnProperty.call(vNode.properties.style, 'border')) {
+        if (vNode.properties.style.border === 'none' || vNode.properties.style.border === 0) {
+            attributes.tableCellBorder = {};
+        }
+        else {
+            // eslint-disable-next-line no-use-before-define
+            const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style.border);
+            attributes.tableCellBorder = {
+                top: borderSize,
+                left: borderSize,
+                bottom: borderSize,
+                right: borderSize,
+                color: borderColor,
+                stroke: borderStroke,
+            };
+        }
+    }
+    if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { top: 0 });
+    }
+    else if (vNode.properties.style['border-top'] && vNode.properties.style['border-top'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-top']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { top: borderSize, color: borderColor, stroke: borderStroke });
+    }
+    if (vNode.properties.style['border-left'] && vNode.properties.style['border-left'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { left: 0 });
+    }
+    else if (vNode.properties.style['border-left'] &&
+        vNode.properties.style['border-left'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-left']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { left: borderSize, color: borderColor, stroke: borderStroke });
+    }
+    if (vNode.properties.style['border-bottom'] && vNode.properties.style['border-bottom'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { bottom: 0 });
+    }
+    else if (vNode.properties.style['border-bottom'] &&
+        vNode.properties.style['border-bottom'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-bottom']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { bottom: borderSize, color: borderColor, stroke: borderStroke });
+    }
+    if (vNode.properties.style['border-right'] && vNode.properties.style['border-right'] === '0') {
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: 0 });
+    }
+    else if (vNode.properties.style['border-right'] &&
+        vNode.properties.style['border-right'] !== '0') {
+        // eslint-disable-next-line no-use-before-define
+        const [borderSize, borderStroke, borderColor] = cssBorderParser(vNode.properties.style['border-right']);
+        attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: borderSize, color: borderColor, stroke: borderStroke });
+    }
+};
+const ɵ44 = fixupTableCellBorder;
+const buildTableCell = (vNode, attributes, rowSpanMap, columnIndex, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
+    let modifiedAttributes = Object.assign({}, attributes);
+    if (isVNode(vNode) && vNode.properties) {
+        if (vNode.properties.rowSpan) {
+            rowSpanMap.set(columnIndex.index, { rowSpan: vNode.properties.rowSpan - 1, colSpan: 0 });
+            modifiedAttributes.rowSpan = 'restart';
+        }
+        else {
+            const previousSpanObject = rowSpanMap.get(columnIndex.index);
+            rowSpanMap.set(columnIndex.index, 
+            // eslint-disable-next-line prefer-object-spread
+            Object.assign({}, previousSpanObject, {
+                rowSpan: 0,
+                colSpan: (previousSpanObject && previousSpanObject.colSpan) || 0,
+            }));
+        }
+        if (vNode.properties.colSpan ||
+            (vNode.properties.style && vNode.properties.style['column-span'])) {
+            modifiedAttributes.colSpan =
+                vNode.properties.colSpan ||
+                    (vNode.properties.style && vNode.properties.style['column-span']);
+            const previousSpanObject = rowSpanMap.get(columnIndex.index);
+            rowSpanMap.set(columnIndex.index, 
+            // eslint-disable-next-line prefer-object-spread
+            Object.assign({}, previousSpanObject, {
+                colSpan: parseInt(modifiedAttributes.colSpan) || 0,
+            }));
+            columnIndex.index += parseInt(modifiedAttributes.colSpan) - 1;
+        }
+        if (vNode.properties.style) {
+            modifiedAttributes = Object.assign(Object.assign({}, modifiedAttributes), modifiedStyleAttributesBuilder(vNode, attributes));
+            fixupTableCellBorder(vNode, modifiedAttributes);
+        }
+    }
+    const tableCellPropertiesFragment = buildTableCellProperties(modifiedAttributes);
+    tableCellFragment.import(tableCellPropertiesFragment);
+    if (vNodeHasChildren(vNode)) {
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            if (isVNode(childVNode) && childVNode.tagName === 'img') {
+                const imageFragment = yield buildImage(docxDocumentInstance, childVNode, modifiedAttributes.maximumWidth);
+                if (imageFragment) {
+                    tableCellFragment.import(imageFragment);
+                }
+            }
+            else if (isVNode(childVNode) && childVNode.tagName === 'figure') {
+                if (vNodeHasChildren(childVNode)) {
+                    // eslint-disable-next-line no-plusplus
+                    for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
+                        const grandChildVNode = childVNode.children[iteratorIndex];
+                        if (grandChildVNode.tagName === 'img') {
+                            const imageFragment = yield buildImage(docxDocumentInstance, grandChildVNode, modifiedAttributes.maximumWidth);
+                            if (imageFragment) {
+                                tableCellFragment.import(imageFragment);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (isVNode(childVNode) && ['ul', 'ol'].includes(childVNode.tagName)) {
+                // render list in table
+                if (vNodeHasChildren(childVNode)) {
+                    yield buildList(childVNode, docxDocumentInstance, tableCellFragment);
+                }
+            }
+            else {
+                const paragraphFragment = yield buildParagraph(childVNode, modifiedAttributes, docxDocumentInstance);
+                tableCellFragment.import(paragraphFragment);
+            }
+        }
+    }
+    else {
+        // TODO: Figure out why building with buildParagraph() isn't working
+        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+            .ele('@w', 'p')
+            .up();
+        tableCellFragment.import(paragraphFragment);
+    }
+    tableCellFragment.up();
+    return tableCellFragment;
+});
+const ɵ45 = buildTableCell;
+const buildRowSpanCell = (rowSpanMap, columnIndex, attributes) => {
+    const rowSpanCellFragments = [];
+    let spanObject = rowSpanMap.get(columnIndex.index);
+    while (spanObject && spanObject.rowSpan) {
+        const rowSpanCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
+        const tableCellPropertiesFragment = buildTableCellProperties(Object.assign(Object.assign({}, attributes), { rowSpan: 'continue', colSpan: spanObject.colSpan ? spanObject.colSpan : 0 }));
+        rowSpanCellFragment.import(tableCellPropertiesFragment);
+        const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+            .ele('@w', 'p')
+            .up();
+        rowSpanCellFragment.import(paragraphFragment);
+        rowSpanCellFragment.up();
+        rowSpanCellFragments.push(rowSpanCellFragment);
+        if (spanObject.rowSpan - 1 === 0) {
+            rowSpanMap.delete(columnIndex.index);
+        }
+        else {
+            rowSpanMap.set(columnIndex.index, {
+                rowSpan: spanObject.rowSpan - 1,
+                colSpan: spanObject.colSpan || 0,
+            });
+        }
+        columnIndex.index += spanObject.colSpan || 1;
+        spanObject = rowSpanMap.get(columnIndex.index);
+    }
+    return rowSpanCellFragments;
+};
+const ɵ46 = buildRowSpanCell;
+const buildTableRowProperties = (attributes) => {
+    const tableRowPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'trPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'tableRowHeight':
+                    const tableRowHeightFragment = buildTableRowHeight(attributes[key]);
+                    tableRowPropertiesFragment.import(tableRowHeightFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableRowHeight;
+                    break;
+                case 'rowCantSplit':
+                    if (attributes.rowCantSplit) {
+                        const cantSplitFragment = fragment({ namespaceAlias: { w: namespaces.w } })
+                            .ele('@w', 'cantSplit')
+                            .up();
+                        tableRowPropertiesFragment.import(cantSplitFragment);
+                        // eslint-disable-next-line no-param-reassign
+                        delete attributes.rowCantSplit;
+                    }
+                    break;
+            }
+        });
+    }
+    tableRowPropertiesFragment.up();
+    return tableRowPropertiesFragment;
+};
+const ɵ47 = buildTableRowProperties;
+const buildTableRow = (vNode, attributes, rowSpanMap, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableRowFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tr');
+    const modifiedAttributes = Object.assign({}, attributes);
+    if (isVNode(vNode) && vNode.properties) {
+        // FIXME: find a better way to get row height from cell style
+        if ((vNode.properties.style && vNode.properties.style.height) ||
+            (vNode.children[0] &&
+                isVNode(vNode.children[0]) &&
+                vNode.children[0].properties.style &&
+                vNode.children[0].properties.style.height)) {
+            modifiedAttributes.tableRowHeight = fixupRowHeight((vNode.properties.style && vNode.properties.style.height) ||
+                (vNode.children[0] &&
+                    isVNode(vNode.children[0]) &&
+                    vNode.children[0].properties.style &&
+                    vNode.children[0].properties.style.height
+                    ? vNode.children[0].properties.style.height
+                    : undefined));
+        }
+        if (vNode.properties.style) {
+            fixupTableCellBorder(vNode, modifiedAttributes);
+        }
+    }
+    const tableRowPropertiesFragment = buildTableRowProperties(modifiedAttributes);
+    tableRowFragment.import(tableRowPropertiesFragment);
+    const columnIndex = { index: 0 };
+    if (vNodeHasChildren(vNode)) {
+        const tableColumns = vNode.children.filter((childVNode) => ['td', 'th'].includes(childVNode.tagName));
+        const maximumColumnWidth = docxDocumentInstance.availableDocumentSpace / tableColumns.length;
+        // eslint-disable-next-line no-restricted-syntax
+        for (const column of tableColumns) {
+            const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);
+            if (Array.isArray(rowSpanCellFragments)) {
+                for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {
+                    const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];
+                    tableRowFragment.import(rowSpanCellFragment);
+                }
+            }
+            const tableCellFragment = yield buildTableCell(column, Object.assign(Object.assign({}, modifiedAttributes), { maximumWidth: maximumColumnWidth }), rowSpanMap, columnIndex, docxDocumentInstance);
+            columnIndex.index++;
+            tableRowFragment.import(tableCellFragment);
+        }
+    }
+    if (columnIndex.index < rowSpanMap.size) {
+        const rowSpanCellFragments = buildRowSpanCell(rowSpanMap, columnIndex, modifiedAttributes);
+        if (Array.isArray(rowSpanCellFragments)) {
+            for (let iteratorIndex = 0; iteratorIndex < rowSpanCellFragments.length; iteratorIndex++) {
+                const rowSpanCellFragment = rowSpanCellFragments[iteratorIndex];
+                tableRowFragment.import(rowSpanCellFragment);
+            }
+        }
+    }
+    tableRowFragment.up();
+    return tableRowFragment;
+});
+const ɵ48 = buildTableRow;
+const buildTableGridCol = (gridWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'gridCol')
+    .att('@w', 'w', String(gridWidth));
+const ɵ49 = buildTableGridCol;
+const buildTableGrid = (vNode, attributes) => {
+    const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');
+    if (vNodeHasChildren(vNode)) {
+        const gridColumns = vNode.children.filter((childVNode) => childVNode.tagName === 'col');
+        const gridWidth = attributes.maximumWidth / gridColumns.length;
+        for (let index = 0; index < gridColumns.length; index++) {
+            const tableGridColFragment = buildTableGridCol(gridWidth);
+            tableGridFragment.import(tableGridColFragment);
+        }
+    }
+    tableGridFragment.up();
+    return tableGridFragment;
+};
+const ɵ50 = buildTableGrid;
+const buildTableGridFromTableRow = (vNode, attributes) => {
+    const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');
+    if (vNodeHasChildren(vNode)) {
+        const numberOfGridColumns = vNode.children.reduce((accumulator, childVNode) => {
+            const colSpan = childVNode.properties.colSpan ||
+                (childVNode.properties.style && childVNode.properties.style['column-span']);
+            return accumulator + (colSpan ? parseInt(colSpan) : 1);
+        }, 0);
+        const gridWidth = attributes.maximumWidth / numberOfGridColumns;
+        for (let index = 0; index < numberOfGridColumns; index++) {
+            const tableGridColFragment = buildTableGridCol(gridWidth);
+            tableGridFragment.import(tableGridColFragment);
+        }
+    }
+    tableGridFragment.up();
+    return tableGridFragment;
+};
+const ɵ51 = buildTableGridFromTableRow;
+const buildTableBorders = (tableBorder) => {
+    const tableBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblBorders');
+    const { color, stroke } = tableBorder, borders = __rest(tableBorder, ["color", "stroke"]);
+    Object.keys(borders).forEach((border) => {
+        if (borders[border]) {
+            const borderFragment = buildBorder(border, borders[border], 0, color, stroke);
+            tableBordersFragment.import(borderFragment);
+        }
+    });
+    tableBordersFragment.up();
+    return tableBordersFragment;
+};
+const ɵ52 = buildTableBorders;
+const buildTableWidth = (tableWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', 'tblW')
+    .att('@w', 'type', 'dxa')
+    .att('@w', 'w', String(tableWidth))
+    .up();
+const ɵ53 = buildTableWidth;
+const buildCellMargin = (side, margin) => fragment({ namespaceAlias: { w: namespaces.w } })
+    .ele('@w', side)
+    .att('@w', 'type', 'dxa')
+    .att('@w', 'w', String(margin))
+    .up();
+const ɵ54 = buildCellMargin;
+const buildTableCellMargins = (margin) => {
+    const tableCellMarFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblCellMar');
+    ['top', 'bottom'].forEach((side) => {
+        const marginFragment = buildCellMargin(side, margin / 2);
+        tableCellMarFragment.import(marginFragment);
+    });
+    ['left', 'right'].forEach((side) => {
+        const marginFragment = buildCellMargin(side, margin);
+        tableCellMarFragment.import(marginFragment);
+    });
+    return tableCellMarFragment;
+};
+const ɵ55 = buildTableCellMargins;
+const buildTableProperties = (attributes) => {
+    const tablePropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblPr');
+    if (attributes && attributes.constructor === Object) {
+        Object.keys(attributes).forEach((key) => {
+            switch (key) {
+                case 'tableBorder':
+                    const tableBordersFragment = buildTableBorders(attributes[key]);
+                    tablePropertiesFragment.import(tableBordersFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableBorder;
+                    break;
+                case 'tableCellSpacing':
+                    const tableCellSpacingFragment = buildTableCellSpacing(attributes[key]);
+                    tablePropertiesFragment.import(tableCellSpacingFragment);
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.tableCellSpacing;
+                    break;
+                case 'width':
+                    if (attributes[key]) {
+                        const tableWidthFragment = buildTableWidth(attributes[key]);
+                        tablePropertiesFragment.import(tableWidthFragment);
+                    }
+                    // eslint-disable-next-line no-param-reassign
+                    delete attributes.width;
+                    break;
+            }
+        });
+    }
+    const tableCellMarginFragment = buildTableCellMargins(160);
+    tablePropertiesFragment.import(tableCellMarginFragment);
+    // by default, all tables are center aligned.
+    const alignmentFragment = buildHorizontalAlignment('center');
+    tablePropertiesFragment.import(alignmentFragment);
+    tablePropertiesFragment.up();
+    return tablePropertiesFragment;
+};
+const ɵ56 = buildTableProperties;
+const cssBorderParser = (borderString) => {
+    let [size, stroke, color] = borderString.split(' ');
+    if (pointRegex.test(size)) {
+        const matchedParts = size.match(pointRegex);
+        // convert point to eighth of a point
+        size = pointToEIP(matchedParts[1]);
+    }
+    else if (pixelRegex.test(size)) {
+        const matchedParts = size.match(pixelRegex);
+        // convert pixels to eighth of a point
+        size = pixelToEIP(matchedParts[1]);
+    }
+    stroke = stroke && ['dashed', 'dotted', 'double'].includes(stroke) ? stroke : 'single';
+    color = color && fixupColorCode(color).toUpperCase();
+    return [size, stroke, color];
+};
+const ɵ57 = cssBorderParser;
+const buildTable = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
+    const tableFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tbl');
+    const modifiedAttributes = Object.assign({}, attributes);
+    if (isVNode(vNode) && vNode.properties) {
+        const tableAttributes = vNode.properties.attributes || {};
+        const tableStyles = vNode.properties.style || {};
+        const tableBorders = {};
+        const tableCellBorders = {};
+        let [borderSize, borderStrike, borderColor] = [2, 'single', '000000'];
+        // eslint-disable-next-line no-restricted-globals
+        if (!isNaN(tableAttributes.border)) {
+            borderSize = parseInt(tableAttributes.border, 10);
+        }
+        // css style overrides table border properties
+        if (tableStyles.border) {
+            const [cssSize, cssStroke, cssColor] = cssBorderParser(tableStyles.border);
+            borderSize = cssSize || borderSize;
+            borderColor = cssColor || borderColor;
+            borderStrike = cssStroke || borderStrike;
+        }
+        tableBorders.top = borderSize;
+        tableBorders.bottom = borderSize;
+        tableBorders.left = borderSize;
+        tableBorders.right = borderSize;
+        tableBorders.stroke = borderStrike;
+        tableBorders.color = borderColor;
+        if (tableStyles['border-collapse'] === 'collapse') {
+            tableBorders.insideV = borderSize;
+            tableBorders.insideH = borderSize;
+        }
+        else {
+            tableBorders.insideV = 0;
+            tableBorders.insideH = 0;
+            tableCellBorders.top = 1;
+            tableCellBorders.bottom = 1;
+            tableCellBorders.left = 1;
+            tableCellBorders.right = 1;
+        }
+        modifiedAttributes.tableBorder = tableBorders;
+        modifiedAttributes.tableCellSpacing = 0;
+        if (Object.keys(tableCellBorders).length) {
+            modifiedAttributes.tableCellBorder = tableCellBorders;
+        }
+        let minimumWidth;
+        let maximumWidth;
+        let width;
+        // Calculate minimum width of table
+        if (pixelRegex.test(tableStyles['min-width'])) {
+            minimumWidth = pixelToTWIP(tableStyles['min-width'].match(pixelRegex)[1]);
+        }
+        else if (percentageRegex.test(tableStyles['min-width'])) {
+            const percentageValue = tableStyles['min-width'].match(percentageRegex)[1];
+            minimumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);
+        }
+        // Calculate maximum width of table
+        if (pixelRegex.test(tableStyles['max-width'])) {
+            pixelRegex.lastIndex = 0;
+            maximumWidth = pixelToTWIP(tableStyles['max-width'].match(pixelRegex)[1]);
+        }
+        else if (percentageRegex.test(tableStyles['max-width'])) {
+            percentageRegex.lastIndex = 0;
+            const percentageValue = tableStyles['max-width'].match(percentageRegex)[1];
+            maximumWidth = Math.round((percentageValue / 100) * attributes.maximumWidth);
+        }
+        // Calculate specified width of table
+        if (pixelRegex.test(tableStyles.width)) {
+            pixelRegex.lastIndex = 0;
+            width = pixelToTWIP(tableStyles.width.match(pixelRegex)[1]);
+        }
+        else if (percentageRegex.test(tableStyles.width)) {
+            percentageRegex.lastIndex = 0;
+            const percentageValue = tableStyles.width.match(percentageRegex)[1];
+            width = Math.round((percentageValue / 100) * attributes.maximumWidth);
+        }
+        // If width isn't supplied, we should have min-width as the width.
+        if (width) {
+            modifiedAttributes.width = width;
+            if (maximumWidth) {
+                modifiedAttributes.width = Math.min(modifiedAttributes.width, maximumWidth);
+            }
+            if (minimumWidth) {
+                modifiedAttributes.width = Math.max(modifiedAttributes.width, minimumWidth);
+            }
+        }
+        else if (minimumWidth) {
+            modifiedAttributes.width = minimumWidth;
+        }
+        if (modifiedAttributes.width) {
+            modifiedAttributes.width = Math.min(modifiedAttributes.width, attributes.maximumWidth);
+        }
+    }
+    const tablePropertiesFragment = buildTableProperties(modifiedAttributes);
+    tableFragment.import(tablePropertiesFragment);
+    const rowSpanMap = new Map();
+    if (vNodeHasChildren(vNode)) {
+        for (let index = 0; index < vNode.children.length; index++) {
+            const childVNode = vNode.children[index];
+            if (childVNode.tagName === 'colgroup') {
+                const tableGridFragment = buildTableGrid(childVNode, modifiedAttributes);
+                tableFragment.import(tableGridFragment);
+            }
+            else if (childVNode.tagName === 'thead') {
+                for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
+                    const grandChildVNode = childVNode.children[iteratorIndex];
+                    if (grandChildVNode.tagName === 'tr') {
+                        if (iteratorIndex === 0) {
+                            const tableGridFragment = buildTableGridFromTableRow(grandChildVNode, modifiedAttributes);
+                            tableFragment.import(tableGridFragment);
+                        }
+                        const tableRowFragment = yield buildTableRow(grandChildVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
+                        tableFragment.import(tableRowFragment);
+                    }
+                }
+            }
+            else if (childVNode.tagName === 'tbody') {
+                for (let iteratorIndex = 0; iteratorIndex < childVNode.children.length; iteratorIndex++) {
+                    const grandChildVNode = childVNode.children[iteratorIndex];
+                    if (grandChildVNode.tagName === 'tr') {
+                        if (iteratorIndex === 0) {
+                            const tableGridFragment = buildTableGridFromTableRow(grandChildVNode, modifiedAttributes);
+                            tableFragment.import(tableGridFragment);
+                        }
+                        const tableRowFragment = yield buildTableRow(grandChildVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
+                        tableFragment.import(tableRowFragment);
+                    }
+                }
+            }
+            else if (childVNode.tagName === 'tr') {
+                if (index === 0) {
+                    const tableGridFragment = buildTableGridFromTableRow(childVNode, modifiedAttributes);
+                    tableFragment.import(tableGridFragment);
+                }
+                const tableRowFragment = yield buildTableRow(childVNode, modifiedAttributes, rowSpanMap, docxDocumentInstance);
+                tableFragment.import(tableRowFragment);
+            }
+        }
+    }
+    tableFragment.up();
+    return tableFragment;
+});
+const ɵ58 = buildTable;
+const buildPresetGeometry = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'prstGeom')
+    .att('prst', 'rect')
+    .up();
+const ɵ59 = buildPresetGeometry;
+const buildExtents = ({ width, height }) => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'ext')
+    .att('cx', width)
+    .att('cy', height)
+    .up();
+const ɵ60 = buildExtents;
+const buildOffset = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'off')
+    .att('x', '0')
+    .att('y', '0')
+    .up();
+const ɵ61 = buildOffset;
+const buildGraphicFrameTransform = (attributes) => {
+    const graphicFrameTransformFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'xfrm');
+    const offsetFragment = buildOffset();
+    graphicFrameTransformFragment.import(offsetFragment);
+    const extentsFragment = buildExtents(attributes);
+    graphicFrameTransformFragment.import(extentsFragment);
+    graphicFrameTransformFragment.up();
+    return graphicFrameTransformFragment;
+};
+const ɵ62 = buildGraphicFrameTransform;
+const buildShapeProperties = (attributes) => {
+    const shapeProperties = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'spPr');
+    const graphicFrameTransformFragment = buildGraphicFrameTransform(attributes);
+    shapeProperties.import(graphicFrameTransformFragment);
+    const presetGeometryFragment = buildPresetGeometry();
+    shapeProperties.import(presetGeometryFragment);
+    shapeProperties.up();
+    return shapeProperties;
+};
+const ɵ63 = buildShapeProperties;
+const buildFillRect = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'fillRect')
+    .up();
+const ɵ64 = buildFillRect;
+const buildStretch = () => {
+    const stretchFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'stretch');
+    const fillRectFragment = buildFillRect();
+    stretchFragment.import(fillRectFragment);
+    stretchFragment.up();
+    return stretchFragment;
+};
+const ɵ65 = buildStretch;
+const buildSrcRectFragment = () => fragment({ namespaceAlias: { a: namespaces.a } })
+    .ele('@a', 'srcRect')
+    .att('b', '0')
+    .att('l', '0')
+    .att('r', '0')
+    .att('t', '0')
+    .up();
+const ɵ66 = buildSrcRectFragment;
+const buildBinaryLargeImageOrPicture = (relationshipId) => fragment({
+    namespaceAlias: { a: namespaces.a, r: namespaces.r },
+})
+    .ele('@a', 'blip')
+    .att('@r', 'embed', `rId${relationshipId}`)
+    // FIXME: possible values 'email', 'none', 'print', 'hqprint', 'screen'
+    .att('cstate', 'print')
+    .up();
+const ɵ67 = buildBinaryLargeImageOrPicture;
+const buildBinaryLargeImageOrPictureFill = (relationshipId) => {
+    const binaryLargeImageOrPictureFillFragment = fragment({
+        namespaceAlias: { pic: namespaces.pic },
+    }).ele('@pic', 'blipFill');
+    const binaryLargeImageOrPictureFragment = buildBinaryLargeImageOrPicture(relationshipId);
+    binaryLargeImageOrPictureFillFragment.import(binaryLargeImageOrPictureFragment);
+    const srcRectFragment = buildSrcRectFragment();
+    binaryLargeImageOrPictureFillFragment.import(srcRectFragment);
+    const stretchFragment = buildStretch();
+    binaryLargeImageOrPictureFillFragment.import(stretchFragment);
+    binaryLargeImageOrPictureFillFragment.up();
+    return binaryLargeImageOrPictureFillFragment;
+};
+const ɵ68 = buildBinaryLargeImageOrPictureFill;
+const buildNonVisualPictureDrawingProperties = () => fragment({ namespaceAlias: { pic: namespaces.pic } })
+    .ele('@pic', 'cNvPicPr')
+    .up();
+const ɵ69 = buildNonVisualPictureDrawingProperties;
+const buildNonVisualDrawingProperties = (pictureId, pictureNameWithExtension, pictureDescription = '') => fragment({ namespaceAlias: { pic: namespaces.pic } })
+    .ele('@pic', 'cNvPr')
+    .att('id', pictureId)
+    .att('name', pictureNameWithExtension)
+    .att('descr', pictureDescription)
+    .up();
+const ɵ70 = buildNonVisualDrawingProperties;
+const buildNonVisualPictureProperties = (pictureId, pictureNameWithExtension, pictureDescription) => {
+    const nonVisualPicturePropertiesFragment = fragment({
+        namespaceAlias: { pic: namespaces.pic },
+    }).ele('@pic', 'nvPicPr');
+    // TODO: Handle picture attributes
+    const nonVisualDrawingPropertiesFragment = buildNonVisualDrawingProperties(pictureId, pictureNameWithExtension, pictureDescription);
+    nonVisualPicturePropertiesFragment.import(nonVisualDrawingPropertiesFragment);
+    const nonVisualPictureDrawingPropertiesFragment = buildNonVisualPictureDrawingProperties();
+    nonVisualPicturePropertiesFragment.import(nonVisualPictureDrawingPropertiesFragment);
+    nonVisualPicturePropertiesFragment.up();
+    return nonVisualPicturePropertiesFragment;
+};
+const ɵ71 = buildNonVisualPictureProperties;
+const buildPicture = ({ id, fileNameWithExtension, description, relationshipId, width, height, }) => {
+    const pictureFragment = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'pic');
+    const nonVisualPicturePropertiesFragment = buildNonVisualPictureProperties(id, fileNameWithExtension, description);
+    pictureFragment.import(nonVisualPicturePropertiesFragment);
+    const binaryLargeImageOrPictureFill = buildBinaryLargeImageOrPictureFill(relationshipId);
+    pictureFragment.import(binaryLargeImageOrPictureFill);
+    const shapeProperties = buildShapeProperties({ width, height });
+    pictureFragment.import(shapeProperties);
+    pictureFragment.up();
+    return pictureFragment;
+};
+const ɵ72 = buildPicture;
+const buildGraphicData = (graphicType, attributes) => {
+    const graphicDataFragment = fragment({ namespaceAlias: { a: namespaces.a } })
+        .ele('@a', 'graphicData')
+        .att('uri', 'http://schemas.openxmlformats.org/drawingml/2006/picture');
+    if (graphicType === 'picture') {
+        const pictureFragment = buildPicture(attributes);
+        graphicDataFragment.import(pictureFragment);
+    }
+    graphicDataFragment.up();
+    return graphicDataFragment;
+};
+const ɵ73 = buildGraphicData;
+const buildGraphic = (graphicType, attributes) => {
+    const graphicFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'graphic');
+    // TODO: Handle drawing type
+    const graphicDataFragment = buildGraphicData(graphicType, attributes);
+    graphicFragment.import(graphicDataFragment);
+    graphicFragment.up();
+    return graphicFragment;
+};
+const ɵ74 = buildGraphic;
+const buildDrawingObjectNonVisualProperties = (pictureId, pictureName) => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'docPr')
+    .att('id', pictureId)
+    .att('name', pictureName)
+    .up();
+const ɵ75 = buildDrawingObjectNonVisualProperties;
+const buildWrapSquare = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'wrapSquare')
+    .att('wrapText', 'bothSides')
+    .att('distB', '228600')
+    .att('distT', '228600')
+    .att('distL', '228600')
+    .att('distR', '228600')
+    .up();
+const ɵ76 = buildWrapSquare;
+// eslint-disable-next-line no-unused-vars
+const buildWrapNone = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'wrapNone')
+    .up();
+const ɵ77 = buildWrapNone;
+const buildEffectExtentFragment = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'effectExtent')
+    .att('b', '0')
+    .att('l', '0')
+    .att('r', '0')
+    .att('t', '0')
+    .up();
+const ɵ78 = buildEffectExtentFragment;
+const buildExtent = ({ width, height }) => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'extent')
+    .att('cx', width)
+    .att('cy', height)
+    .up();
+const ɵ79 = buildExtent;
+const buildPositionV = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'positionV')
+    .att('relativeFrom', 'paragraph')
+    .ele('@wp', 'posOffset')
+    .txt('19050')
+    .up()
+    .up();
+const ɵ80 = buildPositionV;
+const buildPositionH = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'positionH')
+    .att('relativeFrom', 'column')
+    .ele('@wp', 'posOffset')
+    .txt('19050')
+    .up()
+    .up();
+const ɵ81 = buildPositionH;
+const buildSimplePos = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
+    .ele('@wp', 'simplePos')
+    .att('x', '0')
+    .att('y', '0')
+    .up();
+const ɵ82 = buildSimplePos;
+const buildAnchoredDrawing = (graphicType, attributes) => {
+    const anchoredDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })
+        .ele('@wp', 'anchor')
+        .att('distB', '0')
+        .att('distL', '0')
+        .att('distR', '0')
+        .att('distT', '0')
+        .att('relativeHeight', '0')
+        .att('behindDoc', 'false')
+        .att('locked', 'true')
+        .att('layoutInCell', 'true')
+        .att('allowOverlap', 'false')
+        .att('simplePos', 'false');
+    // Even though simplePos isnt supported by Word 2007 simplePos is required.
+    const simplePosFragment = buildSimplePos();
+    anchoredDrawingFragment.import(simplePosFragment);
+    const positionHFragment = buildPositionH();
+    anchoredDrawingFragment.import(positionHFragment);
+    const positionVFragment = buildPositionV();
+    anchoredDrawingFragment.import(positionVFragment);
+    const extentFragment = buildExtent({ width: attributes.width, height: attributes.height });
+    anchoredDrawingFragment.import(extentFragment);
+    const effectExtentFragment = buildEffectExtentFragment();
+    anchoredDrawingFragment.import(effectExtentFragment);
+    const wrapSquareFragment = buildWrapSquare();
+    anchoredDrawingFragment.import(wrapSquareFragment);
+    const drawingObjectNonVisualPropertiesFragment = buildDrawingObjectNonVisualProperties(attributes.id, attributes.fileNameWithExtension);
+    anchoredDrawingFragment.import(drawingObjectNonVisualPropertiesFragment);
+    const graphicFragment = buildGraphic(graphicType, attributes);
+    anchoredDrawingFragment.import(graphicFragment);
+    anchoredDrawingFragment.up();
+    return anchoredDrawingFragment;
+};
+const ɵ83 = buildAnchoredDrawing;
+const buildInlineDrawing = (graphicType, attributes) => {
+    const inlineDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })
+        .ele('@wp', 'inline')
+        .att('distB', '0')
+        .att('distL', '0')
+        .att('distR', '0')
+        .att('distT', '0');
+    const extentFragment = buildExtent({ width: attributes.width, height: attributes.height });
+    inlineDrawingFragment.import(extentFragment);
+    const effectExtentFragment = buildEffectExtentFragment();
+    inlineDrawingFragment.import(effectExtentFragment);
+    const drawingObjectNonVisualPropertiesFragment = buildDrawingObjectNonVisualProperties(attributes.id, attributes.fileNameWithExtension);
+    inlineDrawingFragment.import(drawingObjectNonVisualPropertiesFragment);
+    const graphicFragment = buildGraphic(graphicType, attributes);
+    inlineDrawingFragment.import(graphicFragment);
+    inlineDrawingFragment.up();
+    return inlineDrawingFragment;
+};
+const ɵ84 = buildInlineDrawing;
+const buildDrawing = (inlineOrAnchored = false, graphicType, attributes) => {
+    const drawingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'drawing');
+    const inlineOrAnchoredDrawingFragment = inlineOrAnchored
+        ? buildInlineDrawing(graphicType, attributes)
+        : buildAnchoredDrawing(graphicType, attributes);
+    drawingFragment.import(inlineOrAnchoredDrawingFragment);
+    drawingFragment.up();
+    return drawingFragment;
+};
+const ɵ85 = buildDrawing;
+
+const convertHTML$1 = HTMLToVDOM({
+    VNode,
+    VText,
+});
+// 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 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 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;
+});
+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,
+    VText,
+});
+const mergeOptions = (options, patch) => (Object.assign(Object.assign({}, options), patch));
+const ɵ0$1 = mergeOptions;
+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 ɵ1 = fixupFontSize;
+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 ɵ2 = normalizeUnits;
+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;
+};
+const ɵ3 = normalizeDocumentOptions;
+// 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;
+    }
+};
+const ɵ0 = minifyHTMLString;
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function WordDocumentService_Factory() { return new WordDocumentService(); }, token: WordDocumentService, providedIn: "root" });
+WordDocumentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+
+class WordDocumentModel {
+    constructor() {
+        this.options = new DocumentOptionsModel();
+    }
+}
+class DocumentOptionsModel {
+}
+
+/*
+ * Public API Surface of @bnsights/bbsf-utilities
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppInjector, AppearanceConfigurationService, AuthService, BBSFTranslateService, BBSFUtilitiesModule, ConfigurationService, ControlValidationService, DocumentOptionsModel, EnvironmentService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, StylesBundleService, TranslationResolverService, UtilityService, WordDocumentModel, WordDocumentService, environment };
+//# sourceMappingURL=bnsights-bbsf-utilities.js.map