@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/settings/index.js

@@ -0,0 +1,829 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+export * from './attached-template';
+export * from './compat-settings';
+export * from './document-background';
+export * from './document-protection';
+export * from './document-settings-facades';
+export * from './document-settings-values';
+export * from './footnote-properties';
+export * from './settings-children';
+export * from './web-settings';
+export * from './zoom';
+/**
+ * WordDocument Settings feature (`word/settings.xml`).
+ *
+ * Load builds a typed child graph (`SettingsPart` → modeled/opaque nodes);
+ * dirty serialize emits only from that graph (not a flat element bag dump).
+ *
+ * @public
+ */
+import { DocxError } from '../../core/errors/docx-error';
+import { elementChildren, isWml, wmlElement } from '../document/wml';
+import { partName, resolveInternalTarget } from '../../core/opc/part-name';
+import { officeDocumentPartName, relationshipsForPart } from '../../core/opc/package';
+import { TargetMode } from '../../core/opc/relationships';
+import { featureId, registerFeature, registerFeaturePartHandler, registerFeatureMaterializeHandler, } from '../../core/registry/index';
+import { parseXml, serializeXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { CompatSettings } from './compat-settings';
+import { DocumentProtection } from './document-protection';
+import { createBackground } from './document-background';
+import { EndnoteProperties, FootnoteProperties, } from './footnote-properties';
+import { findChildIndex, parseSettingsChild, replaceOrInsertChild, serializeSettingsChildren, SettingsAttachedTemplateChild, SettingsCompatChild, SettingsDefaultTabStopChild, SettingsDocumentProtectionChild, SettingsCharacterSpacingControlChild, SettingsEndnotePrChild, SettingsFootnotePrChild, SettingsOnOffChild, SettingsViewChild, SettingsZoomChild, } from './settings-children';
+import { registerWebSettingsFeature, resetWebSettingsFeatureForTests, } from './web-settings';
+import { ZoomSettings } from './zoom';
+/**
+ * @private
+ */
+/**
+ * @private
+ */
+/**
+ * @private
+ */
+/**
+ * @private
+ */
+import { bindDocumentSettingsFacades, registerDocumentSettingsFacades, } from './document-settings-facades';
+var SETTINGS = featureId('settings');
+/**
+ * @private
+ * Transitional settings relationship (ECMA-376-4 §9.2.3). */
+export var SETTINGS_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings';
+/**
+ * @private
+ * Strict settings relationship (ECMA-376-1 §11.3.3). */
+export var STRICT_SETTINGS_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/settings';
+/**
+ * @private
+ * ECMA-376-1 §11.3.3 WordDocument Settings content type. */
+export var SETTINGS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml';
+/**
+ * @private
+ * Transitional attached-template relationship (ECMA-376-4 §14.12.22). */
+export var ATTACHED_TEMPLATE_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/attachedTemplate';
+/**
+ * @private
+ * Strict attached-template relationship (ECMA-376-1 §11.4). */
+export var STRICT_ATTACHED_TEMPLATE_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/attachedTemplate';
+var ATTACHED_TEMPLATE_RELATIONSHIP_TYPES = [
+    ATTACHED_TEMPLATE_RELATIONSHIP_TYPE,
+    STRICT_ATTACHED_TEMPLATE_RELATIONSHIP_TYPE,
+];
+/**
+ * @private
+ */
+export var SETTINGS_PART_NAME = partName('/word/settings.xml');
+var utf8Decoder = new TextDecoder('utf-8');
+var utf8 = new TextEncoder();
+function resolveSettingsPartName(pkg) {
+    var e_1, _a;
+    var main = officeDocumentPartName(pkg);
+    try {
+        for (var _b = __values(relationshipsForPart(pkg, main).items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (rel.type !== SETTINGS_RELATIONSHIP_TYPE &&
+                rel.type !== STRICT_SETTINGS_RELATIONSHIP_TYPE) {
+                continue;
+            }
+            return resolveInternalTarget(rel.target, main);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+function resolveAttachedTemplateTarget(pkg, settingsPartName, relationshipId) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(relationshipsForPart(pkg, settingsPartName).items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (rel.id !== relationshipId) {
+                continue;
+            }
+            if (ATTACHED_TEMPLATE_RELATIONSHIP_TYPES.indexOf(rel.type) === -1) {
+                return undefined;
+            }
+            if (rel.targetMode === TargetMode.External) {
+                return rel.target;
+            }
+            return resolveInternalTarget(rel.target, settingsPartName);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+/**
+ * In-memory WordDocument Settings part (`word/settings.xml`).
+ *
+ * Children are a typed ordered graph: modeled OnOff / protection / attachedTemplate /
+ * compat nodes plus opaque shells for the rest of `CT_Settings`.
+ *
+ * @private
+ */
+var SettingsPart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function SettingsPart(rootAttributes, rootNamespaceDeclarations, children, dirty) {
+        this.rootAttributes = rootAttributes;
+        this.rootNamespaceDeclarations = rootNamespaceDeclarations;
+        this.children = children;
+        this.dirty = dirty;
+    }
+    SettingsPart.prototype.findOnOff = function (localName) {
+        var index = findChildIndex(this.children, localName);
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        return child instanceof SettingsOnOffChild ? child : undefined;
+    };
+    SettingsPart.prototype.setOnOff = function (localName, value) {
+        replaceOrInsertChild(this.children, localName, value === undefined ? undefined : new SettingsOnOffChild(localName, value));
+        this.dirty = true;
+    };
+    /**
+     * `w:evenAndOddHeaders` as a boolean, or `undefined` when the element is absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.evenAndOddHeaders = function () {
+        var child = this.findOnOff('evenAndOddHeaders');
+        return child === undefined ? undefined : child.read();
+    };
+    /**
+     * Set or clear `w:evenAndOddHeaders`. `undefined` removes the element.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setEvenAndOddHeaders = function (value) {
+        this.setOnOff('evenAndOddHeaders', value);
+    };
+    /**
+     * `w:trackRevisions` as a boolean, or `undefined` when the element is absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.trackRevisions = function () {
+        var child = this.findOnOff('trackRevisions');
+        return child === undefined ? undefined : child.read();
+    };
+    /**
+     * Set or clear `w:trackRevisions`. `undefined` removes the element.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setTrackRevisions = function (value) {
+        this.setOnOff('trackRevisions', value);
+    };
+    /**
+     * Modeled `w:documentProtection` flags snapshot. Password/hash attributes are omitted.
+     *
+     * Prefer {@link documentProtectionNode} when the typed class is needed.
+     *
+     * @public
+     */
+    SettingsPart.prototype.documentProtection = function () {
+        var node = this.documentProtectionNode();
+        return node === undefined ? undefined : node.flags();
+    };
+    /**
+     * First-class `w:documentProtection` node, or `undefined` when absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.documentProtectionNode = function () {
+        var index = findChildIndex(this.children, 'documentProtection');
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        return child instanceof SettingsDocumentProtectionChild ? child.protection() : undefined;
+    };
+    /**
+     * Replace or remove `w:documentProtection`. Clearing the element also drops preserved
+     * password/hash attributes. Flag-only updates keep leftover attributes on the existing node.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setDocumentProtection = function (flags) {
+        if (flags === undefined) {
+            replaceOrInsertChild(this.children, 'documentProtection', undefined);
+            this.dirty = true;
+            return;
+        }
+        var existing = this.documentProtectionNode();
+        if (existing !== undefined) {
+            existing.applyFlags(flags);
+            this.dirty = true;
+            return;
+        }
+        replaceOrInsertChild(this.children, 'documentProtection', new SettingsDocumentProtectionChild(DocumentProtection.fromFlags(flags)));
+        this.dirty = true;
+    };
+    /**
+     * Whether `w:attachedTemplate` is present in settings.
+     *
+     * @public
+     */
+    SettingsPart.prototype.hasAttachedTemplate = function () {
+        return this.attachedTemplate() !== undefined;
+    };
+    /**
+     * First-class `w:attachedTemplate` node, or `undefined` when absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.attachedTemplate = function () {
+        var index = findChildIndex(this.children, 'attachedTemplate');
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        return child instanceof SettingsAttachedTemplateChild ? child.template() : undefined;
+    };
+    /**
+     * `r:id` on `w:attachedTemplate`, or `undefined` when absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.attachedTemplateRelationshipId = function () {
+        var template = this.attachedTemplate();
+        return template === undefined ? undefined : template.id();
+    };
+    /**
+     * First-class `w:compat` node, or `undefined` when absent.
+     *
+     * Mutations on the returned node (for example {@link CompatSettings.setNoColumnBalance})
+     * mark the settings part dirty.
+     *
+     * @public
+     */
+    SettingsPart.prototype.compat = function () {
+        var _this = this;
+        var index = findChildIndex(this.children, 'compat');
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        if (!(child instanceof SettingsCompatChild)) {
+            return undefined;
+        }
+        var compat = child.compat();
+        compat.bindDirty(function () {
+            _this.dirty = true;
+        });
+        return compat;
+    };
+    /**
+     * Ensure a `w:compat` node exists and return it.
+     *
+     * @private
+     */
+    SettingsPart.prototype.ensureCompat = function () {
+        var _this = this;
+        var existing = this.compat();
+        if (existing !== undefined) {
+            return existing;
+        }
+        var created = CompatSettings.createEmpty(function () {
+            _this.dirty = true;
+        });
+        replaceOrInsertChild(this.children, 'compat', new SettingsCompatChild(created));
+        this.dirty = true;
+        return created;
+    };
+    /**
+     * Names from `w:compat/w:compatSetting/@w:name`, in document order.
+     *
+     * @public
+     */
+    SettingsPart.prototype.compatSettingNames = function () {
+        var compat = this.compat();
+        return compat === undefined ? [] : compat.settingNames();
+    };
+    /**
+     * Count of `w:compatSetting` children under `w:compat`.
+     *
+     * @public
+     */
+    SettingsPart.prototype.compatSettingCount = function () {
+        var compat = this.compat();
+        return compat === undefined ? 0 : compat.settingCount();
+    };
+    /**
+     * `w:displayBackgroundShape` as a boolean, or `undefined` when the element is absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.displayBackgroundShape = function () {
+        var child = this.findOnOff('displayBackgroundShape');
+        return child === undefined ? undefined : child.read();
+    };
+    /**
+     * Set or clear `w:displayBackgroundShape`. `undefined` removes the element.
+     *
+     * @private
+     */
+    SettingsPart.prototype.setDisplayBackgroundShape = function (value) {
+        this.setOnOff('displayBackgroundShape', value);
+    };
+    // ── View ────────────────────────────────────────────────────────────────────
+    /**
+     * First-class `w:view` child, or `undefined` when absent.
+     *
+     * @private
+     */
+    SettingsPart.prototype.view = function () {
+        var index = findChildIndex(this.children, 'view');
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        return child instanceof SettingsViewChild ? child : undefined;
+    };
+    /**
+     * Set or clear `w:view`. `undefined` removes the element.
+     *
+     * Accepts a known {@link DocumentViewType}, wire string, or modeled child.
+     *
+     * @private
+     */
+    SettingsPart.prototype.setView = function (value) {
+        if (value === undefined) {
+            replaceOrInsertChild(this.children, 'view', undefined);
+            this.dirty = true;
+            return;
+        }
+        if (value instanceof SettingsViewChild) {
+            replaceOrInsertChild(this.children, 'view', value);
+            this.dirty = true;
+            return;
+        }
+        var wire = typeof value === 'string' ? value : value;
+        replaceOrInsertChild(this.children, 'view', new SettingsViewChild(wire));
+        this.dirty = true;
+    };
+    // ── Zoom ────────────────────────────────────────────────────────────────────
+    /**
+     * First-class `w:zoom` node, or `undefined` when absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.zoom = function () {
+        var index = findChildIndex(this.children, 'zoom');
+        if (index < 0)
+            return undefined;
+        var child = this.children[index];
+        return child instanceof SettingsZoomChild ? child.zoom() : undefined;
+    };
+    /**
+     * Set `w:zoom` from a {@link ZoomSettings} instance, or remove it when `undefined`.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setZoom = function (value) {
+        replaceOrInsertChild(this.children, 'zoom', value === undefined ? undefined : new SettingsZoomChild(value));
+        this.dirty = true;
+    };
+    // ── Footnote / endnote properties (document-level) ──────────────────────────
+    /**
+     * First-class `w:footnotePr` node, or `undefined` when absent.
+     *
+     * Mutations on the returned node mark the settings part dirty.
+     *
+     * @public
+     */
+    SettingsPart.prototype.footnoteProperties = function () {
+        var _this = this;
+        var index = findChildIndex(this.children, 'footnotePr');
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        if (!(child instanceof SettingsFootnotePrChild)) {
+            return undefined;
+        }
+        var props = child.props();
+        props.bindDirty(function () {
+            _this.dirty = true;
+        });
+        return props;
+    };
+    /**
+     * Ensure a `w:footnotePr` node exists and return it.
+     *
+     * @public
+     */
+    SettingsPart.prototype.ensureFootnoteProperties = function () {
+        var _this = this;
+        var existing = this.footnoteProperties();
+        if (existing !== undefined) {
+            return existing;
+        }
+        var props = FootnoteProperties.create();
+        props.bindDirty(function () {
+            _this.dirty = true;
+        });
+        replaceOrInsertChild(this.children, 'footnotePr', new SettingsFootnotePrChild(props));
+        this.dirty = true;
+        return props;
+    };
+    /**
+     * Replace or clear `w:footnotePr`. `undefined` removes the element.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setFootnoteProperties = function (value) {
+        var _this = this;
+        if (value === undefined) {
+            replaceOrInsertChild(this.children, 'footnotePr', undefined);
+            this.dirty = true;
+            return;
+        }
+        value.bindDirty(function () {
+            _this.dirty = true;
+        });
+        replaceOrInsertChild(this.children, 'footnotePr', new SettingsFootnotePrChild(value));
+        this.dirty = true;
+    };
+    /**
+     * First-class `w:endnotePr` node, or `undefined` when absent.
+     *
+     * Mutations on the returned node mark the settings part dirty.
+     *
+     * @public
+     */
+    SettingsPart.prototype.endnoteProperties = function () {
+        var _this = this;
+        var index = findChildIndex(this.children, 'endnotePr');
+        if (index < 0) {
+            return undefined;
+        }
+        var child = this.children[index];
+        if (!(child instanceof SettingsEndnotePrChild)) {
+            return undefined;
+        }
+        var props = child.props();
+        props.bindDirty(function () {
+            _this.dirty = true;
+        });
+        return props;
+    };
+    /**
+     * Ensure a `w:endnotePr` node exists and return it.
+     *
+     * @public
+     */
+    SettingsPart.prototype.ensureEndnoteProperties = function () {
+        var _this = this;
+        var existing = this.endnoteProperties();
+        if (existing !== undefined) {
+            return existing;
+        }
+        var props = EndnoteProperties.create();
+        props.bindDirty(function () {
+            _this.dirty = true;
+        });
+        replaceOrInsertChild(this.children, 'endnotePr', new SettingsEndnotePrChild(props));
+        this.dirty = true;
+        return props;
+    };
+    /**
+     * Replace or clear `w:endnotePr`. `undefined` removes the element.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setEndnoteProperties = function (value) {
+        var _this = this;
+        if (value === undefined) {
+            replaceOrInsertChild(this.children, 'endnotePr', undefined);
+            this.dirty = true;
+            return;
+        }
+        value.bindDirty(function () {
+            _this.dirty = true;
+        });
+        replaceOrInsertChild(this.children, 'endnotePr', new SettingsEndnotePrChild(value));
+        this.dirty = true;
+    };
+    // ── Default tab stop ────────────────────────────────────────────────────────
+    /**
+     * `w:defaultTabStop/@w:val` in plain points, or `undefined` when the element is absent.
+     * Wire unit is twips (`ST_TwipsMeasure`); conversion is at the parse/serialize boundary.
+     *
+     * The default value in Word is half an inch (`720` twips → `36` points).
+     *
+     * @public
+     */
+    SettingsPart.prototype.defaultTabStop = function () {
+        var index = findChildIndex(this.children, 'defaultTabStop');
+        if (index < 0)
+            return undefined;
+        var child = this.children[index];
+        return child instanceof SettingsDefaultTabStopChild ? child.read() : undefined;
+    };
+    /**
+     * Set or clear `w:defaultTabStop`. `undefined` removes the element.
+     *
+     * @param value - Plain points (e.g. `36` = 0.5 inch). Serialized as twips on the wire.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setDefaultTabStop = function (value) {
+        replaceOrInsertChild(this.children, 'defaultTabStop', value === undefined ? undefined : new SettingsDefaultTabStopChild(value));
+        this.dirty = true;
+    };
+    // ── Character spacing control ───────────────────────────────────────────────
+    /**
+     * `w:characterSpacingControl/@w:val`, or `undefined` when the element is absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.characterSpacingControl = function () {
+        var index = findChildIndex(this.children, 'characterSpacingControl');
+        if (index < 0)
+            return undefined;
+        var child = this.children[index];
+        return child instanceof SettingsCharacterSpacingControlChild ? child.read() : undefined;
+    };
+    /**
+     * Set or clear `w:characterSpacingControl`. `undefined` removes the element.
+     *
+     * @public
+     */
+    SettingsPart.prototype.setCharacterSpacingControl = function (value) {
+        replaceOrInsertChild(this.children, 'characterSpacingControl', value === undefined ? undefined : new SettingsCharacterSpacingControlChild(value));
+        this.dirty = true;
+    };
+    // ── compat convenience ──────────────────────────────────────────────────────
+    /**
+     * `compatibilityMode` from `w:compat/w:compatSetting[@w:name='compatibilityMode']/@w:val`.
+     *
+     * Common values: `"15"` = Word 2013+, `"14"` = Word 2010, `"12"` = Word 2007.
+     * Returns `undefined` when the `w:compat` element or the named setting is absent.
+     *
+     * @public
+     */
+    SettingsPart.prototype.compatibilityMode = function () {
+        var compat = this.compat();
+        return compat === undefined ? undefined : compat.compatibilityMode();
+    };
+    /**
+     * Set Word `compatibilityMode` on `w:compat`, creating the compat block when needed.
+     *
+     * @param value Wire token or {@link CompatibilityMode}.
+     * @private
+     */
+    SettingsPart.prototype.setCompatibilityMode = function (value) {
+        this.ensureCompat().setCompatibilityMode(value);
+        this.dirty = true;
+    };
+    /**
+     * `w:compat/w:noColumnBalance` (`CT_OnOff`) — do not balance multi-column section
+     * content. See {@link CompatSettings.noColumnBalance}.
+     *
+     * Returns `undefined` when `w:compat` or the element is absent (Word default:
+     * balance columns). Layout engines are out of scope for this library.
+     *
+     * @private
+     */
+    SettingsPart.prototype.noColumnBalance = function () {
+        var compat = this.compat();
+        return compat === undefined ? undefined : compat.noColumnBalance();
+    };
+    /**
+     * Set or clear `w:compat/w:noColumnBalance`. Creates `w:compat` when needed.
+     * Pass `undefined` to remove the element. Marks the settings part dirty.
+     *
+     * @private
+     */
+    SettingsPart.prototype.setNoColumnBalance = function (value) {
+        if (value === undefined) {
+            var compat = this.compat();
+            if (compat === undefined) {
+                return;
+            }
+            compat.setNoColumnBalance(undefined);
+            this.dirty = true;
+            return;
+        }
+        this.ensureCompat().setNoColumnBalance(value);
+        this.dirty = true;
+    };
+    /**
+     * @private
+     */
+    SettingsPart.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    SettingsPart.prototype.serialize = function () {
+        var root = wmlElement('settings', {
+            attributes: this.rootAttributes,
+            namespaceDeclarations: this.rootNamespaceDeclarations.length > 0
+                ? this.rootNamespaceDeclarations
+                : [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+            children: serializeSettingsChildren(this.children),
+        });
+        return utf8.encode(serializeXml(root));
+    };
+    return SettingsPart;
+}());
+export { SettingsPart };
+function loadSettingsPart(part) {
+    if (part === undefined) {
+        // Absent settings part (WordDocument.create scaffold, or package without
+        // settings.xml): attach Word-2013 defaults and mark dirty so the next save
+        // always emits settings.xml (TASK-8026 / settings-preserve-basic).
+        return createDefaultSettingsPart();
+    }
+    var root = parseXml(utf8Decoder.decode(part.data));
+    if (!isWml(root, 'settings')) {
+        return new SettingsPart([], [], [], false);
+    }
+    var children = elementChildren(root).map(function (child) { return parseSettingsChild(child); });
+    return new SettingsPart(root.attributes, root.namespaceDeclarations, children, false);
+}
+/**
+ * Build the canonical default `CT_Settings` children that Microsoft Word emits
+ * for a new document containing only a "Hello World" paragraph.
+ *
+ * - `w:zoom val="none" percent="100"`
+ * - `w:defaultTabStop val="720"` (0.5 inch / 36 points; stored as points, wire twips)
+ * - `w:characterSpacingControl val="doNotCompress"`
+ * - `w:compat` with five Word-2013 compat settings
+ * - `w:clrSchemeMapping` (empty element)
+ */
+function buildDefaultSettingsChildren() {
+    return __spread([
+        new SettingsZoomChild(ZoomSettings.create(100, 'none')),
+        new SettingsDefaultTabStopChild(36),
+        new SettingsCharacterSpacingControlChild('doNotCompress'),
+        new SettingsCompatChild(CompatSettings.createDefault())
+    ], elementChildren(parseXml('<w:settings xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:clrSchemeMapping/></w:settings>')).map(function (child) { return parseSettingsChild(child); }));
+}
+/**
+ * Creates a new {@link SettingsPart} pre-populated with the canonical Word-2013
+ * default settings and marked **dirty** so `WordDocument.saveSync` always writes
+ * `settings.xml` — even when no further mutation is made.
+ *
+ * Emitted children (matching Microsoft Word for a minimal new document):
+ * - `w:zoom val="none" percent="100"`
+ * - `w:defaultTabStop val="720"` (wire twips; DOM value is `36` points)
+ * - `w:characterSpacingControl val="doNotCompress"`
+ * - `w:compat` with five Word-2013 compat settings
+ * - `w:clrSchemeMapping`
+ *
+ * @private
+ */
+export function createDefaultSettingsPart() {
+    return new SettingsPart([], [], buildDefaultSettingsChildren(), true);
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetSettingsFeatureForTests() {
+    registered = false;
+    resetWebSettingsFeatureForTests();
+}
+/**
+ * @private
+ * Register the document-settings package-part handler. Idempotent. */
+export function registerSettingsFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerWebSettingsFeature();
+    registerFeature({ id: SETTINGS });
+    registerFeaturePartHandler({
+        featureId: SETTINGS,
+        relationshipTypes: [SETTINGS_RELATIONSHIP_TYPE, STRICT_SETTINGS_RELATIONSHIP_TYPE],
+        defaultRelativeTarget: 'settings.xml',
+        partName: SETTINGS_PART_NAME,
+        contentType: SETTINGS_CONTENT_TYPE,
+        loadPart: function (part, ctx) {
+            void ctx;
+            return loadSettingsPart(part);
+        },
+    });
+    // Materialize handler: ensure a default settings part is attached before every
+    // save — even when the caller never explicitly invoked `settingsFor()`.
+    // This guarantees settings.xml is always emitted (OOXML conformance requirement).
+    registerFeatureMaterializeHandler({
+        featureId: SETTINGS,
+        materialize: function (document) {
+            var existing = document.featurePart(SETTINGS);
+            // Attach Word-2013 defaults only when no settings part is present.
+            // A loaded empty `<w:settings/>` is a real part and must not be replaced.
+            if (!(existing instanceof SettingsPart)) {
+                document.setFeaturePart(SETTINGS, createDefaultSettingsPart());
+            }
+        },
+    });
+}
+/**
+ * Settings catalog for a document. Requires {@link registerSettingsFeature}.
+ *
+ * On {@link WordDocument.create} (and any document that has no settings state yet), the first
+ * access attaches a default {@link SettingsPart} pre-populated with canonical Word-2013
+ * settings (zoom, defaultTabStop, characterSpacingControl, compat, clrSchemeMapping) and
+ * marked dirty so that `WordDocument.saveSync` **always** materializes `/word/settings.xml`,
+ * its content-type override, and its Main Document relationship — even when no further
+ * mutation is made. This matches the OOXML conformance requirement that a DOCX file
+ * contains a settings part by default.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the module was not registered.
+ *
+ * @private
+ */
+export function settingsFor(document) {
+    var existing = document.featurePart(SETTINGS);
+    if (existing instanceof SettingsPart) {
+        return existing;
+    }
+    if (!registered) {
+        throw new DocxError('feature/not-registered', 'Settings part was not loaded; call registerSettingsFeature() before WordDocument.open or WordDocument.create');
+    }
+    // Absent part only: attach Word-2013 defaults so save always emits settings.xml.
+    // WordDocument.create loads via loadSettingsPart(undefined), which already attaches defaults.
+    var part = createDefaultSettingsPart();
+    document.setFeaturePart(SETTINGS, part);
+    return part;
+}
+/**
+ * Attached template relationship target from the settings part, without fetching.
+ *
+ * @private
+ */
+export function attachedTemplateTarget(document) {
+    var settings = settingsFor(document);
+    var id = settings.attachedTemplateRelationshipId();
+    if (id === undefined) {
+        return undefined;
+    }
+    var settingsPart = resolveSettingsPartName(document.opcPackage());
+    if (settingsPart === undefined) {
+        return undefined;
+    }
+    return resolveAttachedTemplateTarget(document.opcPackage(), settingsPart, id);
+}
+/**
+ * Main Document page background metadata. Requires {@link registerSettingsFeature}.
+ *
+ * @private
+ */
+export function backgroundFor(document) {
+    return createBackground(document, settingsFor(document).displayBackgroundShape());
+}
+registerSettingsFeature();
+bindDocumentSettingsFacades({
+    settingsFor: settingsFor,
+    registerSettingsFeature: registerSettingsFeature,
+    attachedTemplateTarget: attachedTemplateTarget,
+});
+registerDocumentSettingsFacades();