docx 7.8.2 → 8.0.0

package/src/patcher/util.spec.ts

@@ -0,0 +1,50 @@
+import { expect } from "chai";
+
+import { createTextElementContents, getFirstLevelElements, patchSpaceAttribute, toJson } from "./util";
+
+describe("util", () => {
+    describe("toJson", () => {
+        it("should return an Element", () => {
+            const output = toJson("<xml></xml>");
+            expect(output).to.be.an("object");
+        });
+    });
+
+    describe("createTextElementContents", () => {
+        it("should return an array of elements", () => {
+            const output = createTextElementContents("hello");
+            expect(output).to.deep.equal([{ type: "text", text: "hello" }]);
+        });
+    });
+
+    describe("patchSpaceAttribute", () => {
+        it("should return an element with the xml:space attribute", () => {
+            const output = patchSpaceAttribute({ type: "element", name: "xml" });
+            expect(output).to.deep.equal({
+                type: "element",
+                name: "xml",
+                attributes: {
+                    "xml:space": "preserve",
+                },
+            });
+        });
+    });
+
+    describe("getFirstLevelElements", () => {
+        it("should return an empty array if no elements are found", () => {
+            const elements = getFirstLevelElements(
+                { elements: [{ type: "element", name: "Relationships", elements: [] }] },
+                "Relationships",
+            );
+            expect(elements).to.deep.equal([]);
+        });
+
+        it("should return an array if elements are found", () => {
+            const elements = getFirstLevelElements(
+                { elements: [{ type: "element", name: "Relationships", elements: [{ type: "element", name: "Relationship" }] }] },
+                "Relationships",
+            );
+            expect(elements).to.deep.equal([{ type: "element", name: "Relationship" }]);
+        });
+    });
+});

package/src/patcher/util.ts

@@ -0,0 +1,30 @@
+import { xml2js, Element } from "xml-js";
+import * as xml from "xml";
+
+import { Formatter } from "@export/formatter";
+import { Text } from "@file/paragraph/run/run-components/text";
+
+const formatter = new Formatter();
+
+export const toJson = (xmlData: string): Element => {
+    const xmlObj = xml2js(xmlData, { compact: false }) as Element;
+    return xmlObj;
+};
+
+// eslint-disable-next-line functional/prefer-readonly-type
+export const createTextElementContents = (text: string): Element[] => {
+    const textJson = toJson(xml(formatter.format(new Text({ text }))));
+
+    return textJson.elements![0].elements ?? [];
+};
+
+export const patchSpaceAttribute = (element: Element): Element => ({
+    ...element,
+    attributes: {
+        "xml:space": "preserve",
+    },
+});
+
+// eslint-disable-next-line functional/prefer-readonly-type
+export const getFirstLevelElements = (relationships: Element, id: string): Element[] =>
+    relationships.elements?.filter((e) => e.name === id)[0].elements ?? [];

package/src/util/values.spec.ts

@@ -25,13 +25,6 @@ describe("values", () => {
             expect(universalMeasureValue("5.22pc")).to.eq("5.22pc");
             expect(universalMeasureValue("100 pi")).to.eq("100pi");
         });
-        it("should throw on invalid values", () => {
-            expect(() => universalMeasureValue("100pp")).to.throw();
-            expect(() => universalMeasureValue("foo")).to.throw();
-            expect(() => universalMeasureValue("--in")).to.throw();
-            expect(() => universalMeasureValue("NaNpc")).to.throw();
-            expect(() => universalMeasureValue("50")).to.throw();
-        });
     });
 
     describe("positiveUniversalMeasureValue", () => {
@@ -46,11 +39,6 @@ describe("values", () => {
         it("should throw on invalid values", () => {
             expect(() => positiveUniversalMeasureValue("-9mm")).to.throw();
             expect(() => positiveUniversalMeasureValue("-0.5in")).to.throw();
-            expect(() => positiveUniversalMeasureValue("100pp")).to.throw();
-            expect(() => positiveUniversalMeasureValue("foo")).to.throw();
-            expect(() => positiveUniversalMeasureValue("--in")).to.throw();
-            expect(() => positiveUniversalMeasureValue("NaNpc")).to.throw();
-            expect(() => positiveUniversalMeasureValue("50")).to.throw();
         });
     });
 
@@ -116,7 +104,6 @@ describe("values", () => {
         });
         it("should throw on invalid values", () => {
             expect(() => signedTwipsMeasureValue(NaN)).to.throw();
-            expect(() => signedTwipsMeasureValue("foo")).to.throw();
         });
     });
 
@@ -129,7 +116,6 @@ describe("values", () => {
         it("should throw on invalid values", () => {
             expect(() => twipsMeasureValue(-12)).to.throw();
             expect(() => twipsMeasureValue(NaN)).to.throw();
-            expect(() => twipsMeasureValue("foo")).to.throw();
             expect(() => twipsMeasureValue("-5mm")).to.throw();
         });
     });
@@ -154,7 +140,6 @@ describe("values", () => {
         });
         it("should throw on invalid values", () => {
             expect(() => hpsMeasureValue(NaN)).to.throw();
-            expect(() => hpsMeasureValue("5FF")).to.throw();
         });
     });
 
@@ -165,11 +150,6 @@ describe("values", () => {
             expect(percentageValue("100%")).to.eq("100%");
             expect(percentageValue("1000%")).to.eq("1000%");
         });
-        it("should throw on invalid values", () => {
-            expect(() => percentageValue("0%%")).to.throw();
-            expect(() => percentageValue("20")).to.throw();
-            expect(() => percentageValue("FF%")).to.throw();
-        });
     });
 
     describe("measurementOrPercentValue", () => {
@@ -181,8 +161,6 @@ describe("values", () => {
         });
         it("should throw on invalid values", () => {
             expect(() => measurementOrPercentValue(NaN)).to.throw();
-            expect(() => measurementOrPercentValue("10%%")).to.throw();
-            expect(() => measurementOrPercentValue("10F")).to.throw();
         });
     });
 

package/src/util/values.ts

@@ -4,6 +4,23 @@
 // Most of the rest of the types not defined here are either aliases of existing types or enumerations.
 // Enumerations should probably just be implemented as enums, with instructions to end-users, without a runtime check.
 
+// -?[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)
+export type UniversalMeasure = `${"-" | ""}${number}${"mm" | "cm" | "in" | "pt" | "pc" | "pi"}`;
+
+// <xsd:simpleType name="ST_PositiveUniversalMeasure">
+//     <xsd:restriction base="ST_UniversalMeasure">
+//         <xsd:pattern value="[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)" />
+//     </xsd:restriction>
+// </xsd:simpleType>
+export type PositiveUniversalMeasure = `${number}${"mm" | "cm" | "in" | "pt" | "pc" | "pi"}`;
+
+// <xsd:simpleType name="ST_Percentage">
+//     <xsd:restriction base="xsd:string">
+//         <xsd:pattern value="-?[0-9]+(\.[0-9]+)?%"/>
+//     </xsd:restriction>
+// </xsd:simpleType>
+export type Percentage = `${"-" | ""}${number}%`;
+
 // <xsd:simpleType name="ST_DecimalNumber">
 //     <xsd:restriction base="xsd:integer"/>
 // </xsd:simpleType>
@@ -70,30 +87,23 @@ export const uCharHexNumber = (val: string): string => hexBinary(val, 1);
 //         <xsd:pattern value="-?[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export const universalMeasureValue = (val: string): string => {
+export const universalMeasureValue = (val: UniversalMeasure): UniversalMeasure => {
     const unit = val.slice(-2);
-    if (!universalMeasureUnits.includes(unit)) {
-        throw new Error(`Invalid unit '${unit}' specified. Valid units are ${universalMeasureUnits.join(", ")}`);
-    }
     const amount = val.substring(0, val.length - 2);
-    if (isNaN(Number(amount))) {
-        throw new Error(`Invalid value '${amount}' specified. Expected a valid number.`);
-    }
-    return `${Number(amount)}${unit}`;
+    return `${Number(amount)}${unit}` as UniversalMeasure;
 };
-const universalMeasureUnits = ["mm", "cm", "in", "pt", "pc", "pi"];
 
 // <xsd:simpleType name="ST_PositiveUniversalMeasure">
 //     <xsd:restriction base="ST_UniversalMeasure">
 //         <xsd:pattern value="[0-9]+(\.[0-9]+)?(mm|cm|in|pt|pc|pi)"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export const positiveUniversalMeasureValue = (val: string): string => {
+export const positiveUniversalMeasureValue = (val: PositiveUniversalMeasure): PositiveUniversalMeasure => {
     const value = universalMeasureValue(val);
     if (parseFloat(value) < 0) {
         throw new Error(`Invalid value '${value}' specified. Expected a positive number.`);
     }
-    return value;
+    return value as PositiveUniversalMeasure;
 };
 
 // <xsd:simpleType name="ST_HexColor">
@@ -123,25 +133,25 @@ export const hexColorValue = (val: string): string => {
 // <xsd:simpleType name="ST_SignedTwipsMeasure">
 //     <xsd:union memberTypes="xsd:integer s:ST_UniversalMeasure"/>
 // </xsd:simpleType>
-export const signedTwipsMeasureValue = (val: string | number): string | number =>
+export const signedTwipsMeasureValue = (val: UniversalMeasure | number): UniversalMeasure | number =>
     typeof val === "string" ? universalMeasureValue(val) : decimalNumber(val);
 
 // <xsd:simpleType name="ST_HpsMeasure">
 //     <xsd:union memberTypes="s:ST_UnsignedDecimalNumber s:ST_PositiveUniversalMeasure"/>
 // </xsd:simpleType>
-export const hpsMeasureValue = (val: string | number): string | number =>
+export const hpsMeasureValue = (val: PositiveUniversalMeasure | number): string | number =>
     typeof val === "string" ? positiveUniversalMeasureValue(val) : unsignedDecimalNumber(val);
 
 // <xsd:simpleType name="ST_SignedHpsMeasure">
 //     <xsd:union memberTypes="xsd:integer s:ST_UniversalMeasure"/>
 // </xsd:simpleType>
-export const signedHpsMeasureValue = (val: string | number): string | number =>
+export const signedHpsMeasureValue = (val: UniversalMeasure | number): string | number =>
     typeof val === "string" ? universalMeasureValue(val) : decimalNumber(val);
 
 // <xsd:simpleType name="ST_TwipsMeasure">
 //     <xsd:union memberTypes="ST_UnsignedDecimalNumber ST_PositiveUniversalMeasure"/>
 // </xsd:simpleType>
-export const twipsMeasureValue = (val: string | number): string | number =>
+export const twipsMeasureValue = (val: PositiveUniversalMeasure | number): PositiveUniversalMeasure | number =>
     typeof val === "string" ? positiveUniversalMeasureValue(val) : unsignedDecimalNumber(val);
 
 // <xsd:simpleType name="ST_Percentage">
@@ -149,14 +159,8 @@ export const twipsMeasureValue = (val: string | number): string | number =>
 //         <xsd:pattern value="-?[0-9]+(\.[0-9]+)?%"/>
 //     </xsd:restriction>
 // </xsd:simpleType>
-export const percentageValue = (val: string): string => {
-    if (val.slice(-1) !== "%") {
-        throw new Error(`Invalid value '${val}'. Expected percentage value (eg '55%')`);
-    }
+export const percentageValue = (val: Percentage): Percentage => {
     const percent = val.substring(0, val.length - 1);
-    if (isNaN(Number(percent))) {
-        throw new Error(`Invalid value '${percent}' specified. Expected a valid number.`);
-    }
     return `${Number(percent)}%`;
 };
 
@@ -172,14 +176,14 @@ export const percentageValue = (val: string): string => {
 //     <xsd:restriction base="xsd:integer"/>
 // </xsd:simpleType>
 
-export const measurementOrPercentValue = (val: number | string): number | string => {
+export const measurementOrPercentValue = (val: number | Percentage | UniversalMeasure): number | UniversalMeasure | Percentage => {
     if (typeof val === "number") {
         return decimalNumber(val);
     }
     if (val.slice(-1) === "%") {
-        return percentageValue(val);
+        return percentageValue(val as Percentage);
     }
-    return universalMeasureValue(val);
+    return universalMeasureValue(val as UniversalMeasure);
 };
 
 // <xsd:simpleType name="ST_EighthPointMeasure">

package/build/file/file-properties.d.ts

@@ -1,5 +0,0 @@
-import { IDocumentTemplate } from "../import-dotx";
-export interface IFileProperties {
-    readonly template?: IDocumentTemplate;
-}
-export declare const WORKAROUND = "";

package/build/file/paragraph/run/tab.d.ts

@@ -1,4 +0,0 @@
-import { XmlComponent } from "../../../file/xml-components";
-export declare class Tab extends XmlComponent {
-    constructor();
-}

package/build/import-dotx/import-dotx.d.ts

@@ -1,23 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IDocumentFooter } from "../file/footer-wrapper";
-import { IDocumentHeader } from "../file/header-wrapper";
-import { Media } from "../file/media";
-export interface IDocumentTemplate {
-    readonly currentRelationshipId: number;
-    readonly headers: IDocumentHeader[];
-    readonly footers: IDocumentFooter[];
-    readonly styles: string;
-    readonly titlePageIsDefined: boolean;
-    readonly media: Media;
-}
-export declare class ImportDotx {
-    extract(data: Buffer | string | number[] | Uint8Array | ArrayBuffer | Blob | NodeJS.ReadableStream): Promise<IDocumentTemplate>;
-    private createFooters;
-    private createHeaders;
-    private addRelationshipToWrapper;
-    private findReferenceFiles;
-    private extractDocumentRefs;
-    private checkIfTitlePageIsDefined;
-    private parseRefId;
-}

package/build/import-dotx/index.d.ts

@@ -1 +0,0 @@
-export * from "./import-dotx";

package/src/file/file-properties.ts

@@ -1,11 +0,0 @@
-import { IDocumentTemplate } from "../import-dotx";
-
-export interface IFileProperties {
-    readonly template?: IDocumentTemplate;
-}
-
-// Needed because of: https://github.com/s-panferov/awesome-typescript-loader/issues/432
-/**
- * @ignore
- */
-export const WORKAROUND = "";

package/src/file/paragraph/run/tab.spec.ts

@@ -1,22 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Tab } from "./tab";
-
-describe("Tab", () => {
-    let tab: Tab;
-
-    beforeEach(() => {
-        tab = new Tab();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Tab with correct root key", () => {
-            const tree = new Formatter().format(tab);
-            expect(tree).to.deep.equal({
-                "w:tab": {},
-            });
-        });
-    });
-});

package/src/file/paragraph/run/tab.ts

@@ -1,14 +0,0 @@
-// https://c-rex.net/projects/samples/ooxml/e1/Part4/OOXML_P4_DOCX_tab_topic_ID0EM6AO.html
-import { XmlComponent } from "@file/xml-components";
-
-// <xsd:group name="EG_RunInnerContent">
-//     ...
-//     <xsd:element name="tab" type="CT_Empty" minOccurs="0"/>
-//
-// TODO: this is unused and undocumented currently.
-// I think the intended use was for users to import, and insert as a child of `Run`.
-export class Tab extends XmlComponent {
-    public constructor() {
-        super("w:tab");
-    }
-}

package/src/import-dotx/import-dotx.spec.ts

@@ -1,26 +0,0 @@
-import { expect } from "chai";
-
-import { ImportDotx } from "./import-dotx";
-
-describe("ImportDotx", () => {
-    describe("#constructor", () => {
-        it("should create", () => {
-            const file = new ImportDotx();
-
-            expect(file).to.deep.equal({});
-        });
-    });
-
-    // describe("#extract", () => {
-    //     it("should create", async () => {
-    //         const file = new ImportDotx();
-    //         const filePath = "./demo/dotx/template.dotx";
-
-    //         const templateDocument = await file.extract(data);
-
-    //         await file.extract(data);
-
-    //         expect(templateDocument).to.be.equal({ currentRelationshipId: 1 });
-    //     });
-    // });
-});

package/src/import-dotx/import-dotx.ts

@@ -1,266 +0,0 @@
-/* eslint-disable */
-// This will be deprecated soon
-import * as JSZip from "jszip";
-import { Element as XMLElement, ElementCompact as XMLElementCompact, xml2js } from "xml-js";
-
-import { HeaderFooterReferenceType } from "@file/document/body/section-properties";
-import { FooterWrapper, IDocumentFooter } from "@file/footer-wrapper";
-import { HeaderWrapper, IDocumentHeader } from "@file/header-wrapper";
-import { Media } from "@file/media";
-import { TargetModeType } from "@file/relationships/relationship/relationship";
-import { convertToXmlComponent, ImportedXmlComponent } from "@file/xml-components";
-
-const schemeToType = {
-    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header": "header",
-    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer": "footer",
-    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image": "image",
-    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink": "hyperlink",
-};
-
-interface IDocumentRefs {
-    readonly headers: { readonly id: number; readonly type: HeaderFooterReferenceType }[];
-    readonly footers: { readonly id: number; readonly type: HeaderFooterReferenceType }[];
-}
-
-enum RelationshipType {
-    HEADER = "header",
-    FOOTER = "footer",
-    IMAGE = "image",
-    HYPERLINK = "hyperlink",
-}
-
-interface IRelationshipFileInfo {
-    readonly id: number;
-    readonly target: string;
-    readonly type: RelationshipType;
-}
-
-// Document Template
-// https://fileinfo.com/extension/dotx
-export interface IDocumentTemplate {
-    readonly currentRelationshipId: number;
-    readonly headers: IDocumentHeader[];
-    readonly footers: IDocumentFooter[];
-    readonly styles: string;
-    readonly titlePageIsDefined: boolean;
-    readonly media: Media;
-}
-
-export class ImportDotx {
-    public async extract(
-        data: Buffer | string | number[] | Uint8Array | ArrayBuffer | Blob | NodeJS.ReadableStream,
-    ): Promise<IDocumentTemplate> {
-        const zipContent = await JSZip.loadAsync(data);
-
-        const documentContent = await zipContent.files["word/document.xml"].async("text");
-        const relationshipContent = await zipContent.files["word/_rels/document.xml.rels"].async("text");
-
-        const documentRefs = this.extractDocumentRefs(documentContent);
-        const documentRelationships = this.findReferenceFiles(relationshipContent);
-
-        const media = new Media();
-
-        const templateDocument: IDocumentTemplate = {
-            headers: await this.createHeaders(zipContent, documentRefs, documentRelationships, media, 0),
-            footers: await this.createFooters(zipContent, documentRefs, documentRelationships, media, documentRefs.headers.length),
-            currentRelationshipId: documentRefs.footers.length + documentRefs.headers.length,
-            styles: await zipContent.files["word/styles.xml"].async("text"),
-            titlePageIsDefined: this.checkIfTitlePageIsDefined(documentContent),
-            media: media,
-        };
-
-        return templateDocument;
-    }
-
-    private async createFooters(
-        zipContent: JSZip,
-        documentRefs: IDocumentRefs,
-        documentRelationships: IRelationshipFileInfo[],
-        media: Media,
-        startingRelationshipId: number,
-    ): Promise<IDocumentFooter[]> {
-        const result = documentRefs.footers
-            .map(async (reference, i) => {
-                const relationshipFileInfo = documentRelationships.find((rel) => rel.id === reference.id);
-
-                if (relationshipFileInfo === null || !relationshipFileInfo) {
-                    throw new Error(`Can not find target file for id ${reference.id}`);
-                }
-
-                const xmlData = await zipContent.files[`word/${relationshipFileInfo.target}`].async("text");
-                const xmlObj = xml2js(xmlData, { compact: false, captureSpacesBetweenElements: true }) as XMLElement;
-
-                if (!xmlObj.elements) {
-                    return undefined;
-                }
-
-                const xmlElement = xmlObj.elements.reduce((acc, current) => (current.name === "w:ftr" ? current : acc));
-
-                const importedComp = convertToXmlComponent(xmlElement) as ImportedXmlComponent;
-                const wrapper = new FooterWrapper(media, startingRelationshipId + i, importedComp);
-                await this.addRelationshipToWrapper(relationshipFileInfo, zipContent, wrapper, media);
-
-                return { type: reference.type, footer: wrapper };
-            })
-            .filter((x) => !!x) as Promise<IDocumentFooter>[];
-
-        return Promise.all(result);
-    }
-
-    private async createHeaders(
-        zipContent: JSZip,
-        documentRefs: IDocumentRefs,
-        documentRelationships: IRelationshipFileInfo[],
-        media: Media,
-        startingRelationshipId: number,
-    ): Promise<IDocumentHeader[]> {
-        const result = documentRefs.headers
-            .map(async (reference, i) => {
-                const relationshipFileInfo = documentRelationships.find((rel) => rel.id === reference.id);
-
-                if (relationshipFileInfo === null || !relationshipFileInfo) {
-                    throw new Error(`Can not find target file for id ${reference.id}`);
-                }
-
-                const xmlData = await zipContent.files[`word/${relationshipFileInfo.target}`].async("text");
-                const xmlObj = xml2js(xmlData, { compact: false, captureSpacesBetweenElements: true }) as XMLElement;
-
-                if (!xmlObj.elements) {
-                    return undefined;
-                }
-
-                const xmlElement = xmlObj.elements.reduce((acc, current) => (current.name === "w:hdr" ? current : acc));
-
-                const importedComp = convertToXmlComponent(xmlElement) as ImportedXmlComponent;
-                const wrapper = new HeaderWrapper(media, startingRelationshipId + i, importedComp);
-                await this.addRelationshipToWrapper(relationshipFileInfo, zipContent, wrapper, media);
-
-                return { type: reference.type, header: wrapper };
-            })
-            .filter((x) => !!x) as Promise<IDocumentHeader>[];
-
-        return Promise.all(result);
-    }
-
-    private async addRelationshipToWrapper(
-        relationshipFile: IRelationshipFileInfo,
-        zipContent: JSZip,
-        wrapper: HeaderWrapper | FooterWrapper,
-        media: Media,
-    ): Promise<void> {
-        const refFile = zipContent.files[`word/_rels/${relationshipFile.target}.rels`];
-
-        if (!refFile) {
-            return;
-        }
-
-        const xmlRef = await refFile.async("text");
-        const wrapperImagesReferences = this.findReferenceFiles(xmlRef).filter((r) => r.type === RelationshipType.IMAGE);
-        const hyperLinkReferences = this.findReferenceFiles(xmlRef).filter((r) => r.type === RelationshipType.HYPERLINK);
-
-        for (const r of wrapperImagesReferences) {
-            const bufferType = JSZip.support.arraybuffer ? "arraybuffer" : "nodebuffer";
-            const buffer = await zipContent.files[`word/${r.target}`].async(bufferType);
-            const mediaData = media.addMedia(buffer, {
-                width: 100,
-                height: 100,
-            });
-
-            wrapper.Relationships.createRelationship(
-                r.id,
-                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
-                `media/${mediaData.fileName}`,
-            );
-        }
-
-        for (const r of hyperLinkReferences) {
-            wrapper.Relationships.createRelationship(
-                r.id,
-                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
-                r.target,
-                TargetModeType.EXTERNAL,
-            );
-        }
-    }
-
-    private findReferenceFiles(xmlData: string): IRelationshipFileInfo[] {
-        const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
-        const relationXmlArray = Array.isArray(xmlObj.Relationships.Relationship)
-            ? xmlObj.Relationships.Relationship
-            : [xmlObj.Relationships.Relationship];
-        const relationships: IRelationshipFileInfo[] = relationXmlArray
-            .map((item: XMLElementCompact) => {
-                if (item._attributes === undefined) {
-                    throw Error("relationship element has no attributes");
-                }
-                return {
-                    id: this.parseRefId(item._attributes.Id as string),
-                    type: schemeToType[item._attributes.Type as string],
-                    target: item._attributes.Target as string,
-                };
-            })
-            .filter((item) => item.type !== null);
-        return relationships;
-    }
-
-    private extractDocumentRefs(xmlData: string): IDocumentRefs {
-        const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
-        const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"];
-
-        const headerProps: XMLElementCompact = sectionProp["w:headerReference"];
-        let headersXmlArray: XMLElementCompact[];
-        if (headerProps === undefined) {
-            headersXmlArray = [];
-        } else if (Array.isArray(headerProps)) {
-            headersXmlArray = headerProps;
-        } else {
-            headersXmlArray = [headerProps];
-        }
-        const headers = headersXmlArray.map((item) => {
-            if (item._attributes === undefined) {
-                throw Error("header reference element has no attributes");
-            }
-            return {
-                type: item._attributes["w:type"] as HeaderFooterReferenceType,
-                id: this.parseRefId(item._attributes["r:id"] as string),
-            };
-        });
-
-        const footerProps: XMLElementCompact = sectionProp["w:footerReference"];
-        let footersXmlArray: XMLElementCompact[];
-        if (footerProps === undefined) {
-            footersXmlArray = [];
-        } else if (Array.isArray(footerProps)) {
-            footersXmlArray = footerProps;
-        } else {
-            footersXmlArray = [footerProps];
-        }
-
-        const footers = footersXmlArray.map((item) => {
-            if (item._attributes === undefined) {
-                throw Error("footer reference element has no attributes");
-            }
-            return {
-                type: item._attributes["w:type"] as HeaderFooterReferenceType,
-                id: this.parseRefId(item._attributes["r:id"] as string),
-            };
-        });
-
-        return { headers, footers };
-    }
-
-    private checkIfTitlePageIsDefined(xmlData: string): boolean {
-        const xmlObj = xml2js(xmlData, { compact: true }) as XMLElementCompact;
-        const sectionProp = xmlObj["w:document"]["w:body"]["w:sectPr"];
-
-        return sectionProp["w:titlePg"] !== undefined;
-    }
-
-    private parseRefId(str: string): number {
-        const match = /^rId(\d+)$/.exec(str);
-        if (match === null) {
-            throw new Error("Invalid ref id");
-        }
-        return parseInt(match[1], 10);
-    }
-}

package/src/import-dotx/index.ts

@@ -1 +0,0 @@
-export * from "./import-dotx";