@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/styles/style-base.js

@@ -0,0 +1,1026 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * Live typed Styles DOM: Style, ParagraphStyle, CharacterStyle.
+ *
+ * Single mutable source of truth for paragraph and character style definitions.
+ * Table and numbering styles use {@link OpaqueStyle} (not public API).
+ *
+ * Style_Architecture_change.txt §§4–9.
+ *
+ * @public
+ */
+import { DetachedObjectError, DocxError, InvalidArgumentError } from '../../core/errors/docx-error';
+import { CharacterFormat, } from '../document/character-format';
+import { ParagraphFormat, } from '../document/paragraph-format';
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute, WML } from '../document/wml';
+import { normalizeStyleName } from './builtin-catalog';
+import { characterSnapshotFromRPr, paragraphSnapshotFromPPr, } from './style-format-bridge';
+import { DocxStyle, parseDocxStyle } from './style';
+// ---------------------------------------------------------------------------
+// Metadata helpers
+// ---------------------------------------------------------------------------
+/** CT_Style children emitted from typed fields (schema preamble). */
+var MODELED_META_NAMES = new Set([
+    'name',
+    'aliases',
+    'basedOn',
+    'next',
+    'link',
+    'autoRedefine',
+    'hidden',
+    'uiPriority',
+    'semiHidden',
+    'unhideWhenUsed',
+    'qFormat',
+    'locked',
+]);
+function firstWmlChild(children, localName) {
+    for (var i = 0; i < children.length; i += 1) {
+        var child = children[i];
+        if (child !== undefined && isWml(child, localName)) {
+            return child;
+        }
+    }
+    return undefined;
+}
+function readStringVal(children, localName) {
+    var el = firstWmlChild(children, localName);
+    if (el === undefined) {
+        return undefined;
+    }
+    return wValAttribute(el);
+}
+function readOnOffChild(children, localName) {
+    var el = firstWmlChild(children, localName);
+    if (el === undefined) {
+        return undefined;
+    }
+    return parseOnOff(el);
+}
+function parseDecimalChild(el) {
+    if (el === undefined) {
+        return undefined;
+    }
+    var raw = wValAttribute(el);
+    if (raw === undefined || !/^-?\d+$/.test(raw.trim())) {
+        return undefined;
+    }
+    return parseInt(raw.trim(), 10);
+}
+function pushOnOff(out, localName, value) {
+    if (value === undefined) {
+        return;
+    }
+    out.push(serializeOnOff(localName, value));
+}
+// ---------------------------------------------------------------------------
+// Style
+// ---------------------------------------------------------------------------
+/**
+ * Base live style definition (`w:style`).
+ *
+ * Paragraph and character styles are {@link ParagraphStyle} / {@link CharacterStyle}.
+ * Table and numbering styles are internal opaque instances.
+ *
+ * @public
+ */
+var Style = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Style(styleId, type, defaultFlag, customStyle) {
+        if (styleId.length === 0) {
+            throw new InvalidArgumentError('Style id must not be empty');
+        }
+        this.styleIdValue = styleId;
+        this.typeValue = type;
+        this.defaultValue = defaultFlag;
+        this.customStyleValue = customStyle;
+        this.nameValue = undefined;
+        this.aliasesValue = undefined;
+        this.basedOnIdValue = undefined;
+        this.nextIdValue = undefined;
+        this.linkIdValue = undefined;
+        this.uiPriorityValue = undefined;
+        this.autoRedefineValue = undefined;
+        this.hiddenValue = undefined;
+        this.semiHiddenValue = undefined;
+        this.unhideWhenUsedValue = undefined;
+        this.qFormatValue = undefined;
+        this.lockedValue = undefined;
+        this.extraAttributesValue = [];
+        this.opaqueChildrenValue = [];
+        this.ownerValue = undefined;
+        this.attachedValue = false;
+        this.suppressDirty = false;
+        this.characterFormatValue = new CharacterFormat(this);
+    }
+    Object.defineProperty(Style.prototype, "styleId", {
+        // ---- Identity ----
+        /**
+         * Stable OOXML style identity (`w:style/@w:styleId`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.styleIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "type", {
+        /**
+         * Style type (`w:style/@w:type`), when present.
+         *
+         * @public
+         */
+        get: function () {
+            return this.typeValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "isDefault", {
+        /**
+         * Whether this is the default style of its type (`@w:default`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.defaultValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "customStyle", {
+        /**
+         * Customer-defined style flag (`@w:customStyle`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.customStyleValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "name", {
+        /**
+         * Display name (`w:name/@w:val`). Mutable; does not change {@link styleId}.
+         *
+         * @public
+         */
+        get: function () {
+            return this.nameValue;
+        },
+        set: function (value) {
+            this.ensureAttached();
+            this.nameValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "characterFormat", {
+        /**
+         * Style-level character formatting (`w:rPr`). Stable facade identity.
+         *
+         * @public
+         */
+        get: function () {
+            return this.characterFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "owner", {
+        /**
+         * Owning collection infrastructure, when attached.
+         *
+         * @private
+         */
+        get: function () {
+            return this.ownerValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "isAttached", {
+        /**
+         * Whether this style is attached to a document styles collection.
+         *
+         * @private
+         */
+        get: function () {
+            return this.attachedValue && this.ownerValue !== undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "basedOnId", {
+        // ---- Base style (Option A) ----
+        /**
+         * Raw `w:basedOn/@w:val` (may be unresolved).
+         *
+         * @private
+         */
+        get: function () {
+            return this.basedOnIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "baseStyle", {
+        /**
+         * Resolved base style of the same public kind, when present and attached.
+         *
+         * @public
+         */
+        get: function () {
+            if (this.basedOnIdValue === undefined || this.basedOnIdValue.length === 0) {
+                return undefined;
+            }
+            if (this.ownerValue === undefined) {
+                return undefined;
+            }
+            var resolved = this.ownerValue.lookupStyle(this.basedOnIdValue);
+            if (resolved === undefined) {
+                return undefined;
+            }
+            if (this.typeValue !== undefined && resolved.type !== undefined && resolved.type !== this.typeValue) {
+                return undefined;
+            }
+            return resolved;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Set base style by instance or style id (same-type, same-document).
+     *
+     * Pass `undefined` to clear the relationship.
+     *
+     * @public
+     */
+    Style.prototype.applyBaseStyle = function (styleOrId) {
+        this.ensureAttached();
+        if (styleOrId === undefined) {
+            this.basedOnIdValue = undefined;
+            this.markDirty();
+            return;
+        }
+        var target;
+        if (typeof styleOrId === 'string') {
+            if (styleOrId.length === 0) {
+                throw new InvalidArgumentError('Base style id must not be empty');
+            }
+            if (this.ownerValue === undefined) {
+                throw new DetachedObjectError('Cannot resolve base style on a detached style');
+            }
+            target = this.ownerValue.lookupStyle(styleOrId);
+            if (target === undefined) {
+                // Preserve raw id (dangling basedOn is valid OOXML).
+                this.basedOnIdValue = styleOrId;
+                this.markDirty();
+                return;
+            }
+        }
+        else {
+            target = styleOrId;
+        }
+        if (target === this) {
+            throw new DocxError('styles/circular-based-on', "Style \"" + this.styleIdValue + "\" cannot be based on itself");
+        }
+        if (!target.isAttached || target.owner !== this.ownerValue) {
+            throw new DocxError('argument/invalid', 'Base style must belong to the same document styles collection');
+        }
+        if (this.typeValue !== undefined && target.type !== undefined && target.type !== this.typeValue) {
+            throw new DocxError('styles/invalid-based-on', "Style \"" + this.styleIdValue + "\" basedOn \"" + target.styleId + "\" is a " + String(target.type) + " style; expected " + this.typeValue);
+        }
+        // Indirect cycle: walk target's chain.
+        var cursor = target;
+        var seen = new Set();
+        seen.add(this.styleIdValue);
+        while (cursor !== undefined) {
+            if (seen.has(cursor.styleId)) {
+                throw new DocxError('styles/circular-based-on', "Circular basedOn relationship on style \"" + this.styleIdValue + "\"");
+            }
+            seen.add(cursor.styleId);
+            var nextId = cursor.basedOnId;
+            if (nextId === undefined || this.ownerValue === undefined) {
+                break;
+            }
+            cursor = this.ownerValue.lookupStyle(nextId);
+        }
+        this.basedOnIdValue = target.styleId;
+        this.markDirty();
+    };
+    Object.defineProperty(Style.prototype, "nextStyleId", {
+        // ---- Other metadata (public where useful) ----
+        /** `w:next/@w:val`. @public */
+        get: function () {
+            return this.nextIdValue;
+        },
+        set: function (value) {
+            this.ensureAttached();
+            this.nextIdValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "linkStyleId", {
+        /** `w:link/@w:val`. @public */
+        get: function () {
+            return this.linkIdValue;
+        },
+        set: function (value) {
+            this.ensureAttached();
+            this.linkIdValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "uiPriority", {
+        /** `w:uiPriority/@w:val`. @public */
+        get: function () {
+            return this.uiPriorityValue;
+        },
+        set: function (value) {
+            this.ensureAttached();
+            this.uiPriorityValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "isQuickStyle", {
+        /** `w:qFormat`. @public */
+        get: function () {
+            return this.qFormatValue;
+        },
+        set: function (value) {
+            this.ensureAttached();
+            this.qFormatValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "isSemiHidden", {
+        /** `w:semiHidden`. @public */
+        get: function () {
+            return this.semiHiddenValue;
+        },
+        set: function (value) {
+            this.ensureAttached();
+            this.semiHiddenValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    // ---- Host ----
+    /**
+     * @private
+     */
+    Style.prototype.notifyCharacterFormatMutation = function () {
+        this.ensureAttached();
+        this.markDirty();
+    };
+    // ---- Lifecycle ----
+    /**
+     * Attach to a document styles owner. Idempotent when already attached to the same owner.
+     *
+     * @private
+     */
+    Style.prototype.attach = function (owner) {
+        if (this.attachedValue && this.ownerValue === owner) {
+            return;
+        }
+        if (this.attachedValue && this.ownerValue !== undefined && this.ownerValue !== owner) {
+            throw new DocxError('argument/invalid', "Style \"" + this.styleIdValue + "\" is already owned by another document");
+        }
+        this.ownerValue = owner;
+        this.attachedValue = true;
+    };
+    /**
+     * Detach from the owning collection. Further mutations throw {@link DetachedObjectError}.
+     *
+     * @private
+     */
+    Style.prototype.detach = function () {
+        this.attachedValue = false;
+        this.ownerValue = undefined;
+    };
+    /**
+     * Remove this style from the document styles collection: drop the `w:style`
+     * definition, detach this instance, and clear content/catalog references to
+     * its style id so save does not re-materialize a stub. After removal the
+     * instance is detached; a second call throws {@link DetachedObjectError}.
+     *
+     * @public
+     */
+    Style.prototype.remove = function () {
+        this.ensureAttached();
+        var owner = this.ownerValue;
+        if (owner === undefined) {
+            throw new DetachedObjectError("Style \"" + this.styleIdValue + "\" is detached from its document");
+        }
+        // StyleOwner is the lookup/dirty surface; collection owns private remove.
+        var collection = owner;
+        if (typeof collection.remove !== 'function') {
+            throw new InvalidArgumentError("Style \"" + this.styleIdValue + "\" owner does not support removal");
+        }
+        collection.remove(this);
+    };
+    /**
+     * Clear basedOn / next / link edges that point at `removedStyleId`.
+     * Used by StyleCollection.remove (no dirty — caller marks once).
+     *
+     * @private
+     */
+    Style.prototype.clearReferencesToStyleId = function (removedStyleId) {
+        if (this.basedOnIdValue === removedStyleId) {
+            this.basedOnIdValue = undefined;
+        }
+        if (this.nextIdValue === removedStyleId) {
+            this.nextIdValue = undefined;
+        }
+        if (this.linkIdValue === removedStyleId) {
+            this.linkIdValue = undefined;
+        }
+    };
+    /**
+     * Hydrate modeled fields and format facades from a parsed {@link DocxStyle}
+     * without marking dirty or running authoring exclusivity.
+     *
+     * @private
+     */
+    Style.prototype.hydrateFromDocxStyle = function (source) {
+        this.suppressDirty = true;
+        try {
+            var shell = source.serialize();
+            var children = elementChildren(shell);
+            this.nameValue = readStringVal(children, 'name');
+            this.aliasesValue = readStringVal(children, 'aliases');
+            this.basedOnIdValue = readStringVal(children, 'basedOn');
+            this.nextIdValue = readStringVal(children, 'next');
+            this.linkIdValue = readStringVal(children, 'link');
+            this.uiPriorityValue = parseDecimalChild(firstWmlChild(children, 'uiPriority'));
+            this.autoRedefineValue = readOnOffChild(children, 'autoRedefine');
+            this.hiddenValue = readOnOffChild(children, 'hidden');
+            this.semiHiddenValue = readOnOffChild(children, 'semiHidden');
+            this.unhideWhenUsedValue = readOnOffChild(children, 'unhideWhenUsed');
+            this.qFormatValue = readOnOffChild(children, 'qFormat');
+            this.lockedValue = readOnOffChild(children, 'locked');
+            this.customStyleValue = source.customStyle;
+            var rPr = firstWmlChild(children, 'rPr');
+            this.characterFormatValue.hydrate(characterSnapshotFromRPr(rPr));
+            var pPr = firstWmlChild(children, 'pPr');
+            this.hydrateParagraphFormat(paragraphSnapshotFromPPr(pPr));
+            var opaque = [];
+            for (var i = 0; i < children.length; i += 1) {
+                var child = children[i];
+                if (child === undefined) {
+                    continue;
+                }
+                if (isWml(child, child.localName)) {
+                    if (MODELED_META_NAMES.has(child.localName)) {
+                        continue;
+                    }
+                    if (child.localName === 'pPr' || child.localName === 'rPr') {
+                        continue;
+                    }
+                }
+                opaque.push(child);
+            }
+            this.opaqueChildrenValue = opaque;
+            // Extra attributes from the style element (unknown attrs).
+            var knownAttr_1 = new Set(['styleId', 'type', 'default', 'customStyle']);
+            this.extraAttributesValue = shell.attributes.filter(function (a) {
+                return !(knownAttr_1.has(a.localName) && (a.namespaceUri === WML || a.namespaceUri === ''));
+            });
+        }
+        finally {
+            this.suppressDirty = false;
+        }
+    };
+    /**
+     * Subclasses with paragraph format hydrate here; default no-op.
+     *
+     * @private
+     */
+    Style.prototype.hydrateParagraphFormat = function (_snapshot) {
+        // CharacterStyle / OpaqueStyle without PF: ignore pPr snapshot (Opaque may override).
+    };
+    /**
+     * Subclasses contribute `w:pPr` during serialize.
+     *
+     * @private
+     */
+    Style.prototype.serializeParagraphProperties = function (_out) {
+        // default none
+    };
+    /**
+     * Serialize this live style to a `w:style` element.
+     *
+     * @private
+     */
+    Style.prototype.serialize = function () {
+        var attributes = [];
+        if (this.typeValue !== undefined) {
+            attributes.push(wmlAttr('type', this.typeValue));
+        }
+        attributes.push(wmlAttr('styleId', this.styleIdValue));
+        if (this.defaultValue !== undefined) {
+            attributes.push(wmlAttr('default', this.defaultValue ? '1' : '0'));
+        }
+        if (this.customStyleValue !== undefined) {
+            attributes.push(wmlAttr('customStyle', this.customStyleValue ? '1' : '0'));
+        }
+        for (var i = 0; i < this.extraAttributesValue.length; i += 1) {
+            attributes.push(this.extraAttributesValue[i]);
+        }
+        var out = [];
+        var nameVal = this.nameValue != null ? this.nameValue : this.styleIdValue;
+        out.push(wmlElement('name', { attributes: [wmlAttr('val', nameVal)] }));
+        if (this.aliasesValue !== undefined) {
+            out.push(wmlElement('aliases', { attributes: [wmlAttr('val', this.aliasesValue)] }));
+        }
+        if (this.basedOnIdValue !== undefined) {
+            out.push(wmlElement('basedOn', { attributes: [wmlAttr('val', this.basedOnIdValue)] }));
+        }
+        if (this.nextIdValue !== undefined) {
+            out.push(wmlElement('next', { attributes: [wmlAttr('val', this.nextIdValue)] }));
+        }
+        if (this.linkIdValue !== undefined) {
+            out.push(wmlElement('link', { attributes: [wmlAttr('val', this.linkIdValue)] }));
+        }
+        pushOnOff(out, 'autoRedefine', this.autoRedefineValue);
+        pushOnOff(out, 'hidden', this.hiddenValue);
+        if (this.uiPriorityValue !== undefined) {
+            out.push(wmlElement('uiPriority', { attributes: [wmlAttr('val', String(this.uiPriorityValue))] }));
+        }
+        pushOnOff(out, 'semiHidden', this.semiHiddenValue);
+        pushOnOff(out, 'unhideWhenUsed', this.unhideWhenUsedValue);
+        pushOnOff(out, 'qFormat', this.qFormatValue);
+        pushOnOff(out, 'locked', this.lockedValue);
+        // Opaque children (tblPr, tblStylePr, personal*, rsid, …) before pPr/rPr
+        // keeps table style structure intact; modeled pPr/rPr append after.
+        for (var i = 0; i < this.opaqueChildrenValue.length; i += 1) {
+            out.push(this.opaqueChildrenValue[i]);
+        }
+        this.serializeParagraphProperties(out);
+        var rPrChildren = this.characterFormatValue.buildRPrChildren();
+        // Style-level rPr must not emit nested rStyle (styleIdValue on CF).
+        var filteredRPr = [];
+        for (var i = 0; i < rPrChildren.length; i += 1) {
+            var child = rPrChildren[i];
+            if (isWml(child, 'rStyle')) {
+                continue;
+            }
+            filteredRPr.push(child);
+        }
+        if (filteredRPr.length > 0) {
+            out.push(wmlElement('rPr', { children: filteredRPr }));
+        }
+        return wmlElement('style', { attributes: attributes, children: out });
+    };
+    /**
+     * Character-format snapshot for the effective-format resolver.
+     *
+     * @private
+     */
+    Style.prototype.characterFormatSnapshot = function () {
+        return this.characterFormatValue.snapshot();
+    };
+    /**
+     * Project this live style to a temporary DocxStyle shell (resolver / TableStyle).
+     *
+     * @private
+     */
+    Style.prototype.toDocxStyle = function () {
+        var parsed = parseDocxStyle(this.serialize());
+        if (parsed !== undefined) {
+            return parsed;
+        }
+        return new DocxStyle(this.styleIdValue, this.typeValue, this.defaultValue, this.customStyleValue, elementChildren(this.serialize()).slice());
+    };
+    /**
+     * Replace live fields from a DocxStyle shell (TableStyle mutation path).
+     * Does not require attach; used while the style remains document-owned.
+     *
+     * @private
+     */
+    Style.prototype.replaceShell = function (shell) {
+        if (shell.styleId !== this.styleIdValue) {
+            throw new DocxError('argument/invalid', "Cannot replace style shell: styleId \"" + shell.styleId + "\" does not match \"" + this.styleIdValue + "\"");
+        }
+        this.hydrateFromDocxStyle(shell);
+        this.markDirty();
+    };
+    /**
+     * Normalized display name for catalog lookup.
+     *
+     * @private
+     */
+    Style.prototype.normalizedName = function () {
+        var n = this.nameValue;
+        if (n !== undefined && n.length > 0) {
+            return normalizeStyleName(n);
+        }
+        return normalizeStyleName(this.styleIdValue);
+    };
+    /**
+     * Opaque children retained for package fidelity (table props, conditionals, …).
+     *
+     * @private
+     */
+    Style.prototype.getOpaqueChildren = function () {
+        return this.opaqueChildrenValue;
+    };
+    /**
+     * Replace opaque children (TableStyle base props / tblStylePr).
+     *
+     * @private
+     */
+    Style.prototype.setOpaqueChildren = function (children) {
+        this.opaqueChildrenValue = children.slice();
+        this.markDirty();
+    };
+    /**
+     * @private
+     */
+    Style.prototype.ensureAttached = function () {
+        if (!this.attachedValue || this.ownerValue === undefined) {
+            throw new DetachedObjectError("Style \"" + this.styleIdValue + "\" is detached from its document");
+        }
+    };
+    /**
+     * @private
+     */
+    Style.prototype.markDirty = function () {
+        if (this.suppressDirty) {
+            return;
+        }
+        if (this.ownerValue !== undefined) {
+            this.ownerValue.markStylesDirty();
+        }
+    };
+    /**
+     * Set metadata used when creating a minimal / seed style (no dirty).
+     *
+     * @private
+     */
+    Style.prototype.seedIdentity = function (name, basedOnId) {
+        this.suppressDirty = true;
+        try {
+            this.nameValue = name;
+            this.basedOnIdValue = basedOnId;
+        }
+        finally {
+            this.suppressDirty = false;
+        }
+    };
+    /**
+     * Hydrate CF from snapshot without dirty (catalog / seed).
+     *
+     * @private
+     */
+    Style.prototype.hydrateCharacterSnapshot = function (snapshot) {
+        this.suppressDirty = true;
+        try {
+            this.characterFormatValue.hydrate(snapshot);
+        }
+        finally {
+            this.suppressDirty = false;
+        }
+    };
+    /**
+     * Internal write of basedOn id during hydrate/seed (no dirty, no attach check).
+     *
+     * @private
+     */
+    Style.prototype.setBasedOnIdInternal = function (value) {
+        this.basedOnIdValue = value;
+    };
+    /**
+     * Internal next/link/ui flags during hydrate/seed.
+     *
+     * @private
+     */
+    Style.prototype.setMetaInternal = function (meta) {
+        if (meta.nextId !== undefined) {
+            this.nextIdValue = meta.nextId;
+        }
+        if (meta.linkId !== undefined) {
+            this.linkIdValue = meta.linkId;
+        }
+        if (meta.uiPriority !== undefined) {
+            this.uiPriorityValue = meta.uiPriority;
+        }
+        if (meta.semiHidden !== undefined) {
+            this.semiHiddenValue = meta.semiHidden;
+        }
+        if (meta.unhideWhenUsed !== undefined) {
+            this.unhideWhenUsedValue = meta.unhideWhenUsed;
+        }
+        if (meta.qFormat !== undefined) {
+            this.qFormatValue = meta.qFormat;
+        }
+        if (meta.aliases !== undefined) {
+            this.aliasesValue = meta.aliases;
+        }
+        if (meta.autoRedefine !== undefined) {
+            this.autoRedefineValue = meta.autoRedefine;
+        }
+        if (meta.hidden !== undefined) {
+            this.hiddenValue = meta.hidden;
+        }
+        if (meta.locked !== undefined) {
+            this.lockedValue = meta.locked;
+        }
+    };
+    Object.defineProperty(Style.prototype, "nextIdInternal", {
+        /** @private */
+        get: function () {
+            return this.nextIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Style.prototype, "linkIdInternal", {
+        /** @private */
+        get: function () {
+            return this.linkIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Style;
+}());
+export { Style };
+// ---------------------------------------------------------------------------
+// ParagraphStyle
+// ---------------------------------------------------------------------------
+/**
+ * Paragraph style (`w:type="paragraph"`) with paragraph and character format facades.
+ *
+ * @public
+ */
+var ParagraphStyle = /** @class */ (function (_super) {
+    __extends(ParagraphStyle, _super);
+    /**
+     * @private
+     */
+    function ParagraphStyle(styleId, defaultFlag, customStyle) {
+        var _this = _super.call(this, styleId, 'paragraph', defaultFlag, customStyle) || this;
+        _this.paragraphFormatValue = new ParagraphFormat(_this);
+        return _this;
+    }
+    Object.defineProperty(ParagraphStyle.prototype, "paragraphFormat", {
+        /**
+         * Style-level paragraph formatting (`w:pPr`). Stable facade identity.
+         *
+         * @public
+         */
+        get: function () {
+            return this.paragraphFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphStyle.prototype, "baseParagraphStyle", {
+        /**
+         * Resolved paragraph base style, when present.
+         *
+         * @public
+         */
+        get: function () {
+            var base = this.baseStyle;
+            if (base instanceof ParagraphStyle) {
+                return base;
+            }
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    ParagraphStyle.prototype.notifyParagraphFormatMutation = function () {
+        this.ensureAttached();
+        this.markDirty();
+    };
+    /**
+     * @private
+     */
+    ParagraphStyle.prototype.hydrateParagraphFormat = function (snapshot) {
+        // Called only from Style.hydrateFromDocxStyle (suppressDirty already true).
+        // hydrate() does not notify the host.
+        this.paragraphFormatValue.hydrate(snapshot);
+    };
+    /**
+     * @private
+     */
+    ParagraphStyle.prototype.serializeParagraphProperties = function (out) {
+        var children = this.paragraphFormatValue.buildPPrChildren();
+        if (children.length > 0) {
+            out.push(wmlElement('pPr', { children: children }));
+        }
+    };
+    /**
+     * @private
+     */
+    ParagraphStyle.prototype.paragraphFormatSnapshot = function () {
+        return this.paragraphFormatValue.snapshot();
+    };
+    /**
+     * Create a minimal paragraph style (ensure / authoring).
+     *
+     * @private
+     */
+    ParagraphStyle.createMinimal = function (styleId) {
+        var style = new ParagraphStyle(styleId, undefined, true);
+        style.seedIdentity(styleId, undefined);
+        return style;
+    };
+    /**
+     * Hydrate a paragraph style from a parsed DocxStyle shell.
+     *
+     * @private
+     */
+    ParagraphStyle.fromDocxStyle = function (source) {
+        var style = new ParagraphStyle(source.styleId, source.default, source.customStyle);
+        style.hydrateFromDocxStyle(source);
+        return style;
+    };
+    return ParagraphStyle;
+}(Style));
+export { ParagraphStyle };
+// ---------------------------------------------------------------------------
+// CharacterStyle
+// ---------------------------------------------------------------------------
+/**
+ * Character style (`w:type="character"`) with a character format facade only.
+ *
+ * @public
+ */
+var CharacterStyle = /** @class */ (function (_super) {
+    __extends(CharacterStyle, _super);
+    /**
+     * @private
+     */
+    function CharacterStyle(styleId, defaultFlag, customStyle) {
+        return _super.call(this, styleId, 'character', defaultFlag, customStyle) || this;
+    }
+    Object.defineProperty(CharacterStyle.prototype, "baseCharacterStyle", {
+        /**
+         * Resolved character base style, when present.
+         *
+         * @public
+         */
+        get: function () {
+            var base = this.baseStyle;
+            if (base instanceof CharacterStyle) {
+                return base;
+            }
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Create a minimal character style (ensure / authoring).
+     *
+     * @private
+     */
+    CharacterStyle.createMinimal = function (styleId) {
+        var style = new CharacterStyle(styleId, undefined, true);
+        style.seedIdentity(styleId, undefined);
+        return style;
+    };
+    /**
+     * Hydrate a character style from a parsed DocxStyle shell.
+     *
+     * @private
+     */
+    CharacterStyle.fromDocxStyle = function (source) {
+        var style = new CharacterStyle(source.styleId, source.default, source.customStyle);
+        style.hydrateFromDocxStyle(source);
+        return style;
+    };
+    return CharacterStyle;
+}(Style));
+export { CharacterStyle };
+// ---------------------------------------------------------------------------
+// OpaqueStyle (table / numbering / unknown) — not a public API type
+// ---------------------------------------------------------------------------
+/**
+ * Non-paragraph, non-character style retained for package fidelity.
+ * Not part of the public Styles DOM surface.
+ *
+ * @private
+ */
+var OpaqueStyle = /** @class */ (function (_super) {
+    __extends(OpaqueStyle, _super);
+    /**
+     * @private
+     */
+    function OpaqueStyle(styleId, type, defaultFlag, customStyle) {
+        return _super.call(this, styleId, type, defaultFlag, customStyle) || this;
+    }
+    /**
+     * @private
+     */
+    OpaqueStyle.prototype.hydrateParagraphFormat = function (snapshot) {
+        if (this.paragraphFormatValue === undefined) {
+            // Lazy PF only when pPr present — OpaqueStyle implements host inline.
+            var self_1 = this;
+            this.paragraphFormatValue = new ParagraphFormat({
+                notifyParagraphFormatMutation: function () {
+                    self_1.ensureAttached();
+                    self_1.markDirty();
+                },
+            });
+        }
+        this.paragraphFormatValue.hydrate(snapshot);
+    };
+    /**
+     * @private
+     */
+    OpaqueStyle.prototype.serializeParagraphProperties = function (out) {
+        if (this.paragraphFormatValue === undefined) {
+            return;
+        }
+        var children = this.paragraphFormatValue.buildPPrChildren();
+        if (children.length > 0) {
+            out.push(wmlElement('pPr', { children: children }));
+        }
+    };
+    /**
+     * @private
+     */
+    OpaqueStyle.fromDocxStyle = function (source) {
+        var style = new OpaqueStyle(source.styleId, source.type, source.default, source.customStyle);
+        style.hydrateFromDocxStyle(source);
+        return style;
+    };
+    return OpaqueStyle;
+}(Style));
+export { OpaqueStyle };
+// ---------------------------------------------------------------------------
+// Factories
+// ---------------------------------------------------------------------------
+/**
+ * Build a live Style from a temporary {@link DocxStyle} parse/catalog shell.
+ * Does not attach; caller attaches via the collection.
+ * Table styles are created as {@link OpaqueStyle} here — the collection upgrades
+ * `type === 'table'` shells to {@link TableStyle}.
+ *
+ * @private
+ */
+export function createStyleFromDocxStyle(source) {
+    if (source.type === 'paragraph') {
+        return ParagraphStyle.fromDocxStyle(source);
+    }
+    if (source.type === 'character') {
+        return CharacterStyle.fromDocxStyle(source);
+    }
+    return OpaqueStyle.fromDocxStyle(source);
+}
+/**
+ * Alias for {@link createStyleFromDocxStyle} (legacy shell projection name).
+ *
+ * @private
+ */
+export function styleFromDocxShell(shell) {
+    return createStyleFromDocxStyle(shell);
+}
+/**
+ * Minimal paragraph or character style for ensure / pending materialize.
+ *
+ * @private
+ */
+export function createMinimalStyle(styleId, type) {
+    if (type === 'paragraph') {
+        return ParagraphStyle.createMinimal(styleId);
+    }
+    return CharacterStyle.createMinimal(styleId);
+}