Version bump

build(deps-dev): bump eslint from 8.42.0 to 8.43.0

demo/2-declaritive-styles.ts

@@ -43,6 +43,15 @@ const doc = new Document({
                     color: "#FF0000",
                 },
             },
+            document: {
+                run: {
+                    size: "11pt",
+                    font: "Calibri",
+                },
+                paragraph: {
+                    alignment: AlignmentType.RIGHT,
+                },
+            },
         },
         paragraphStyles: [
             {

demo/35-hyperlinks.ts

@@ -4,6 +4,18 @@ import * as fs from "fs";
 import { Document, ExternalHyperlink, Footer, FootnoteReferenceRun, ImageRun, Packer, Paragraph, TextRun } from "docx";
 
 const doc = new Document({
+    styles: {
+        default: {
+            hyperlink: {
+                run: {
+                    color: "FF0000",
+                    underline: {
+                        color: "0000FF",
+                    },
+                },
+            },
+        },
+    },
     footnotes: {
         1: {
             children: [

demo/90-check-boxes.ts

@@ -0,0 +1,44 @@
+// Simple example to add check boxes to a document
+import * as fs from "fs";
+import { Document, Packer, Paragraph, TextRun, CheckBox } from "docx";
+
+const doc = new Document({
+    sections: [
+        {
+            properties: {},
+            children: [
+                new Paragraph({
+                    children: [
+                        new TextRun("Hello World"),
+                        new TextRun({ break: 1 }),
+                        new CheckBox(),
+                        new TextRun({ break: 1 }),
+                        new CheckBox({ checked: true }),
+                        new TextRun({ break: 1 }),
+                        new CheckBox({ checked: true, checkedState: { value: "2611" } }),
+                        new TextRun({ break: 1 }),
+                        new CheckBox({ checked: true, checkedState: { value: "2611", font: "MS Gothic" } }),
+                        new TextRun({ break: 1 }),
+                        new CheckBox({
+                            checked: true,
+                            checkedState: { value: "2611", font: "MS Gothic" },
+                            uncheckedState: { value: "2610", font: "MS Gothic" },
+                        }),
+                        new TextRun({ break: 1 }),
+                        new CheckBox({
+                            checked: true,
+                            checkedState: { value: "2611", font: "MS Gothic" },
+                            uncheckedState: { value: "2610", font: "MS Gothic" },
+                        }),
+                        new TextRun({ text: "Are you ok?", break: 1 }),
+                        new CheckBox({ checked: true, alias: "Are you ok?" }),
+                    ],
+                }),
+            ],
+        },
+    ],
+});
+
+Packer.toBuffer(doc).then((buffer) => {
+    fs.writeFileSync("My Document.docx", buffer);
+});

package.json

@@ -1,6 +1,6 @@
 {
     "name": "docx",
-    "version": "8.1.0",
+    "version": "8.2.0",
     "description": "Easily generate .docx files with JS/TS with a nice declarative API. Works for Node and on the Browser.",
     "type": "module",
     "main": "build/index.umd.cjs",

src/file/checkbox/checkbox-symbol.ts

@@ -0,0 +1,29 @@
+// This represents element type CT_SdtCheckboxSymbol element
+// <xsd:complexType name="CT_SdtCheckboxSymbol">
+//   <xsd:attribute name="font" type="w:ST_String"/>
+//    <xsd:attribute name="val" type="w:ST_ShortHexNumber"/>
+// </xsd:complexType>
+
+import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
+import { shortHexNumber } from "@util/values";
+
+class CheckboxSymbolAttributes extends XmlAttributeComponent<{
+    readonly val?: string | number | boolean;
+    readonly symbolfont?: string;
+}> {
+    protected readonly xmlKeys = {
+        val: "w14:val",
+        symbolfont: "w14:font",
+    };
+}
+
+export class CheckBoxSymbolElement extends XmlComponent {
+    public constructor(name: string, val: string, font?: string) {
+        super(name);
+        if (font) {
+            this.root.push(new CheckboxSymbolAttributes({ val: shortHexNumber(val), symbolfont: font }));
+        } else {
+            this.root.push(new CheckboxSymbolAttributes({ val }));
+        }
+    }
+}

src/file/checkbox/checkbox-util.spec.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import { Formatter } from "@export/formatter";
+import { CheckBoxUtil } from ".";
+
+describe("CheckBoxUtil", () => {
+    describe("#constructor()", () => {
+        it("should create a CheckBoxUtil with proper root and default values", () => {
+            const checkBoxUtil = new CheckBoxUtil();
+
+            const tree = new Formatter().format(checkBoxUtil);
+
+            expect(tree).to.deep.equal({
+                "w14:checkbox": [
+                    {
+                        "w14:checked": {
+                            _attr: {
+                                "w14:val": "0",
+                            },
+                        },
+                    },
+                    {
+                        "w14:checkedState": {
+                            _attr: {
+                                "w14:font": "MS Gothic",
+                                "w14:val": "2612",
+                            },
+                        },
+                    },
+                    {
+                        "w14:uncheckedState": {
+                            _attr: {
+                                "w14:font": "MS Gothic",
+                                "w14:val": "2610",
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+
+        it("should create a CheckBoxUtil with proper structure and custom values", () => {
+            const checkBoxUtil = new CheckBoxUtil({
+                checked: true,
+                checkedState: {
+                    value: "2713",
+                    font: "Segoe UI Symbol",
+                },
+                uncheckedState: {
+                    value: "2705",
+                    font: "Segoe UI Symbol",
+                },
+            });
+
+            const tree = new Formatter().format(checkBoxUtil);
+
+            expect(tree).to.deep.equal({
+                "w14:checkbox": [
+                    {
+                        "w14:checked": {
+                            _attr: {
+                                "w14:val": "1",
+                            },
+                        },
+                    },
+                    {
+                        "w14:checkedState": {
+                            _attr: {
+                                "w14:font": "Segoe UI Symbol",
+                                "w14:val": "2713",
+                            },
+                        },
+                    },
+                    {
+                        "w14:uncheckedState": {
+                            _attr: {
+                                "w14:font": "Segoe UI Symbol",
+                                "w14:val": "2705",
+                            },
+                        },
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/checkbox/checkbox-util.ts

@@ -0,0 +1,45 @@
+// <xsd:complexType name="CT_SdtCheckbox">
+//    <xsd:sequence>
+//        <xsd:element name="checked" type="CT_OnOff" minOccurs="0"/>
+//        <xsd:element name="checkedState" type="CT_SdtCheckboxSymbol" minOccurs="0"/>
+//        <xsd:element name="uncheckedState" type="CT_SdtCheckboxSymbol" minOccurs="0"/>
+//    </xsd:sequence>
+// </xsd:complexType>
+// <xsd:element name="checkbox" type="CT_SdtCheckbox"/>
+
+import { XmlComponent } from "@file/xml-components";
+import { CheckBoxSymbolElement } from "@file/checkbox/checkbox-symbol";
+
+export interface ICheckboxSymbolProperties {
+    readonly value?: string;
+    readonly font?: string;
+}
+
+export interface ICheckboxSymbolOptions {
+    readonly alias?: string;
+    readonly checked?: boolean;
+    readonly checkedState?: ICheckboxSymbolProperties;
+    readonly uncheckedState?: ICheckboxSymbolProperties;
+}
+
+export class CheckBoxUtil extends XmlComponent {
+    private readonly DEFAULT_UNCHECKED_SYMBOL: string = "2610";
+    private readonly DEFAULT_CHECKED_SYMBOL: string = "2612";
+    private readonly DEFAULT_FONT: string = "MS Gothic";
+    public constructor(options?: ICheckboxSymbolOptions) {
+        super("w14:checkbox");
+
+        const value = options?.checked ? "1" : "0";
+        let symbol: string;
+        let font: string;
+        this.root.push(new CheckBoxSymbolElement("w14:checked", value));
+
+        symbol = options?.checkedState?.value ? options?.checkedState?.value : this.DEFAULT_CHECKED_SYMBOL;
+        font = options?.checkedState?.font ? options?.checkedState?.font : this.DEFAULT_FONT;
+        this.root.push(new CheckBoxSymbolElement("w14:checkedState", symbol, font));
+
+        symbol = options?.uncheckedState?.value ? options?.uncheckedState?.value : this.DEFAULT_UNCHECKED_SYMBOL;
+        font = options?.uncheckedState?.font ? options?.uncheckedState?.font : this.DEFAULT_FONT;
+        this.root.push(new CheckBoxSymbolElement("w14:uncheckedState", symbol, font));
+    }
+}

src/file/checkbox/checkbox.spec.ts

@@ -0,0 +1,213 @@
+import { describe, expect, it } from "vitest";
+import { Formatter } from "@export/formatter";
+
+import { CheckBox } from "./checkbox";
+
+describe("CheckBox", () => {
+    describe("#constructor()", () => {
+        it("should create a CheckBox with proper root and default values (no alias, no custom state)", () => {
+            const checkBox = new CheckBox();
+
+            const tree = new Formatter().format(checkBox);
+
+            expect(tree).to.deep.equal({
+                "w:sdt": [
+                    {
+                        "w:sdtPr": [
+                            {
+                                "w14:checkbox": [
+                                    {
+                                        "w14:checked": {
+                                            _attr: {
+                                                "w14:val": "0",
+                                            },
+                                        },
+                                    },
+                                    {
+                                        "w14:checkedState": {
+                                            _attr: {
+                                                "w14:font": "MS Gothic",
+                                                "w14:val": "2612",
+                                            },
+                                        },
+                                    },
+                                    {
+                                        "w14:uncheckedState": {
+                                            _attr: {
+                                                "w14:font": "MS Gothic",
+                                                "w14:val": "2610",
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "w:sdtContent": [
+                            {
+                                "w:r": [
+                                    {
+                                        "w:sym": {
+                                            _attr: {
+                                                "w:char": "2610",
+                                                "w:font": "MS Gothic",
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+
+        it.each([
+            ["2713", "Segoe UI Symbol", "2713", "Segoe UI Symbol"],
+            [undefined, undefined, "2612", "MS Gothic"],
+        ])("should create a CheckBox with proper root and custom values", (inputChar, inputFont, actualChar, actualFont) => {
+            const checkBox = new CheckBox({
+                alias: "Custom Checkbox",
+                checked: true,
+                checkedState: {
+                    value: inputChar,
+                    font: inputFont,
+                },
+                uncheckedState: {
+                    value: "2705",
+                    font: "Segoe UI Symbol",
+                },
+            });
+
+            const tree = new Formatter().format(checkBox);
+
+            expect(tree).to.deep.equal({
+                "w:sdt": [
+                    {
+                        "w:sdtPr": [
+                            {
+                                "w:alias": {
+                                    _attr: {
+                                        "w:val": "Custom Checkbox",
+                                    },
+                                },
+                            },
+                            {
+                                "w14:checkbox": [
+                                    {
+                                        "w14:checked": {
+                                            _attr: {
+                                                "w14:val": "1",
+                                            },
+                                        },
+                                    },
+                                    {
+                                        "w14:checkedState": {
+                                            _attr: {
+                                                "w14:font": actualFont,
+                                                "w14:val": actualChar,
+                                            },
+                                        },
+                                    },
+                                    {
+                                        "w14:uncheckedState": {
+                                            _attr: {
+                                                "w14:font": "Segoe UI Symbol",
+                                                "w14:val": "2705",
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "w:sdtContent": [
+                            {
+                                "w:r": [
+                                    {
+                                        "w:sym": {
+                                            _attr: {
+                                                "w:char": actualChar,
+                                                "w:font": actualFont,
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+
+        it("should create a CheckBox with proper root, custom state, and no alias", () => {
+            const checkBox = new CheckBox({
+                checked: false,
+                checkedState: {
+                    value: "2713",
+                    font: "Segoe UI Symbol",
+                },
+                uncheckedState: {
+                    value: "2705",
+                    font: "Segoe UI Symbol",
+                },
+            });
+
+            const tree = new Formatter().format(checkBox);
+
+            expect(tree).to.deep.equal({
+                "w:sdt": [
+                    {
+                        "w:sdtPr": [
+                            {
+                                "w14:checkbox": [
+                                    {
+                                        "w14:checked": {
+                                            _attr: {
+                                                "w14:val": "0",
+                                            },
+                                        },
+                                    },
+                                    {
+                                        "w14:checkedState": {
+                                            _attr: {
+                                                "w14:font": "Segoe UI Symbol",
+                                                "w14:val": "2713",
+                                            },
+                                        },
+                                    },
+                                    {
+                                        "w14:uncheckedState": {
+                                            _attr: {
+                                                "w14:font": "Segoe UI Symbol",
+                                                "w14:val": "2705",
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        "w:sdtContent": [
+                            {
+                                "w:r": [
+                                    {
+                                        "w:sym": {
+                                            _attr: {
+                                                "w:char": "2705",
+                                                "w:font": "Segoe UI Symbol",
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+});

src/file/checkbox/checkbox.ts

@@ -0,0 +1,43 @@
+import { SymbolRun } from "@file/paragraph/run/symbol-run";
+import { StructuredDocumentTagProperties } from "@file/table-of-contents/sdt-properties";
+import { StructuredDocumentTagContent } from "@file/table-of-contents/sdt-content";
+import { XmlComponent } from "@file/xml-components";
+import { CheckBoxUtil, ICheckboxSymbolOptions } from "./checkbox-util";
+
+export class CheckBox extends XmlComponent {
+    // default values per Microsoft
+    private readonly DEFAULT_UNCHECKED_SYMBOL: string = "2610";
+    private readonly DEFAULT_CHECKED_SYMBOL: string = "2612";
+    private readonly DEFAULT_FONT: string = "MS Gothic";
+    public constructor(options?: ICheckboxSymbolOptions) {
+        super("w:sdt");
+
+        const properties = new StructuredDocumentTagProperties(options?.alias);
+        properties.addChildElement(new CheckBoxUtil(options));
+        this.root.push(properties);
+
+        const content = new StructuredDocumentTagContent();
+        const checkedFont: string | undefined = options?.checkedState?.font;
+        const checkedText: string | undefined = options?.checkedState?.value;
+        const uncheckedFont: string | undefined = options?.uncheckedState?.font;
+        const uncheckedText: string | undefined = options?.uncheckedState?.value;
+        let symbolFont: string;
+        let char: string;
+
+        if (options?.checked) {
+            symbolFont = checkedFont ? checkedFont : this.DEFAULT_FONT;
+            char = checkedText ? checkedText : this.DEFAULT_CHECKED_SYMBOL;
+        } else {
+            symbolFont = uncheckedFont ? uncheckedFont : this.DEFAULT_FONT;
+            char = uncheckedText ? uncheckedText : this.DEFAULT_UNCHECKED_SYMBOL;
+        }
+
+        const initialRenderedChar = new SymbolRun({
+            char: char,
+            symbolfont: symbolFont,
+        });
+
+        content.addChildElement(initialRenderedChar);
+        this.root.push(content);
+    }
+}

src/file/checkbox/index.ts

@@ -0,0 +1,3 @@
+export * from "./checkbox-util";
+export * from "./checkbox-symbol";
+export * from "./checkbox";

src/file/index.ts

@@ -17,3 +17,4 @@ export * from "./track-revision";
 export * from "./shared";
 export * from "./border";
 export * from "./vertical-align";
+export * from "./checkbox";

src/file/paragraph/paragraph.ts

@@ -6,6 +6,7 @@ import { FileChild } from "@file/file-child";
 
 import { TargetModeType } from "../relationships/relationship/relationship";
 import { DeletedTextRun, InsertedTextRun } from "../track-revision";
+import { CheckBox } from "../checkbox";
 import { ColumnBreak, PageBreak } from "./formatting/break";
 import { Bookmark, ConcreteHyperlink, ExternalHyperlink, InternalHyperlink } from "./links";
 import { Math } from "./math";
@@ -33,7 +34,8 @@ export type ParagraphChild =
     | Comment
     | CommentRangeStart
     | CommentRangeEnd
-    | CommentReference;
+    | CommentReference
+    | CheckBox;
 
 export interface IParagraphOptions extends IParagraphPropertiesOptions {
     readonly text?: string;

src/file/styles/style/default-styles.spec.ts

@@ -318,4 +318,45 @@ describe("Default Styles", () => {
             ],
         });
     });
+
+    it("HyperlinkStyle#constructor", () => {
+        const style = new defaultStyles.HyperlinkStyle({
+            run: {
+                color: "FF0000",
+                underline: {
+                    color: "0000FF",
+                },
+            },
+        });
+        const tree = new Formatter().format(style);
+        expect(tree).to.deep.equal({
+            "w:style": [
+                { _attr: { "w:type": "character", "w:styleId": "Hyperlink" } },
+                { "w:name": { _attr: { "w:val": "Hyperlink" } } },
+                { "w:basedOn": { _attr: { "w:val": "DefaultParagraphFont" } } },
+                {
+                    "w:uiPriority": {
+                        _attr: {
+                            "w:val": 99,
+                        },
+                    },
+                },
+                {
+                    "w:unhideWhenUsed": EMPTY_OBJECT,
+                },
+                {
+                    "w:rPr": [
+                        { "w:u": { _attr: { "w:color": "0000FF", "w:val": "single" } } },
+                        {
+                            "w:color": {
+                                _attr: {
+                                    "w:val": "FF0000",
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
 });

src/file/styles/style/default-styles.ts

@@ -8,10 +8,10 @@ import { IBaseParagraphStyleOptions, IParagraphStyleOptions, StyleForParagraph }
 export class HeadingStyle extends StyleForParagraph {
     public constructor(options: IParagraphStyleOptions) {
         super({
-            ...options,
             basedOn: "Normal",
             next: "Normal",
             quickFormat: true,
+            ...options,
         });
     }
 }
@@ -19,9 +19,9 @@ export class HeadingStyle extends StyleForParagraph {
 export class TitleStyle extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Title",
             name: "Title",
+            ...options,
         });
     }
 }
@@ -29,9 +29,9 @@ export class TitleStyle extends HeadingStyle {
 export class Heading1Style extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Heading1",
             name: "Heading 1",
+            ...options,
         });
     }
 }
@@ -39,9 +39,9 @@ export class Heading1Style extends HeadingStyle {
 export class Heading2Style extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Heading2",
             name: "Heading 2",
+            ...options,
         });
     }
 }
@@ -49,9 +49,9 @@ export class Heading2Style extends HeadingStyle {
 export class Heading3Style extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Heading3",
             name: "Heading 3",
+            ...options,
         });
     }
 }
@@ -59,9 +59,9 @@ export class Heading3Style extends HeadingStyle {
 export class Heading4Style extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Heading4",
             name: "Heading 4",
+            ...options,
         });
     }
 }
@@ -69,9 +69,9 @@ export class Heading4Style extends HeadingStyle {
 export class Heading5Style extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Heading5",
             name: "Heading 5",
+            ...options,
         });
     }
 }
@@ -79,9 +79,9 @@ export class Heading5Style extends HeadingStyle {
 export class Heading6Style extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Heading6",
             name: "Heading 6",
+            ...options,
         });
     }
 }
@@ -89,9 +89,9 @@ export class Heading6Style extends HeadingStyle {
 export class StrongStyle extends HeadingStyle {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "Strong",
             name: "Strong",
+            ...options,
         });
     }
 }
@@ -99,11 +99,11 @@ export class StrongStyle extends HeadingStyle {
 export class ListParagraph extends StyleForParagraph {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "ListParagraph",
             name: "List Paragraph",
             basedOn: "Normal",
             quickFormat: true,
+            ...options,
         });
     }
 }
@@ -111,7 +111,6 @@ export class ListParagraph extends StyleForParagraph {
 export class FootnoteText extends StyleForParagraph {
     public constructor(options: IBaseParagraphStyleOptions) {
         super({
-            ...options,
             id: "FootnoteText",
             name: "footnote text",
             link: "FootnoteTextChar",
@@ -129,6 +128,7 @@ export class FootnoteText extends StyleForParagraph {
             run: {
                 size: 20,
             },
+            ...options,
         });
     }
 }
@@ -136,7 +136,6 @@ export class FootnoteText extends StyleForParagraph {
 export class FootnoteReferenceStyle extends StyleForCharacter {
     public constructor(options: IBaseCharacterStyleOptions) {
         super({
-            ...options,
             id: "FootnoteReference",
             name: "footnote reference",
             basedOn: "DefaultParagraphFont",
@@ -144,6 +143,7 @@ export class FootnoteReferenceStyle extends StyleForCharacter {
             run: {
                 superScript: true,
             },
+            ...options,
         });
     }
 }
@@ -151,7 +151,6 @@ export class FootnoteReferenceStyle extends StyleForCharacter {
 export class FootnoteTextChar extends StyleForCharacter {
     public constructor(options: IBaseCharacterStyleOptions) {
         super({
-            ...options,
             id: "FootnoteTextChar",
             name: "Footnote Text Char",
             basedOn: "DefaultParagraphFont",
@@ -160,6 +159,7 @@ export class FootnoteTextChar extends StyleForCharacter {
             run: {
                 size: 20,
             },
+            ...options,
         });
     }
 }
@@ -167,7 +167,6 @@ export class FootnoteTextChar extends StyleForCharacter {
 export class HyperlinkStyle extends StyleForCharacter {
     public constructor(options: IBaseCharacterStyleOptions) {
         super({
-            ...options,
             id: "Hyperlink",
             name: "Hyperlink",
             basedOn: "DefaultParagraphFont",
@@ -177,6 +176,7 @@ export class HyperlinkStyle extends StyleForCharacter {
                     type: UnderlineType.SINGLE,
                 },
             },
+            ...options,
         });
     }
 }

src/file/table-of-contents/sdt-properties.ts

@@ -2,8 +2,11 @@
 import { StringValueElement, XmlComponent } from "@file/xml-components";
 
 export class StructuredDocumentTagProperties extends XmlComponent {
-    public constructor(alias: string) {
+    public constructor(alias?: string) {
         super("w:sdtPr");
+
+        if (alias) {
             this.root.push(new StringValueElement("w:alias", alias));
         }
     }
+}

src/patcher/content-types-manager.spec.ts

@@ -47,5 +47,31 @@ describe("content-types-manager", () => {
                 type: "element",
             });
         });
+
+        it("should not append duplicate content type", () => {
+            const element = {
+                type: "element",
+                name: "xml",
+                elements: [
+                    {
+                        type: "element",
+                        name: "Types",
+                        elements: [
+                            {
+                                type: "element",
+                                name: "Default",
+                                attributes: {
+                                    ContentType: "image/png",
+                                    Extension: "png",
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            appendContentType(element, "image/png", "png");
+
+            expect(element.elements.length).toBe(1);
+        });
     });
 });

src/patcher/content-types-manager.ts

@@ -4,6 +4,18 @@ import { getFirstLevelElements } from "./util";
 
 export const appendContentType = (element: Element, contentType: string, extension: string): void => {
     const relationshipElements = getFirstLevelElements(element, "Types");
+
+    const exist = relationshipElements.some(
+        (el) =>
+            el.type === "element" &&
+            el.name === "Default" &&
+            el?.attributes?.ContentType === contentType &&
+            el?.attributes?.Extension === extension,
+    );
+    if (exist) {
+        return;
+    }
+
     // eslint-disable-next-line functional/immutable-data
     relationshipElements.push({
         attributes: {