docx 7.8.2 → 8.0.1

package/src/file/table/table-properties/table-cell-margin.spec.ts

@@ -1,97 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { WidthType } from "../table-width";
-
-import { TableCellMargin, TableCellMarginElementType } from "./table-cell-margin";
-
-describe("TableCellMargin", () => {
-    describe("#constructor", () => {
-        it("should throw an error if theres no child elements", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {});
-            expect(() => new Formatter().format(cellMargin)).to.throw();
-        });
-    });
-
-    describe("#addTopMargin", () => {
-        it("should add a table cell top margin", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                marginUnitType: WidthType.DXA,
-                top: 1234,
-            });
-
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:top": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-
-        it("should add a table cell top margin using default width type", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                top: 1234,
-            });
-
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:top": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-    });
-
-    describe("#addLeftMargin", () => {
-        it("should add a table cell left margin", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                marginUnitType: WidthType.DXA,
-                left: 1234,
-            });
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:left": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-
-        it("should add a table cell left margin using default width type", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                left: 1234,
-            });
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:left": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-    });
-
-    describe("#addBottomMargin", () => {
-        it("should add a table cell bottom margin", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                marginUnitType: WidthType.DXA,
-                bottom: 1234,
-            });
-
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:bottom": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-
-        it("should add a table cell bottom margin using default width type", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                bottom: 1234,
-            });
-
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:bottom": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-    });
-
-    describe("#addRightMargin", () => {
-        it("should add a table cell right margin", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                marginUnitType: WidthType.DXA,
-                right: 1234,
-            });
-
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:right": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-
-        it("should add a table cell right margin using default width type", () => {
-            const cellMargin = new TableCellMargin(TableCellMarginElementType.TABLE, {
-                right: 1234,
-            });
-
-            const tree = new Formatter().format(cellMargin);
-            expect(tree).to.deep.equal({ "w:tblCellMar": [{ "w:right": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] });
-        });
-    });
-});

package/src/file/table/table-properties/table-cell-margin.ts

@@ -1,64 +0,0 @@
-import { IgnoreIfEmptyXmlComponent } from "@file/xml-components";
-import { TableWidthElement, WidthType } from "../table-width";
-
-export interface ITableCellMarginOptions {
-    readonly marginUnitType?: WidthType;
-    readonly top?: number;
-    readonly bottom?: number;
-    readonly left?: number;
-    readonly right?: number;
-}
-
-// Technically two different types, but they're identical
-//
-// <xsd:complexType name="CT_TcMar">
-//     <xsd:sequence>
-//     <xsd:element name="top" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="start" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="left" type="CT_TblWidth" minOccurs="0"/>
-//     <xsd:element name="bottom" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="end" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="right" type="CT_TblWidth" minOccurs="0"/>
-//     </xsd:sequence>
-// </xsd:complexType>
-
-// <xsd:complexType name="CT_TblCellMar">
-//     <xsd:sequence>
-//     <xsd:element name="top" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="start" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="left" type="CT_TblWidth" minOccurs="0"/>
-//     <xsd:element name="bottom" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="end" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//     <xsd:element name="right" type="CT_TblWidth" minOccurs="0"/>
-//     </xsd:sequence>
-// </xsd:complexType>
-
-export enum TableCellMarginElementType {
-    TABLE = "w:tblCellMar",
-    TABLE_CELL = "w:tcMar",
-}
-
-export class TableCellMargin extends IgnoreIfEmptyXmlComponent {
-    public constructor(
-        type: TableCellMarginElementType,
-        { marginUnitType = WidthType.DXA, top, left, bottom, right }: ITableCellMarginOptions,
-    ) {
-        super(type);
-
-        if (top !== undefined) {
-            this.root.push(new TableWidthElement("w:top", { type: marginUnitType, size: top }));
-        }
-
-        if (left !== undefined) {
-            this.root.push(new TableWidthElement("w:left", { type: marginUnitType, size: left }));
-        }
-
-        if (bottom !== undefined) {
-            this.root.push(new TableWidthElement("w:bottom", { type: marginUnitType, size: bottom }));
-        }
-
-        if (right !== undefined) {
-            this.root.push(new TableWidthElement("w:right", { type: marginUnitType, size: right }));
-        }
-    }
-}

package/src/file/table/table-properties/table-float-properties.spec.ts

@@ -1,73 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import {
-    OverlapType,
-    RelativeHorizontalPosition,
-    RelativeVerticalPosition,
-    TableAnchorType,
-    TableFloatProperties,
-} from "./table-float-properties";
-
-describe("Table Float Properties", () => {
-    describe("#constructor", () => {
-        it("should construct a TableFloatProperties with all options", () => {
-            const properties = new TableFloatProperties({
-                horizontalAnchor: TableAnchorType.MARGIN,
-                verticalAnchor: TableAnchorType.PAGE,
-                absoluteHorizontalPosition: 10,
-                relativeHorizontalPosition: RelativeHorizontalPosition.CENTER,
-                absoluteVerticalPosition: 20,
-                relativeVerticalPosition: RelativeVerticalPosition.BOTTOM,
-                bottomFromText: 30,
-                topFromText: 40,
-                leftFromText: 50,
-                rightFromText: 60,
-            });
-            const tree = new Formatter().format(properties);
-            expect(tree).to.deep.equal(DEFAULT_TFP);
-        });
-
-        it("should add overlap", () => {
-            const properties = new TableFloatProperties({
-                overlap: OverlapType.NEVER,
-            });
-            const tree = new Formatter().format(properties);
-
-            expect(tree).to.deep.equal({
-                "w:tblpPr": [
-                    {
-                        _attr: {
-                            overlap: "never",
-                        },
-                    },
-                    {
-                        "w:tblOverlap": {
-                            _attr: {
-                                "w:val": "never",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});
-
-const DEFAULT_TFP = {
-    "w:tblpPr": {
-        _attr: {
-            "w:horzAnchor": "margin",
-            "w:vertAnchor": "page",
-            "w:tblpX": 10,
-            "w:tblpXSpec": "center",
-            "w:tblpY": 20,
-            "w:tblpYSpec": "bottom",
-            "w:bottomFromText": 30,
-            "w:topFromText": 40,
-            "w:leftFromText": 50,
-            "w:rightFromText": 60,
-        },
-    },
-};

package/src/file/table/table-properties/table-float-properties.ts

@@ -1,189 +0,0 @@
-import { StringEnumValueElement, XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { signedTwipsMeasureValue, twipsMeasureValue } from "@util/values";
-
-export enum TableAnchorType {
-    MARGIN = "margin",
-    PAGE = "page",
-    TEXT = "text",
-}
-
-export enum RelativeHorizontalPosition {
-    CENTER = "center",
-    INSIDE = "inside",
-    LEFT = "left",
-    OUTSIDE = "outside",
-    RIGHT = "right",
-}
-
-export enum RelativeVerticalPosition {
-    CENTER = "center",
-    INSIDE = "inside",
-    BOTTOM = "bottom",
-    OUTSIDE = "outside",
-    INLINE = "inline",
-    TOP = "top",
-}
-
-// <xsd:simpleType name="ST_TblOverlap">
-//     <xsd:restriction base="xsd:string">
-//         <xsd:enumeration value="never"/>
-//         <xsd:enumeration value="overlap"/>
-//     </xsd:restriction>
-// </xsd:simpleType>
-export enum OverlapType {
-    NEVER = "never",
-    OVERLAP = "overlap",
-}
-
-export interface ITableFloatOptions {
-    /* cSpell:disable */
-    /**
-     * Specifies the horizontal anchor or the base object from which the horizontal positioning in the
-     * tblpX or tblpXSpec attribute should be determined.
-     * margin - relative to the vertical edge of the text margin before any text runs (left edge for left-to-right paragraphs)
-     * page - relative to the vertical edge of the page before any text runs (left edge for left-to-right paragraphs)
-     * text - relative to the vertical edge of the text margin for the column in which the anchor paragraph is located
-     * If omitted, the value is assumed to be page.
-     */
-    /* cSpell:enable */
-    readonly horizontalAnchor?: TableAnchorType;
-
-    /**
-     * Specifies an absolute horizontal position for the table, relative to the horizontalAnchor.
-     * The value is in twentieths of a point. Note that the value can be negative, in which case the
-     * table is positioned before the anchor object in the direction of horizontal text flow.
-     * If relativeHorizontalPosition is also specified, then the absoluteHorizontalPosition attribute is ignored.
-     * If the attribute is omitted, the value is assumed to be zero.
-     */
-    readonly absoluteHorizontalPosition?: number | string;
-
-    /**
-     * Specifies a relative horizontal position for the table, relative to the horizontalAnchor attribute.
-     * This will supersede the absoluteHorizontalPosition attribute.
-     * Possible values are:
-     * center - the table should be horizontally centered with respect to the anchor
-     * inside - the table should be inside of the anchor
-     * left - the table should be left aligned with respect to the anchor
-     * outside - the table should be outside of the anchor
-     * right - the table should be right aligned with respect to the anchor
-     */
-    readonly relativeHorizontalPosition?: RelativeHorizontalPosition;
-
-    /**
-     * Specifies the vertical anchor or the base object from which the vertical positioning
-     * in the absoluteVerticalPosition attribute should be determined. Possible values are:
-     * margin - relative to the horizontal edge of the text margin before any text runs (top edge for top-to-bottom paragraphs)
-     * page - relative to the horizontal edge of the page before any text runs (top edge for top-to-bottom paragraphs)
-     * text - relative to the horizontal edge of the text margin for the column in which the anchor paragraph is located
-     * If omitted, the value is assumed to be page.
-     */
-    readonly verticalAnchor?: TableAnchorType;
-
-    /**
-     * Specifies an absolute vertical position for the table, relative to the verticalAnchor anchor.
-     * The value is in twentieths of a point. Note that the value can be negative, in which case the table is
-     * positioned before the anchor object in the direction of vertical text flow.
-     * If relativeVerticalPosition is also specified, then the absoluteVerticalPosition attribute is ignored.
-     * If the attribute is omitted, the value is assumed to be zero.
-     */
-    readonly absoluteVerticalPosition?: number | string;
-
-    /**
-     * Specifies a relative vertical position for the table, relative to the verticalAnchor attribute.
-     * This will supersede the absoluteVerticalPosition attribute. Possible values are:
-     * center - the table should be vertically centered with respect to the anchor
-     * inside - the table should be vertically aligned to the edge of the anchor and inside the anchor
-     * bottom - the table should be vertically aligned to the bottom edge of the anchor
-     * outside - the table should be vertically aligned to the edge of the anchor and outside the anchor
-     * inline - the table should be vertically aligned in line with the surrounding text (so as to not allow any text wrapping around it)
-     * top - the table should be vertically aligned to the top edge of the anchor
-     */
-    readonly relativeVerticalPosition?: RelativeVerticalPosition;
-
-    /**
-     * Specifies the minimum distance to be maintained between the table and the top of text in the paragraph
-     * below the table. The value is in twentieths of a point. If omitted, the value is assumed to be zero.
-     */
-    readonly bottomFromText?: number | string;
-
-    /**
-     * Specifies the minimum distance to be maintained between the table and the bottom edge of text in the paragraph
-     * above the table. The value is in twentieths of a point. If omitted, the value is assumed to be zero.
-     */
-    readonly topFromText?: number | string;
-
-    /**
-     * Specifies the minimum distance to be maintained between the table and the edge of text in the paragraph
-     * to the left of the table. The value is in twentieths of a point. If omitted, the value is assumed to be zero.
-     */
-    readonly leftFromText?: number | string;
-
-    /**
-     * Specifies the minimum distance to be maintained between the table and the edge of text in the paragraph
-     * to the right of the table. The value is in twentieths of a point. If omitted, the value is assumed to be zero.
-     */
-    readonly rightFromText?: number | string;
-    readonly overlap?: OverlapType;
-}
-
-// <xsd:complexType name="CT_TblPPr">
-//     <xsd:attribute name="leftFromText" type="s:ST_TwipsMeasure"/>
-//     <xsd:attribute name="rightFromText" type="s:ST_TwipsMeasure"/>
-//     <xsd:attribute name="topFromText" type="s:ST_TwipsMeasure"/>
-//     <xsd:attribute name="bottomFromText" type="s:ST_TwipsMeasure"/>
-//     <xsd:attribute name="vertAnchor" type="ST_VAnchor"/>
-//     <xsd:attribute name="horzAnchor" type="ST_HAnchor"/>
-//     <xsd:attribute name="tblpXSpec" type="s:ST_XAlign"/>
-//     <xsd:attribute name="tblpX" type="ST_SignedTwipsMeasure"/>
-//     <xsd:attribute name="tblpYSpec" type="s:ST_YAlign"/>
-//     <xsd:attribute name="tblpY" type="ST_SignedTwipsMeasure"/>
-// </xsd:complexType>
-
-export class TableFloatOptionsAttributes extends XmlAttributeComponent<ITableFloatOptions> {
-    protected readonly xmlKeys = {
-        horizontalAnchor: "w:horzAnchor",
-        verticalAnchor: "w:vertAnchor",
-        absoluteHorizontalPosition: "w:tblpX",
-        relativeHorizontalPosition: "w:tblpXSpec",
-        absoluteVerticalPosition: "w:tblpY",
-        relativeVerticalPosition: "w:tblpYSpec",
-        bottomFromText: "w:bottomFromText",
-        topFromText: "w:topFromText",
-        leftFromText: "w:leftFromText",
-        rightFromText: "w:rightFromText",
-    };
-}
-
-export class TableFloatProperties extends XmlComponent {
-    public constructor({
-        leftFromText,
-        rightFromText,
-        topFromText,
-        bottomFromText,
-        absoluteHorizontalPosition,
-        absoluteVerticalPosition,
-        ...options
-    }: ITableFloatOptions) {
-        super("w:tblpPr");
-        this.root.push(
-            new TableFloatOptionsAttributes({
-                leftFromText: leftFromText === undefined ? undefined : twipsMeasureValue(leftFromText),
-                rightFromText: rightFromText === undefined ? undefined : twipsMeasureValue(rightFromText),
-                topFromText: topFromText === undefined ? undefined : twipsMeasureValue(topFromText),
-                bottomFromText: bottomFromText === undefined ? undefined : twipsMeasureValue(bottomFromText),
-                absoluteHorizontalPosition:
-                    absoluteHorizontalPosition === undefined ? undefined : signedTwipsMeasureValue(absoluteHorizontalPosition),
-                absoluteVerticalPosition:
-                    absoluteVerticalPosition === undefined ? undefined : signedTwipsMeasureValue(absoluteVerticalPosition),
-                ...options,
-            }),
-        );
-
-        if (options.overlap) {
-            // <xsd:complexType name="CT_TblOverlap">
-            //     <xsd:attribute name="val" type="ST_TblOverlap" use="required"/>
-            // </xsd:complexType>
-            this.root.push(new StringEnumValueElement<OverlapType>("w:tblOverlap", options.overlap));
-        }
-    }
-}

package/src/file/table/table-properties/table-layout.ts

@@ -1,26 +0,0 @@
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-// <xsd:simpleType name="ST_TblLayoutType">
-//     <xsd:restriction base="xsd:string">
-//         <xsd:enumeration value="fixed"/>
-//         <xsd:enumeration value="autofit"/>
-//     </xsd:restriction>
-// </xsd:simpleType>
-export enum TableLayoutType {
-    AUTOFIT = "autofit",
-    FIXED = "fixed",
-}
-
-class TableLayoutAttributes extends XmlAttributeComponent<{ readonly type: TableLayoutType }> {
-    protected readonly xmlKeys = { type: "w:type" };
-}
-
-// <xsd:complexType name="CT_TblLayoutType">
-//     <xsd:attribute name="type" type="ST_TblLayoutType"/>
-// </xsd:complexType>
-export class TableLayout extends XmlComponent {
-    public constructor(type: TableLayoutType) {
-        super("w:tblLayout");
-        this.root.push(new TableLayoutAttributes({ type }));
-    }
-}

package/src/file/table/table-properties/table-properties.spec.ts

@@ -1,189 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { AlignmentType } from "@file/paragraph";
-import { ShadingType } from "@file/shading";
-
-import { WidthType } from "../table-width";
-import { TableLayoutType } from "./table-layout";
-import { TableProperties } from "./table-properties";
-
-describe("TableProperties", () => {
-    describe("#constructor", () => {
-        it("creates an initially empty property object", () => {
-            const tp = new TableProperties({});
-            // The TableProperties is ignorable if there are no attributes,
-            // which results in prepForXml returning undefined, which causes
-            // the formatter to throw an error if that is the only object it
-            // has been asked to format.
-            expect(() => new Formatter().format(tp)).to.throw("XMLComponent did not format correctly");
-        });
-
-        it("should add a table style property", () => {
-            const tp = new TableProperties({
-                style: "TableNormal",
-            });
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblStyle": { _attr: { "w:val": "TableNormal" } } }],
-            });
-        });
-
-        it("should add a table width property", () => {
-            const tp = new TableProperties({
-                width: {
-                    size: 1234,
-                    type: WidthType.DXA,
-                },
-            });
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblW": { _attr: { "w:type": "dxa", "w:w": 1234 } } }],
-            });
-        });
-
-        it("should add a table width property with default of AUTO", () => {
-            const tp = new TableProperties({
-                width: {
-                    size: 1234,
-                },
-            });
-
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblW": { _attr: { "w:type": "auto", "w:w": 1234 } } }],
-            });
-        });
-
-        it("should add a table indent property", () => {
-            const tp = new TableProperties({
-                indent: {
-                    size: 1234,
-                    type: WidthType.DXA,
-                },
-            });
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblInd": { _attr: { "w:type": "dxa", "w:w": 1234 } } }],
-            });
-        });
-
-        it("should add a table indent property with default of AUTO", () => {
-            const tp = new TableProperties({
-                indent: {
-                    size: 1234,
-                },
-            });
-
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblInd": { _attr: { "w:type": "auto", "w:w": 1234 } } }],
-            });
-        });
-
-        it("sets the table to fixed width layout", () => {
-            const tp = new TableProperties({
-                layout: TableLayoutType.FIXED,
-            });
-
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblLayout": { _attr: { "w:type": "fixed" } } }],
-            });
-        });
-    });
-
-    describe("#cellMargin", () => {
-        it("adds a table cell top margin", () => {
-            const tp = new TableProperties({
-                cellMargin: {
-                    marginUnitType: WidthType.DXA,
-                    top: 1234,
-                },
-            });
-
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblCellMar": [{ "w:top": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] }],
-            });
-        });
-
-        it("adds a table cell left margin", () => {
-            const tp = new TableProperties({
-                cellMargin: {
-                    marginUnitType: WidthType.DXA,
-                    left: 1234,
-                },
-            });
-
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [{ "w:tblCellMar": [{ "w:left": { _attr: { "w:type": "dxa", "w:w": 1234 } } }] }],
-            });
-        });
-    });
-
-    describe("#setShading", () => {
-        it("sets the shading of the table", () => {
-            const tp = new TableProperties({
-                shading: {
-                    fill: "b79c2f",
-                    type: ShadingType.REVERSE_DIAGONAL_STRIPE,
-                    color: "auto",
-                },
-            });
-
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [
-                    {
-                        "w:shd": {
-                            _attr: {
-                                "w:color": "auto",
-                                "w:fill": "b79c2f",
-                                "w:val": "reverseDiagStripe",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-
-    describe("#setAlignment", () => {
-        it("sets the alignment of the table", () => {
-            const tp = new TableProperties({
-                alignment: AlignmentType.CENTER,
-            });
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [
-                    {
-                        "w:jc": {
-                            _attr: {
-                                "w:val": "center",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-
-    describe("#Set Virtual Right to Left", () => {
-        it("sets the alignment of the table", () => {
-            const tp = new TableProperties({
-                visuallyRightToLeft: true,
-            });
-            const tree = new Formatter().format(tp);
-            expect(tree).to.deep.equal({
-                "w:tblPr": [
-                    {
-                        "w:bidiVisual": {},
-                    },
-                ],
-            });
-        });
-    });
-});