@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/styles/index.js

@@ -0,0 +1,1325 @@
+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;
+};
+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 };
+        }
+    };
+};
+export * from './builtin-catalog';
+export * from './builtin-resolver';
+export * from './default-styles';
+export * from './default-theme';
+export * from './doc-defaults';
+export * from './formatting-resolver';
+export * from './latent-styles';
+export * from './paragraph-properties';
+export * from './run-properties';
+export * from './style-base';
+export * from './style-collection';
+export * from './style-format-bridge';
+export * from './style';
+export * from './styles-with-effects';
+export * from './table-style';
+export * from './theme';
+import { DocxError } from '../../core/errors/docx-error';
+import { WordDocument } from '../document/document';
+import { Paragraph } from '../document/paragraph';
+import { TextRange } from '../document/text-range';
+import { elementChildren, isWml, wmlElement, } from '../document/wml';
+import { partName } from '../../core/opc/part-name';
+import { featureId, isFeatureRegistered, registerFeature, registerFeatureMaterializeHandler, registerFeaturePartHandler, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+import { parseXml, serializeXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { parseDocDefaults } from './doc-defaults';
+import { resolveReferencedStyle, resolveStyleForTarget } from './builtin-resolver';
+import { StyleCollection } from './style-collection';
+import { characterSnapshotToModeledRunProperties } from './style-format-bridge';
+import { ParagraphStyle } from './style-base';
+import { getBuiltinStyleTemplate, getBuiltinStyleTemplateByDisplayName, normalizeStyleName, } from './builtin-catalog';
+import { buildDefaultStylesArgs } from './default-styles';
+import { registerFontTableFeature, resetFontTableFeatureForTests, } from '../font-table/index';
+import { resolveRunFormattingWithStyles } from './formatting-resolver';
+import { parseLatentStyles } from './latent-styles';
+import { EMPTY_MODELED_PARAGRAPH_PROPERTIES } from './paragraph-properties';
+import { EMPTY_MODELED_RUN_PROPERTIES } from './run-properties';
+import { createMinimalDocxStyle, parseDocxStyle } from './style';
+import { registerStylesWithEffectsFeature, resetStylesWithEffectsFeatureForTests, } from './styles-with-effects';
+import { registerThemeFeature, resetThemeFeatureForTests, themeFor } from './theme';
+import { setStylesLookupFactory } from '../numbering/list-format';
+// Bridge stylesFor into ListFormat.applyStyle without extensionless CJS require (Vitest ESM).
+setStylesLookupFactory(function (document) { return stylesFor(document); });
+var STYLES = featureId('styles');
+/**
+ * @private
+ * Transitional styles relationship (ECMA-376-4 §9.2.12). */
+export var STYLES_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles';
+/**
+ * @private
+ * Strict styles relationship (ECMA-376-1 §11.3.12). */
+export var STRICT_STYLES_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/styles';
+/**
+ * @private
+ * ECMA-376-1 §11.3.12 Style Definitions content type. */
+export var STYLES_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml';
+/**
+ * @private
+ */
+export var STYLES_PART_NAME = partName('/word/styles.xml');
+var utf8Decoder = new TextDecoder('utf-8');
+var utf8 = new TextEncoder();
+/**
+ * In-memory Style Definitions part (`word/styles.xml`).
+ *
+ * Models `CT_Styles` as optional {@link DocDefaults}, optional {@link LatentStyles},
+ * and an ordered list of {@link DocxStyle}. Serialize rebuilds the part from that
+ * class graph (not an opaque XML bag). Unmodeled root children are retained in
+ * document order relative to the three schema slots when dirty-path serialize runs.
+ *
+ * @private
+ */
+/**
+ * In-memory Style Definitions part (`word/styles.xml`).
+ *
+ * Hosts package metadata (`docDefaults`, `latentStyles`, extras) and binds a
+ * document-owned live {@link StyleCollection}. Transitional {@link DocxStyle}
+ * lookups project from the live DOM with a stable shell cache so existing
+ * resolver tests keep identity for getStyle.
+ *
+ * @private
+ */
+var StylesPart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function StylesPart(docDefaults, latentStyles, styles, rootExtrasBeforeStyles, rootExtrasAfterStyles, dirty) {
+        var e_1, _a;
+        this.docDefaultsValue = docDefaults;
+        this.latentStylesValue = latentStyles;
+        this.shellList = __spread(styles);
+        this.shellById = new Map();
+        try {
+            for (var _b = __values(this.shellList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var style = _c.value;
+                this.shellById.set(style.styleId, style);
+            }
+        }
+        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; }
+        }
+        this.collection = undefined;
+        this.projectedById = new Map();
+        this.rootExtrasBeforeStyles = rootExtrasBeforeStyles;
+        this.rootExtrasAfterStyles = rootExtrasAfterStyles;
+        this.pendingParagraphStyles = new Set();
+        this.pendingCharacterStyles = new Set();
+        this.pendingTableStyles = new Set();
+        this.dirty = dirty;
+    }
+    /**
+     * @private
+     * StyleCollectionHost: styles package dirty + invalidate DocxStyle projection cache.
+     */
+    StylesPart.prototype.markStylesDirty = function () {
+        this.dirty = true;
+        // Keep projectedById so DocxStyle identity stays stable across ensure of other styles.
+    };
+    /**
+     * Drop a stable DocxStyle projection after the live style is removed.
+     *
+     * @private
+     */
+    StylesPart.prototype.forgetProjectedStyle = function (styleId) {
+        this.projectedById.delete(styleId);
+        this.shellById.delete(styleId);
+        this.pendingParagraphStyles.delete(styleId);
+        this.pendingCharacterStyles.delete(styleId);
+        this.pendingTableStyles.delete(styleId);
+        if (this.shellList.length > 0) {
+            this.shellList = this.shellList.filter(function (shell) { return shell.styleId !== styleId; });
+        }
+    };
+    /**
+     * Clear body (and header/footer when registered) content references to `styleId`
+     * so save-time materialize cannot re-create a minimal stub.
+     *
+     * @private
+     */
+    StylesPart.prototype.purgeContentStyleReferences = function (document, styleId) {
+        purgeStyleReferencesInDocument(document, styleId);
+    };
+    /**
+     * Bind the live StyleCollection and drain create/load shells into it.
+     *
+     * @private
+     */
+    StylesPart.prototype.bindLiveCollection = function (collection) {
+        if (this.collection === collection) {
+            return;
+        }
+        this.collection = collection;
+        if (this.shellList.length > 0) {
+            var shells = this.takeShells();
+            collection.replaceFromDocxStyles(shells, false);
+        }
+        // Pending ids recorded before bind transfer into the live collection.
+        var pendingParagraph = Array.from(this.pendingParagraphStyles);
+        for (var i = 0; i < pendingParagraph.length; i += 1) {
+            collection.registerPendingParagraphStyle(pendingParagraph[i]);
+        }
+        this.pendingParagraphStyles.clear();
+        var pendingCharacter = Array.from(this.pendingCharacterStyles);
+        for (var i = 0; i < pendingCharacter.length; i += 1) {
+            collection.registerPendingCharacterStyle(pendingCharacter[i]);
+        }
+        this.pendingCharacterStyles.clear();
+        var pendingTable = Array.from(this.pendingTableStyles);
+        for (var i = 0; i < pendingTable.length; i += 1) {
+            collection.registerPendingTableStyle(pendingTable[i]);
+        }
+        this.pendingTableStyles.clear();
+        this.projectedById.clear();
+    };
+    /**
+     * Drain unbound DocxStyle shells (load/create path).
+     *
+     * @private
+     */
+    StylesPart.prototype.takeShells = function () {
+        var shells = this.shellList.slice();
+        this.shellList = [];
+        this.shellById.clear();
+        return shells;
+    };
+    /**
+     * Live styles collection when bound.
+     *
+     * @private
+     */
+    StylesPart.prototype.liveCollection = function () {
+        return this.collection;
+    };
+    Object.defineProperty(StylesPart.prototype, "styles", {
+        /**
+         * Ordered style definitions as they appear under `w:styles`.
+         * Projects live styles to DocxStyle shells when the collection is bound.
+         *
+         * @public
+         */
+        get: function () {
+            if (this.collection !== undefined) {
+                var liveStyles = this.collection.stylesInOrder();
+                var out = [];
+                for (var i = 0; i < liveStyles.length; i += 1) {
+                    var live = liveStyles[i];
+                    var styleId = live.styleId;
+                    var shell = this.projectedById.get(styleId);
+                    if (shell === undefined) {
+                        shell = this.collection.projectDocxStyle(styleId);
+                        if (shell !== undefined) {
+                            this.projectedById.set(styleId, shell);
+                        }
+                    }
+                    if (shell !== undefined) {
+                        out.push(shell);
+                    }
+                }
+                return out;
+            }
+            return this.shellList;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(StylesPart.prototype, "docDefaults", {
+        /**
+         * WordDocument defaults (`w:docDefaults`), when present.
+         *
+         * @public
+         */
+        get: function () {
+            return this.docDefaultsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(StylesPart.prototype, "latentStyles", {
+        /**
+         * Latent styles (`w:latentStyles`), when present.
+         *
+         * @public
+         */
+        get: function () {
+            return this.latentStylesValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Look up a style by `w:styleId` (DocxStyle projection; stable while clean).
+     *
+     * @public
+     */
+    StylesPart.prototype.getStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            var cached = this.projectedById.get(styleId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            var projected = this.collection.projectDocxStyle(styleId);
+            if (projected !== undefined) {
+                this.projectedById.set(styleId, projected);
+            }
+            return projected;
+        }
+        return this.shellById.get(styleId);
+    };
+    /** Whether a style id exists in the catalog (including pending ensure). */
+    StylesPart.prototype.hasStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            return this.collection.hasStyle(styleId);
+        }
+        return (this.shellById.has(styleId) ||
+            this.pendingParagraphStyles.has(styleId) ||
+            this.pendingCharacterStyles.has(styleId) ||
+            this.pendingTableStyles.has(styleId));
+    };
+    /**
+     * Modeled run properties from `w:docDefaults/w:rPrDefault/w:rPr`.
+     *
+     * @public
+     */
+    StylesPart.prototype.docDefaultsRunProperties = function () {
+        var defaults = this.docDefaultsValue;
+        if (defaults === undefined) {
+            return EMPTY_MODELED_RUN_PROPERTIES;
+        }
+        return defaults.runProperties();
+    };
+    /**
+     * Modeled paragraph properties from `w:docDefaults/w:pPrDefault/w:pPr`.
+     *
+     * Spacing uses branded point `number` (twips). Absent markup is not filled
+     * with create-path defaults on load.
+     *
+     * @public
+     */
+    StylesPart.prototype.docDefaultsParagraphProperties = function () {
+        var defaults = this.docDefaultsValue;
+        if (defaults === undefined) {
+            return EMPTY_MODELED_PARAGRAPH_PROPERTIES;
+        }
+        return defaults.paragraphProperties();
+    };
+    /**
+     * Modeled `w:rPr` on a style definition, or `undefined` when the style is absent.
+     *
+     * @public
+     */
+    StylesPart.prototype.styleRunProperties = function (styleId) {
+        if (this.collection !== undefined) {
+            var live = this.collection.getStyle(styleId);
+            if (live === undefined) {
+                return undefined;
+            }
+            return characterSnapshotToModeledRunProperties(live.characterFormatSnapshot());
+        }
+        var style = this.shellById.get(styleId);
+        if (style === undefined) {
+            return undefined;
+        }
+        return style.runProperties();
+    };
+    /**
+     * `w:basedOn/@w:val` for a style id, or `undefined` when absent or unknown.
+     *
+     * @public
+     */
+    StylesPart.prototype.styleBasedOn = function (styleId) {
+        if (this.collection !== undefined) {
+            var live = this.collection.getStyle(styleId);
+            if (live === undefined) {
+                return undefined;
+            }
+            return live.basedOnId;
+        }
+        var __ts33_2;
+        return ((__ts33_2 = this.shellById.get(styleId)), __ts33_2 == null ? undefined : __ts33_2.basedOn);
+    };
+    /**
+     * Ensure a paragraph style exists, creating a minimal `CT_Style` when absent.
+     */
+    StylesPart.prototype.ensureParagraphStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            this.collection.ensureParagraphStyle(styleId);
+            return;
+        }
+        this.ensureStyle(styleId, 'paragraph');
+    };
+    /**
+     * Ensure a character style exists, creating a minimal `CT_Style` when absent.
+     */
+    StylesPart.prototype.ensureCharacterStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            this.collection.ensureCharacterStyle(styleId);
+            return;
+        }
+        this.ensureStyle(styleId, 'character');
+    };
+    /**Ensure a table style exists, creating a minimal `CT_Style` when absent.
+     */
+    StylesPart.prototype.ensureTableStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            this.collection.ensureTableStyle(styleId);
+            return;
+        }
+        this.ensureStyle(styleId, 'table');
+    };
+    /**
+     * @private
+   * Record a paragraph style reference before save. */
+    StylesPart.prototype.registerPendingParagraphStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            this.collection.registerPendingParagraphStyle(styleId);
+            return;
+        }
+        if (this.shellById.has(styleId)) {
+            return;
+        }
+        this.pendingParagraphStyles.add(styleId);
+    };
+    /**
+     * @private
+   * Record a character style reference before save. */
+    StylesPart.prototype.registerPendingCharacterStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            this.collection.registerPendingCharacterStyle(styleId);
+            return;
+        }
+        if (this.shellById.has(styleId)) {
+            return;
+        }
+        this.pendingCharacterStyles.add(styleId);
+    };
+    /**
+     * @private
+   * Record a table style reference before save. */
+    StylesPart.prototype.registerPendingTableStyle = function (styleId) {
+        if (this.collection !== undefined) {
+            this.collection.registerPendingTableStyle(styleId);
+            return;
+        }
+        if (this.shellById.has(styleId)) {
+            return;
+        }
+        this.pendingTableStyles.add(styleId);
+    };
+    /**
+     * @private
+     */
+    StylesPart.prototype.materializePending = function (document) {
+        var _this = this;
+        // Ensure live collection is bound before materialize so ensure/canonicalize
+        // go through the single Styles DOM.
+        styleCollectionFor(document);
+        var collection = this.collection;
+        if (collection !== undefined) {
+            visitParagraphsInDocumentOrder(document, function (paragraph) {
+                var e_2, _a;
+                var paragraphStyleId = paragraph.styleId;
+                // Empty style id is invalid OOXML; skip rather than fail save.
+                if (paragraphStyleId !== undefined && paragraphStyleId.length > 0 && !collection.hasStyle(paragraphStyleId)) {
+                    collection.ensureParagraphStyle(paragraphStyleId);
+                    var resolved = collection.getStyle(paragraphStyleId);
+                    if (resolved !== undefined && resolved.styleId !== paragraphStyleId) {
+                        paragraph.styleId = resolved.styleId;
+                    }
+                }
+                try {
+                    for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var inline = _c.value;
+                        if (!(inline instanceof TextRange)) {
+                            continue;
+                        }
+                        var runStyleId = inline.characterFormat.characterStyle;
+                        if (runStyleId !== undefined && runStyleId.length > 0 && !collection.hasStyle(runStyleId)) {
+                            collection.ensureCharacterStyle(runStyleId);
+                            var resolved = collection.getStyle(runStyleId);
+                            if (resolved !== undefined && resolved.styleId !== runStyleId) {
+                                inline.characterFormat.characterStyle = resolved.styleId;
+                            }
+                        }
+                    }
+                }
+                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; }
+                }
+            });
+            visitTablesInDocumentOrder(document, function (table) {
+                var tableStyleId = table.styleId;
+                if (tableStyleId !== undefined && tableStyleId.length > 0 && !collection.hasStyle(tableStyleId)) {
+                    collection.ensureTableStyle(tableStyleId);
+                    var resolved = collection.getStyle(tableStyleId);
+                    if (resolved !== undefined && resolved.styleId !== tableStyleId) {
+                        table.styleId = resolved.styleId;
+                    }
+                }
+            });
+            collection.materializePendingIds(function (fromId, toId) {
+                visitParagraphsInDocumentOrder(document, function (paragraph) {
+                    if (paragraph.styleId === fromId) {
+                        paragraph.styleId = toId;
+                    }
+                });
+            }, function (fromId, toId) {
+                visitParagraphsInDocumentOrder(document, function (paragraph) {
+                    var e_3, _a;
+                    try {
+                        for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var inline = _c.value;
+                            if (!(inline instanceof TextRange)) {
+                                continue;
+                            }
+                            if (inline.characterFormat.characterStyle === fromId) {
+                                inline.characterFormat.characterStyle = toId;
+                            }
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                });
+            }, function (fromId, toId) {
+                visitTablesInDocumentOrder(document, function (table) {
+                    if (table.styleId === fromId) {
+                        table.styleId = toId;
+                    }
+                });
+            });
+            return;
+        }
+        visitParagraphsInDocumentOrder(document, function (paragraph) {
+            var e_4, _a;
+            var paragraphStyleId = paragraph.styleId;
+            if (paragraphStyleId !== undefined && !_this.shellById.has(paragraphStyleId)) {
+                _this.ensureStyle(paragraphStyleId, 'paragraph');
+                _this.pendingParagraphStyles.delete(paragraphStyleId);
+                var resolved = _this.shellById.get(paragraphStyleId);
+                if (resolved !== undefined && resolved.styleId !== paragraphStyleId) {
+                    paragraph.styleId = resolved.styleId;
+                }
+            }
+            try {
+                for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var inline = _c.value;
+                    if (!(inline instanceof TextRange)) {
+                        continue;
+                    }
+                    var runStyleId = inline.characterFormat.characterStyle;
+                    if (runStyleId !== undefined && !_this.shellById.has(runStyleId)) {
+                        _this.ensureStyle(runStyleId, 'character');
+                        _this.pendingCharacterStyles.delete(runStyleId);
+                        var resolved = _this.shellById.get(runStyleId);
+                        if (resolved !== undefined && resolved.styleId !== runStyleId) {
+                            inline.characterFormat.characterStyle = resolved.styleId;
+                        }
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        });
+        visitTablesInDocumentOrder(document, function (table) {
+            var tableStyleId = table.styleId;
+            if (tableStyleId !== undefined && !_this.shellById.has(tableStyleId)) {
+                _this.ensureStyle(tableStyleId, 'table');
+                _this.pendingTableStyles.delete(tableStyleId);
+                var resolved = _this.shellById.get(tableStyleId);
+                if (resolved !== undefined && resolved.styleId !== tableStyleId) {
+                    table.styleId = resolved.styleId;
+                }
+            }
+        });
+        this.pendingParagraphStyles.clear();
+        this.pendingCharacterStyles.clear();
+        this.pendingTableStyles.clear();
+    };
+    /**
+     * @private
+     */
+    StylesPart.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    StylesPart.prototype.serialize = function () {
+        var e_5, _a;
+        var children = [];
+        if (this.docDefaultsValue !== undefined) {
+            children.push(this.docDefaultsValue.serialize());
+        }
+        if (this.latentStylesValue !== undefined) {
+            children.push(this.latentStylesValue.serialize());
+        }
+        children.push.apply(children, __spread(this.rootExtrasBeforeStyles));
+        if (this.collection !== undefined) {
+            var liveStyles = this.collection.stylesInOrder();
+            for (var i = 0; i < liveStyles.length; i += 1) {
+                children.push(liveStyles[i].serialize());
+            }
+        }
+        else {
+            try {
+                for (var _b = __values(this.shellList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var style = _c.value;
+                    children.push(style.serialize());
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+        children.push.apply(children, __spread(this.rootExtrasAfterStyles));
+        var root = wmlElement('styles', {
+            namespaceDeclarations: [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+            children: children,
+        });
+        return utf8.encode(serializeXml(root));
+    };
+    StylesPart.prototype.ensureStyle = function (styleId, type) {
+        if (styleId.length === 0) {
+            throw new DocxError('content/invalid-style-id', 'Style id must not be empty');
+        }
+        if (this.shellById.has(styleId)) {
+            return;
+        }
+        // Resolver: document-first, catalog-second (complete built-in
+        // definition), unknown preserved as a save-time dangling reference
+        // (round-trip; never a minimal stub).
+        var resolved = resolveReferencedStyle(this, styleId, type);
+        if (resolved === undefined) {
+            var created = createMinimalDocxStyle(styleId, type);
+            this.shellList.push(created);
+            this.shellById.set(styleId, created);
+            this.markStylesDirty();
+        }
+    };
+    /**
+     * @private
+   * Style-collection surface for the built-in resolver. */
+    StylesPart.prototype.findStyleByDisplayName = function (name) {
+        if (this.collection !== undefined) {
+            var live = this.collection.findByName(name);
+            if (live === undefined) {
+                return undefined;
+            }
+            var cached = this.projectedById.get(live.styleId);
+            if (cached !== undefined) {
+                return cached;
+            }
+            var projected = this.collection.projectDocxStyle(live.styleId);
+            if (projected !== undefined) {
+                this.projectedById.set(live.styleId, projected);
+            }
+            return projected;
+        }
+        var normalized = normalizeStyleName(name);
+        if (normalized.length === 0) {
+            return undefined;
+        }
+        return this.shellList.find(function (style) {
+            var styleName = style.name;
+            return styleName !== undefined && normalizeStyleName(styleName) === normalized;
+        });
+    };
+    /**
+     * @private
+   * Style-collection surface for the built-in resolver. */
+    StylesPart.prototype.addStyle = function (style) {
+        if (this.collection !== undefined) {
+            if (this.collection.getStyle(style.styleId) !== undefined) {
+                return;
+            }
+            // Live collection accepts Style; hydrate shell via replace path entry.
+            this.collection.hydrateFromDocxStyles([style], true);
+            this.projectedById.delete(style.styleId);
+            return;
+        }
+        if (this.shellById.has(style.styleId)) {
+            return;
+        }
+        this.shellList.push(style);
+        this.shellById.set(style.styleId, style);
+        this.markStylesDirty();
+    };
+    return StylesPart;
+}());
+export { StylesPart };
+var styleCollections = new WeakMap();
+/**
+ * Bind or reuse the document-owned live StyleCollection on a styles part.
+ *
+ * @private
+ */
+function ensureLiveStyleCollection(document, part) {
+    var bound = part.liveCollection();
+    if (bound !== undefined) {
+        styleCollections.set(document, bound);
+        return bound;
+    }
+    var collection = styleCollections.get(document);
+    if (collection === undefined) {
+        collection = new StyleCollection(document, part);
+        styleCollections.set(document, collection);
+    }
+    part.bindLiveCollection(collection);
+    return collection;
+}
+/**
+ * Document-owned live StyleCollection. Stable identity per document.
+ *
+ * @public
+ */
+export function styleCollectionFor(document) {
+    registerStylesFeature();
+    return ensureLiveStyleCollection(document, stylesPartFor(document));
+}
+/**
+ * Raw styles package part (no bind). Used by styleCollectionFor to avoid recursion.
+ *
+ * @private
+ */
+function stylesPartFor(document) {
+    var part = document.featurePart(STYLES);
+    if (part === undefined || !(part instanceof StylesPart)) {
+        throw new DocxError('feature/not-registered', 'Styles part was not loaded; call registerStylesFeature() before WordDocument.open');
+    }
+    return part;
+}
+function parseStylesRoot(root) {
+    var e_6, _a;
+    var docDefaults;
+    var latentStyles;
+    var styles = [];
+    var rootExtrasBeforeStyles = [];
+    var rootExtrasAfterStyles = [];
+    var sawStyle = false;
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'docDefaults') && docDefaults === undefined) {
+                docDefaults = parseDocDefaults(child);
+                continue;
+            }
+            if (isWml(child, 'latentStyles') && latentStyles === undefined) {
+                latentStyles = parseLatentStyles(child);
+                continue;
+            }
+            if (isWml(child, 'style')) {
+                sawStyle = true;
+                var style = parseDocxStyle(child);
+                if (style !== undefined) {
+                    styles.push(style);
+                }
+                continue;
+            }
+            if (sawStyle) {
+                rootExtrasAfterStyles.push(child);
+            }
+            else {
+                rootExtrasBeforeStyles.push(child);
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return { docDefaults: docDefaults, latentStyles: latentStyles, styles: styles, rootExtrasBeforeStyles: rootExtrasBeforeStyles, rootExtrasAfterStyles: rootExtrasAfterStyles };
+}
+function loadStylesPart(part) {
+    if (part === undefined) {
+        var _a = buildDefaultStylesArgs(), docDefaults = _a.docDefaults, styles = _a.styles;
+        return new StylesPart(docDefaults, undefined, styles, [], [], true);
+    }
+    var root = parseXml(utf8Decoder.decode(part.data));
+    if (!isWml(root, 'styles')) {
+        return new StylesPart(undefined, undefined, [], [], [], false);
+    }
+    var parsed = parseStylesRoot(root);
+    return new StylesPart(parsed.docDefaults, parsed.latentStyles, parsed.styles, parsed.rootExtrasBeforeStyles, parsed.rootExtrasAfterStyles, false);
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetStylesFeatureForTests() {
+    registered = false;
+    resetThemeFeatureForTests();
+    resetFontTableFeatureForTests();
+    resetStylesWithEffectsFeatureForTests();
+}
+/**
+ * @private
+ * Register the styles, theme, and font table package-part handlers. Idempotent. */
+export function registerStylesFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerThemeFeature();
+    registerFontTableFeature();
+    registerStylesWithEffectsFeature();
+    registerFeature({ id: STYLES });
+    registerFeaturePartHandler({
+        featureId: STYLES,
+        relationshipTypes: [STYLES_RELATIONSHIP_TYPE, STRICT_STYLES_RELATIONSHIP_TYPE],
+        defaultRelativeTarget: 'styles.xml',
+        partName: STYLES_PART_NAME,
+        contentType: STYLES_CONTENT_TYPE,
+        loadPart: function (part, ctx) {
+            void ctx;
+            return loadStylesPart(part);
+        },
+    });
+    registerFeatureMaterializeHandler({
+        featureId: STYLES,
+        materialize: function (document) {
+            var part = document.featurePart(STYLES);
+            if (part instanceof StylesPart) {
+                part.materializePending(document);
+            }
+        },
+    });
+}
+/**
+ * Styles catalog for a document. Requires {@link registerStylesFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the styles module was not registered before load.
+ * @private
+ */
+export function stylesFor(document) {
+    var part = stylesPartFor(document);
+    ensureLiveStyleCollection(document, part);
+    return part;
+}
+/**
+ * Assign a run character style id and ensure a matching style definition exists.
+ *
+ * Unknown styles throw `styles/undefined-style` (spec §5.2).
+ *
+ * @private
+ */
+export function assignRunStyle(document, run, styleId) {
+    var styles = stylesFor(document);
+    var resolved = resolveStyleForTarget(styles, styleId, 'character');
+    run.characterFormat.characterStyle = resolved.styleId;
+}
+/**
+ * Resolve effective bold, italic, font size, and font names for a run in a paragraph.
+ *
+ * Requires {@link registerStylesFeature} before {@link WordDocument.open}.
+ *
+ * @private
+ */
+export function resolveRunFormatting(document, paragraph, run) {
+    // Package-absent Theme is materialized as a dirty default for save emit only
+    // (theme.ts). Font-slot resolution requires a package-backed Theme part; dirty
+    // defaults leave asciiTheme/hAnsiTheme slots unresolved (formatting-resolver-theme AC).
+    var theme = themeFor(document);
+    return resolveRunFormattingWithStyles(stylesFor(document), paragraph, run, theme.isDirty() ? undefined : theme);
+}
+/**
+ * Apply a built-in or custom style by style id or display name.
+ *
+ * - Paragraph styles write `w:pPr/w:pStyle` via {@link Paragraph.styleId}
+ *   only — format properties are not copied onto the paragraph.
+ * - Character styles (built-in or custom) update DOM state only:
+ *   {@link Paragraph.breakCharacterFormat}.characterStyle and each existing
+ *   {@link TextRange}.characterFormat.characterStyle. Serialization reflects
+ *   that DOM (`w:pPr/w:rPr/w:rStyle` and run `w:rPr/w:rStyle`). Does **not**
+ *   set {@link Paragraph.styleId}.
+ *
+ * Type validation remains in {@link resolveStyleForTarget}.
+ *
+ * @param style Style id string or {@link BuiltInStyle} constant.
+ * @public
+ */
+Paragraph.prototype.applyStyle = function applyStyle(style) {
+    var e_7, _a;
+    var requested = typeof style === 'string' ? style : style;
+    var styles = stylesFor(this.owningDocument());
+    var target = resolveApplyStyleTarget(styles, requested);
+    var resolved = resolveStyleForTarget(styles, requested, target);
+    if (target === 'character') {
+        var styleId = resolved.styleId;
+        this.breakCharacterFormat.characterStyle = styleId;
+        try {
+            for (var _b = __values(this.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var inline = _c.value;
+                if (inline instanceof TextRange) {
+                    inline.characterFormat.characterStyle = styleId;
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return;
+    }
+    this.styleId = resolved.styleId;
+};
+/**
+ * Decide whether {@link Paragraph.applyStyle} should resolve as paragraph or
+ * character. Prefers an existing document style (by id, then display name);
+ * otherwise uses the built-in catalog type. Defaults to paragraph so unknown
+ * and table-typed names keep prior invalid-type / undefined-style behavior.
+ *
+ * @private
+ */
+function resolveApplyStyleTarget(styles, nameOrId) {
+    var byId = styles.getStyle(nameOrId);
+    var existing = byId !== undefined ? byId : styles.findStyleByDisplayName(nameOrId);
+    if (existing !== undefined) {
+        return existing.type === 'character' ? 'character' : 'paragraph';
+    }
+    var byName = getBuiltinStyleTemplate(nameOrId);
+    var template = byName !== undefined ? byName : getBuiltinStyleTemplateByDisplayName(nameOrId);
+    if (template !== undefined && template.type === 'character') {
+        return 'character';
+    }
+    return 'paragraph';
+}
+/**
+ * Read a direct (non-effective) character-format slot from a Style facade without
+ * triggering paragraph effective resolution.
+ * @private
+ */
+function directCharacterSlot(format, key) {
+    if (format === undefined) {
+        return undefined;
+    }
+    // Access private *Value fields via snapshot for reliable authored detection.
+    // Prefer public getters: Style-hosted CF has no resolveEffective* so getters are direct.
+    switch (key) {
+        case 'bold': return format.bold;
+        case 'italic': return format.italic;
+        case 'strikethrough': return format.strikethrough;
+        case 'doubleStrikethrough': return format.doubleStrikethrough;
+        case 'allCaps': return format.allCaps;
+        case 'smallCaps': return format.smallCaps;
+        case 'hidden': return format.hidden;
+        case 'emboss': return format.emboss;
+        case 'engrave': return format.engrave;
+        case 'outline': return format.outline;
+        case 'shadow': return format.shadow;
+        case 'noProof': return format.noProof;
+        case 'webHidden': return format.webHidden;
+        case 'fontSize': return format.fontSize;
+        case 'fontName': return format.fontName;
+        case 'fontNameAscii': return format.fontNameAscii;
+        case 'fontNameNonFarEast': return format.fontNameNonFarEast;
+        case 'fontNameFarEast': return format.fontNameFarEast;
+        case 'fontNameBidi': return format.fontNameBidi;
+        case 'underlineStyle': return format.underlineStyle;
+        case 'underlineColor': return format.underlineColor;
+        case 'textColor': return format.textColor;
+        case 'highlightColor': return format.highlightColor;
+        case 'textBackgroundColor': return format.textBackgroundColor;
+        case 'subSuperScript': return format.subSuperScript;
+        case 'characterSpacing': return format.characterSpacing;
+        case 'position': return format.position;
+        case 'kerning': return format.kerning;
+        case 'scaling': return format.scaling;
+        case 'boldBidi': return format.boldBidi;
+        case 'italicBidi': return format.italicBidi;
+        case 'fontSizeBidi': return format.fontSizeBidi;
+        case 'localeId': return format.localeId;
+        case 'localeIdBidi': return format.localeIdBidi;
+        case 'localeIdFarEast': return format.localeIdFarEast;
+        default: return undefined;
+    }
+}
+function directParagraphSlot(format, key) {
+    if (format === undefined) {
+        return undefined;
+    }
+    switch (key) {
+        case 'horizontalAlignment': return format.horizontalAlignment;
+        case 'keepFollow': return format.keepFollow;
+        case 'keepLines': return format.keepLines;
+        case 'pageBreakBefore': return format.pageBreakBefore;
+        case 'pageBreakAfter': return format.pageBreakAfter;
+        case 'widowControl': return format.widowControl;
+        case 'bidi': return format.bidi;
+        case 'outlineLevel': return format.outlineLevel;
+        case 'leftIndent': return format.leftIndent;
+        case 'rightIndent': return format.rightIndent;
+        case 'firstLineIndent': return format.firstLineIndent;
+        case 'beforeSpacing': return format.beforeSpacing;
+        case 'afterSpacing': return format.afterSpacing;
+        case 'beforeAutospacing': return format.beforeAutospacing;
+        case 'afterAutospacing': return format.afterAutospacing;
+        case 'beforeLines': return format.beforeLines;
+        case 'afterLines': return format.afterLines;
+        case 'lineSpacing': return format.lineSpacing;
+        case 'lineSpacingRule': return format.lineSpacingRule;
+        case 'lineSpacingCount': return format.lineSpacingCount;
+        case 'tabStops': return format.tabStops;
+        case 'borders': {
+            var pf = format;
+            if (typeof pf.readBordersBag === 'function') {
+                return pf.readBordersBag();
+            }
+            return pf.borders;
+        }
+        case 'backColor': return format.backColor;
+        case 'foreColor': return format.foreColor;
+        case 'contextualSpacing': return format.contextualSpacing;
+        case 'mirrorIndents': return format.mirrorIndents;
+        default: return undefined;
+    }
+}
+function modeledRunSlot(props, key) {
+    switch (key) {
+        case 'bold': return props.bold;
+        case 'boldBidi': return props.boldCs;
+        case 'italic': return props.italic;
+        case 'italicBidi': return props.italicCs;
+        case 'fontSize': return props.fontSize;
+        case 'fontSizeBidi': return props.fontSizeCs;
+        case 'kerning': return props.kerning;
+        case 'fontName': return props.asciiFont !== undefined ? props.asciiFont : props.hAnsiFont;
+        case 'fontNameAscii': return props.asciiFont;
+        case 'fontNameNonFarEast': return props.hAnsiFont;
+        case 'fontNameFarEast': return props.eastAsiaFont;
+        case 'fontNameBidi': return props.csFont;
+        case 'textColor': return props.color; // wire hex; CF getter maps Color — leave for CF path only when Color
+        default: return undefined;
+    }
+}
+function modeledParagraphSlot(props, key) {
+    var spacing = props.spacing;
+    var indentation = props.indentation;
+    switch (key) {
+        case 'keepFollow': return props.keepNext;
+        case 'keepLines': return props.keepLines;
+        case 'pageBreakBefore': return props.pageBreakBefore;
+        case 'widowControl': return props.widowControl;
+        case 'contextualSpacing': return props.contextualSpacing;
+        case 'outlineLevel': return props.outlineLevel;
+        case 'beforeSpacing': return spacing === undefined ? undefined : spacing.before;
+        case 'afterSpacing': return spacing === undefined ? undefined : spacing.after;
+        case 'lineSpacing': return spacing === undefined ? undefined : (spacing.lineSpacing !== undefined ? spacing.lineSpacing : spacing.line);
+        case 'lineSpacingRule': return spacing === undefined ? undefined : spacing.lineRule;
+        case 'leftIndent': return indentation === undefined ? undefined : indentation.left;
+        case 'rightIndent': return indentation === undefined ? undefined : indentation.right;
+        case 'firstLineIndent': {
+            if (indentation === undefined)
+                return undefined;
+            if (indentation.firstLine !== undefined)
+                return indentation.firstLine;
+            if (indentation.hanging !== undefined)
+                return -indentation.hanging;
+            return undefined;
+        }
+        default: return undefined;
+    }
+}
+var CF_BOOL_DEFAULT_FALSE = new Set([
+    'bold', 'italic', 'strikethrough', 'doubleStrikethrough', 'allCaps', 'smallCaps',
+    'hidden', 'emboss', 'engrave', 'outline', 'shadow', 'noProof', 'webHidden',
+    'boldBidi', 'italicBidi',
+]);
+/**
+ * Effective break-character value for a paragraph (style chain → docDefaults → API default).
+ * @private
+ */
+Paragraph.prototype.resolveEffectiveCharacterValue = function resolveEffectiveCharacterValue(key) {
+    try {
+        var document_1 = this.owningDocument();
+        var styles = stylesFor(document_1);
+        var collection = styleCollectionFor(document_1);
+        var seen = new Set();
+        var styleId = this.styleId;
+        while (styleId !== undefined && styleId !== '' && !seen.has(styleId)) {
+            seen.add(styleId);
+            var live = collection.getStyle(styleId);
+            if (live !== undefined) {
+                var slot = directCharacterSlot(live.characterFormat, key);
+                if (slot !== undefined) {
+                    return slot;
+                }
+                var base = live.baseStyle;
+                styleId = base === undefined ? undefined : base.styleId;
+                continue;
+            }
+            // unresolved id — stop style walk
+            break;
+        }
+        var docRun = styles.docDefaultsRunProperties();
+        var fromDoc = modeledRunSlot(docRun, key);
+        if (fromDoc !== undefined) {
+            // textColor from modeled is wire hex string — CharacterFormat expects Color enum on public get.
+            // Only return modeled colors for keys that CF effective path knows how to map; skip textColor wire here.
+            if (key === 'textColor') {
+                // leave to API default path below (Transparent) unless we can map — skip hex
+            }
+            else {
+                return fromDoc;
+            }
+        }
+    }
+    catch (_a) {
+        // detached — fall through
+    }
+    // Direct CF getters treat unset as `undefined` (DocIO-style).
+    // Layout/effective consumers apply CHARACTER_FORMAT_DEFAULTS themselves.
+    if (key === 'textColor' || key === 'textBackgroundColor' || key === 'underlineColor' || key === 'highlightColor') {
+        return undefined;
+    }
+    return undefined;
+};
+/**
+ * Effective paragraph-format value (style chain → docDefaults → API default).
+ * @private
+ */
+Paragraph.prototype.resolveEffectiveParagraphValue = function resolveEffectiveParagraphValue(key) {
+    try {
+        var document_2 = this.owningDocument();
+        var styles = stylesFor(document_2);
+        var collection = styleCollectionFor(document_2);
+        var seen = new Set();
+        var styleId = this.styleId;
+        while (styleId !== undefined && styleId !== '' && !seen.has(styleId)) {
+            seen.add(styleId);
+            var live = collection.getStyle(styleId);
+            if (live !== undefined && live instanceof ParagraphStyle) {
+                var slot = directParagraphSlot(live.paragraphFormat, key);
+                if (slot !== undefined) {
+                    return slot;
+                }
+                var base = live.baseParagraphStyle;
+                styleId = base === undefined ? undefined : base.styleId;
+                continue;
+            }
+            if (live !== undefined) {
+                var base = live.baseStyle;
+                styleId = base === undefined ? undefined : base.styleId;
+                continue;
+            }
+            break;
+        }
+        var docP = styles.docDefaultsParagraphProperties();
+        var fromDoc = modeledParagraphSlot(docP, key);
+        if (fromDoc !== undefined) {
+            return fromDoc;
+        }
+    }
+    catch (_a) {
+        // detached
+    }
+    // Direct property getters treat unset as `undefined` (DocIO-style).
+    // Layout/effective consumers apply PARAGRAPH_FORMAT_DEFAULTS themselves
+    // when they need concrete booleans/numbers — do not invent them here.
+    return undefined;
+};
+Object.defineProperty(WordDocument.prototype, 'styles', {
+    get: function () {
+        return styleCollectionFor(this);
+    },
+    configurable: true,
+});
+Object.defineProperty(WordDocument.prototype, 'addTableStyle', {
+    value: function (name) {
+        return styleCollectionFor(this).addTableStyle(name);
+    },
+    writable: true,
+    configurable: true,
+});
+Object.defineProperty(WordDocument.prototype, 'themes', {
+    get: function () {
+        return themeFor(this);
+    },
+    configurable: true,
+});
+/**
+ * Clear `w:pStyle` / `w:rStyle` / table style references that point at `styleId`.
+ * Body + nested tables via document-order visitors; headers/footers when that feature is registered.
+ *
+ * @private
+ */
+function purgeStyleReferencesInDocument(document, styleId) {
+    visitParagraphsInDocumentOrder(document, function (paragraph) {
+        purgeParagraphStyleReferences(paragraph, styleId);
+    });
+    visitTablesInDocumentOrder(document, function (table) {
+        if (table.styleId === styleId) {
+            table.styleId = undefined;
+        }
+    });
+    purgeHeaderFooterStyleReferences(document, styleId);
+}
+/**
+ * Clear paragraph and run style refs on a single paragraph.
+ *
+ * @private
+ */
+function purgeParagraphStyleReferences(paragraph, styleId) {
+    var e_8, _a;
+    if (paragraph.styleId === styleId) {
+        paragraph.styleId = undefined;
+    }
+    try {
+        for (var _b = __values(paragraph.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var inline = _c.value;
+            if (!(inline instanceof TextRange)) {
+                continue;
+            }
+            if (inline.characterFormat.characterStyle === styleId) {
+                inline.characterFormat.characterStyle = undefined;
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+}
+/**
+ * When headers-footers is registered, clear style refs in every loaded HF part
+ * (including nested tables). Duck-types the catalog via featurePart so styles
+ * stays free of a hard HF import — registry presence only.
+ *
+ * @private
+ */
+function purgeHeaderFooterStyleReferences(document, styleId) {
+    var headersFootersFeatureId = featureId('headers-footers');
+    if (!isFeatureRegistered(headersFootersFeatureId)) {
+        return;
+    }
+    var part = document.featurePart(headersFootersFeatureId);
+    if (part === undefined || typeof part !== 'object' || part === null) {
+        return;
+    }
+    var catalog = part;
+    if (typeof catalog.relationshipIds !== 'function') {
+        return;
+    }
+    var kinds = ['header', 'footer'];
+    for (var k = 0; k < kinds.length; k += 1) {
+        var ids = catalog.relationshipIds(kinds[k]);
+        for (var i = 0; i < ids.length; i += 1) {
+            var relationshipId = ids[i];
+            if (typeof catalog.paragraphsForRelationship === 'function') {
+                var paragraphs = catalog.paragraphsForRelationship(relationshipId);
+                for (var p = 0; p < paragraphs.length; p += 1) {
+                    purgeParagraphStyleReferences(paragraphs[p], styleId);
+                }
+            }
+            if (typeof catalog.itemsForRelationship === 'function') {
+                visitTableBlocks(catalog.itemsForRelationship(relationshipId), function (table) {
+                    if (table.styleId === styleId) {
+                        table.styleId = undefined;
+                    }
+                });
+            }
+        }
+    }
+}
+/**
+ * Visit every table block in document order, including nested tables.
+ *
+ * @private
+ */
+function visitTablesInDocumentOrder(document, visit) {
+    visitTableBlocks(document.listBlocks(), visit);
+}
+function asTableStyleMaterializeTarget(value) {
+    if (typeof value !== 'object' || value === null) {
+        return undefined;
+    }
+    var candidate = value;
+    if (typeof candidate.listRows !== 'function') {
+        return undefined;
+    }
+    return value;
+}
+function visitTableBlocks(blocks, visit) {
+    for (var i = 0; i < blocks.length; i += 1) {
+        var block = blocks[i];
+        if (typeof block !== 'object' || block === null) {
+            continue;
+        }
+        var candidate = block;
+        var table = asTableStyleMaterializeTarget(block);
+        if (table === undefined && candidate.type === 'feature') {
+            table = asTableStyleMaterializeTarget(candidate.value);
+        }
+        if (table === undefined) {
+            continue;
+        }
+        visit(table);
+        var rows = table.listRows();
+        for (var r = 0; r < rows.length; r += 1) {
+            var cells = rows[r].listCells();
+            for (var c = 0; c < cells.length; c += 1) {
+                visitTableBlocks(cells[c].listBlocks(), visit);
+            }
+        }
+    }
+}
+registerStylesFeature();