docier-web 0.1.0

package/dist/model/styles/cascade.js

@@ -0,0 +1,636 @@
+import { findOrderedChild, findOrderedChildren } from '../schema-order.js';
+import { integerFrom, isWElement, wAttr } from '../xml.js';
+import { entriesOf } from '../properties/property-keys.js';
+import { ResolvedProperties, ResolvedTableProperties } from './resolved.js';
+export const RUN_CASCADE = [
+    { id: 'docDefaults', layer: 'docDefaults', absoluteToggles: false },
+    { id: 'tableStyle', layer: 'tableStyle', absoluteToggles: false },
+    { id: 'paragraphStyle', layer: 'paragraphStyle', absoluteToggles: false },
+    { id: 'paragraphMark', layer: 'paragraphMark', absoluteToggles: false },
+    { id: 'characterStyle', layer: 'characterStyle', absoluteToggles: false },
+    { id: 'run', layer: 'run', absoluteToggles: true },
+];
+export const NUMBER_RUN_CASCADE = [
+    { id: 'docDefaults', layer: 'docDefaults', absoluteToggles: false },
+    { id: 'tableStyle', layer: 'tableStyle', absoluteToggles: false },
+    { id: 'paragraphStyle', layer: 'paragraphStyle', absoluteToggles: false },
+    { id: 'paragraphMark', layer: 'paragraphMark', absoluteToggles: false },
+    { id: 'characterStyle', layer: 'characterStyle', absoluteToggles: false },
+    { id: 'numbering', layer: 'numbering', absoluteToggles: true },
+];
+export const PARAGRAPH_CASCADE = [
+    { id: 'docDefaults', layer: 'docDefaults', absoluteToggles: false },
+    { id: 'tableStyle', layer: 'tableStyle', absoluteToggles: false },
+    { id: 'numbering', layer: 'numbering', absoluteToggles: false },
+    { id: 'paragraphStyle', layer: 'paragraphStyle', absoluteToggles: false },
+    { id: 'direct', layer: 'paragraphMark', absoluteToggles: true },
+];
+export const TABLE_CASCADE = [
+    { id: 'docDefaults', layer: 'docDefaults' },
+    { id: 'tableStyle', layer: 'tableStyle' },
+    { id: 'tableStyleConditional', layer: 'tableStyleConditional' },
+    { id: 'direct', layer: 'table' },
+];
+export const TABLE_CONDITION_PRECEDENCE = [
+    'wholeTable',
+    'band1Horz',
+    'band2Horz',
+    'band1Vert',
+    'band2Vert',
+    'firstRow',
+    'lastRow',
+    'firstCol',
+    'lastCol',
+    'nwCell',
+    'neCell',
+    'swCell',
+    'seCell',
+];
+const TABLE_LOOK_DEFAULTS = {
+    firstRow: true,
+    lastRow: false,
+    firstColumn: true,
+    lastColumn: false,
+    noHBand: false,
+    noVBand: true,
+};
+export const tableLookFlags = (element) => {
+    if (element === undefined)
+        return TABLE_LOOK_DEFAULTS;
+    const bitmask = integerFrom(wAttr(element, 'val'));
+    if (bitmask !== undefined) {
+        const bits = bitmask & 0x3f0;
+        return {
+            firstRow: (bits & 0x020) !== 0,
+            lastRow: (bits & 0x040) !== 0,
+            firstColumn: (bits & 0x080) !== 0,
+            lastColumn: (bits & 0x100) !== 0,
+            noHBand: (bits & 0x200) !== 0,
+            noVBand: (bits & 0x400) !== 0,
+        };
+    }
+    const read = (name, fallback) => {
+        const raw = wAttr(element, name);
+        if (raw === undefined)
+            return fallback;
+        return raw === '1' || raw === 'true' || raw === 'on';
+    };
+    return {
+        firstRow: read('firstRow', TABLE_LOOK_DEFAULTS.firstRow),
+        lastRow: read('lastRow', TABLE_LOOK_DEFAULTS.lastRow),
+        firstColumn: read('firstColumn', TABLE_LOOK_DEFAULTS.firstColumn),
+        lastColumn: read('lastColumn', TABLE_LOOK_DEFAULTS.lastColumn),
+        noHBand: read('noHBand', TABLE_LOOK_DEFAULTS.noHBand),
+        noVBand: read('noVBand', TABLE_LOOK_DEFAULTS.noVBand),
+    };
+};
+export const conditionsForCell = (position, look) => {
+    const firstRow = position.rowIndex === 0;
+    const lastRow = position.rowIndex === position.rowCount - 1;
+    const firstColumn = position.columnIndex === 0;
+    const lastColumn = position.columnIndex === position.columnCount - 1;
+    const banded = position.rowCount > 1;
+    const selected = ['wholeTable'];
+    if (look.firstRow && firstRow)
+        selected.push('firstRow');
+    if (look.lastRow && lastRow)
+        selected.push('lastRow');
+    if (look.firstColumn && firstColumn)
+        selected.push('firstCol');
+    if (look.lastColumn && lastColumn)
+        selected.push('lastCol');
+    if (!look.noHBand && banded) {
+        const offset = look.firstRow ? position.rowIndex - 1 : position.rowIndex;
+        if (offset >= 0)
+            selected.push(offset % 2 === 0 ? 'band1Horz' : 'band2Horz');
+    }
+    if (!look.noVBand) {
+        const offset = look.firstColumn ? position.columnIndex - 1 : position.columnIndex;
+        if (offset >= 0)
+            selected.push(offset % 2 === 0 ? 'band1Vert' : 'band2Vert');
+    }
+    if (firstRow && firstColumn)
+        selected.push('nwCell');
+    if (firstRow && lastColumn)
+        selected.push('neCell');
+    if (lastRow && firstColumn)
+        selected.push('swCell');
+    if (lastRow && lastColumn)
+        selected.push('seCell');
+    return sortByPrecedence(selected);
+};
+export const sortByPrecedence = (conditions) => {
+    const rank = (name) => {
+        const index = TABLE_CONDITION_PRECEDENCE.indexOf(name);
+        return index < 0 ? TABLE_CONDITION_PRECEDENCE.length : index;
+    };
+    return [...conditions].sort((left, right) => rank(left) - rank(right));
+};
+export const ancestorOfKind = (element, localName) => {
+    let current = element.parent;
+    while (current !== undefined) {
+        if (isWElement(current, localName))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+};
+const gridSpanOf = (cell) => {
+    const properties = findOrderedChild(cell, 'tcPr');
+    if (properties === undefined)
+        return 1;
+    const span = findOrderedChild(properties, 'gridSpan');
+    if (span === undefined)
+        return 1;
+    const raw = integerFrom(wAttr(span, 'val'));
+    return raw === undefined || raw < 1 ? 1 : raw;
+};
+const gridBeforeOf = (row) => {
+    const properties = findOrderedChild(row, 'trPr');
+    if (properties === undefined)
+        return 0;
+    const before = findOrderedChild(properties, 'gridBefore');
+    if (before === undefined)
+        return 0;
+    const raw = integerFrom(wAttr(before, 'val'));
+    return raw === undefined || raw < 0 ? 0 : raw;
+};
+export const cellPositionOf = (cell) => {
+    const row = ancestorOfKind(cell, 'tr');
+    if (row === undefined)
+        return { rowIndex: 0, columnIndex: 0, rowCount: 1, columnCount: 1 };
+    const table = ancestorOfKind(row, 'tbl');
+    const rowList = table === undefined ? [] : findOrderedChildren(table, 'tr');
+    const rowIndex = Math.max(rowList.indexOf(row), 0);
+    let columnIndex = gridBeforeOf(row);
+    for (const sibling of findOrderedChildren(row, 'tc')) {
+        if (sibling === cell)
+            break;
+        columnIndex += gridSpanOf(sibling);
+    }
+    let columnCount = 0;
+    for (const each of rowList) {
+        let width = gridBeforeOf(each);
+        for (const eachCell of findOrderedChildren(each, 'tc'))
+            width += gridSpanOf(eachCell);
+        if (width > columnCount)
+            columnCount = width;
+    }
+    return {
+        rowIndex,
+        columnIndex,
+        rowCount: Math.max(rowList.length, 1),
+        columnCount: Math.max(columnCount, 1),
+    };
+};
+const CNF_STYLE_ORDER = [
+    'firstRow',
+    'lastRow',
+    'firstColumn',
+    'lastColumn',
+    'oddVBand',
+    'evenVBand',
+    'oddHBand',
+    'evenHBand',
+    'firstRowFirstColumn',
+    'firstRowLastColumn',
+    'lastRowFirstColumn',
+    'lastRowLastColumn',
+];
+const CNF_TO_CONDITION = {
+    firstRow: 'firstRow',
+    lastRow: 'lastRow',
+    firstColumn: 'firstCol',
+    lastColumn: 'lastCol',
+    oddVBand: 'band1Vert',
+    evenVBand: 'band2Vert',
+    oddHBand: 'band1Horz',
+    evenHBand: 'band2Horz',
+    firstRowFirstColumn: 'nwCell',
+    firstRowLastColumn: 'neCell',
+    lastRowFirstColumn: 'swCell',
+    lastRowLastColumn: 'seCell',
+};
+const cnfStyleConditions = (element) => {
+    const properties = findOrderedChild(element, 'tcPr') ?? findOrderedChild(element, 'trPr');
+    if (properties === undefined)
+        return [];
+    const cnf = findOrderedChild(properties, 'cnfStyle');
+    if (cnf === undefined)
+        return [];
+    const value = wAttr(cnf, 'val');
+    if (value === undefined)
+        return [];
+    const padded = value.padEnd(CNF_STYLE_ORDER.length, '0');
+    const selected = [];
+    for (let index = 0; index < CNF_STYLE_ORDER.length; index += 1) {
+        if (padded.charAt(index) !== '1')
+            continue;
+        const name = CNF_STYLE_ORDER[index];
+        if (name === undefined)
+            continue;
+        const condition = CNF_TO_CONDITION[name];
+        if (condition !== undefined && !selected.includes(condition))
+            selected.push(condition);
+    }
+    return selected;
+};
+export const tableStyleContextOf = (element) => {
+    const self = isWElement(element, 'tbl');
+    const table = self ? element : ancestorOfKind(element, 'tbl');
+    if (table === undefined)
+        return undefined;
+    const properties = findOrderedChild(table, 'tblPr');
+    if (properties === undefined)
+        return undefined;
+    const styleElement = findOrderedChild(properties, 'tblStyle');
+    const styleId = styleElement === undefined ? undefined : wAttr(styleElement, 'val');
+    if (styleId === undefined || styleId.length === 0)
+        return undefined;
+    const look = tableLookFlags(findOrderedChild(properties, 'tblLook'));
+    const nearest = (localName) => isWElement(element, localName) ? element : ancestorOfKind(element, localName);
+    const cell = self ? undefined : nearest('tc');
+    const row = self ? undefined : nearest('tr');
+    const explicit = [
+        ...(row === undefined ? [] : cnfStyleConditions(row)),
+        ...(cell === undefined ? [] : cnfStyleConditions(cell)),
+    ];
+    const positional = cell === undefined ? ['wholeTable'] : conditionsForCell(cellPositionOf(cell), look);
+    return { styleId, conditions: sortByPrecedence([...positional, ...explicit]) };
+};
+const directStyleId = (properties, localName) => {
+    if (properties === undefined)
+        return undefined;
+    const element = findOrderedChild(properties, localName);
+    return element === undefined ? undefined : wAttr(element, 'val');
+};
+const contextKey = (styleKeys, tableStyle, numbering) => [
+    ...styleKeys,
+    tableStyle?.styleId ?? '',
+    tableStyle?.conditions.join(',') ?? '',
+    numbering === undefined ? '' : `${numbering.numId}/${numbering.ilvl}`,
+].join('');
+const elementContentKey = (element) => {
+    let key = `<${element.localName}`;
+    for (const attribute of element.attributes) {
+        key += ` ${attribute.prefix}:${attribute.localName}=${attribute.value}`;
+    }
+    key += '>';
+    for (const child of element.children) {
+        if (child.kind === 'element')
+            key += elementContentKey(child);
+        else if (child.kind === 'text' || child.kind === 'cdata')
+            key += child.value;
+    }
+    return key;
+};
+const contentKey = (element) => element === undefined ? '' : elementContentKey(element);
+export class StyleResolver {
+    styles;
+    runCache = new Map();
+    paragraphCache = new Map();
+    numberingRunCache = new Map();
+    tableCache = new Map();
+    cellCache = new Map();
+    cachedRevision = -1;
+    constructor(styles) {
+        this.styles = styles;
+    }
+    get revision() {
+        return this.styles?.revision ?? 0;
+    }
+    invalidate() {
+        this.runCache.clear();
+        this.paragraphCache.clear();
+        this.numberingRunCache.clear();
+        this.tableCache.clear();
+        this.cellCache.clear();
+        this.cachedRevision = -1;
+    }
+    sync() {
+        if (this.cachedRevision === this.revision)
+            return;
+        this.invalidate();
+        this.cachedRevision = this.revision;
+    }
+    cached(cache, key, content, signature, compute) {
+        const bucket = cache.get(key);
+        if (bucket !== undefined && bucket.content === content) {
+            const hit = bucket.entries.get(signature);
+            if (hit !== undefined)
+                return hit;
+        }
+        const resolved = compute();
+        if (bucket === undefined || bucket.content !== content) {
+            cache.set(key, { content, entries: new Map([[signature, resolved]]) });
+        }
+        else {
+            bucket.entries.set(signature, resolved);
+        }
+        return resolved;
+    }
+    resolveRun(input) {
+        this.sync();
+        const key = input.runProperties;
+        const signature = contextKey([
+            directStyleId(input.paragraphProperties, 'pStyle') ?? '',
+            directStyleId(input.runProperties, 'rStyle') ?? '',
+        ], input.tableStyle, input.numbering);
+        if (key === undefined)
+            return this.computeRun(input);
+        const content = `${contentKey(key)}${contentKey(input.paragraphProperties)}`;
+        return this.cached(this.runCache, key, content, signature, () => this.computeRun(input));
+    }
+    resolveParagraph(input) {
+        this.sync();
+        const key = input.paragraphProperties;
+        const signature = contextKey([directStyleId(input.paragraphProperties, 'pStyle') ?? ''], input.tableStyle, input.numbering);
+        if (key === undefined)
+            return this.computeParagraph(input);
+        return this.cached(this.paragraphCache, key, contentKey(key), signature, () => this.computeParagraph(input));
+    }
+    resolveNumberingRun(input) {
+        this.sync();
+        const key = input.numbering.level.runPropertiesElement;
+        const signature = contextKey([directStyleId(input.paragraphProperties, 'pStyle') ?? ''], input.tableStyle, input.numbering);
+        if (key === undefined)
+            return this.computeNumberingRun(input);
+        const content = `${contentKey(key)} ${contentKey(input.paragraphProperties)}`;
+        return this.cached(this.numberingRunCache, key, content, signature, () => this.computeNumberingRun(input));
+    }
+    resolveTable(input) {
+        this.sync();
+        const key = input.properties;
+        const signature = [
+            input.kind,
+            input.tableStyle?.styleId ?? '',
+            input.tableStyle?.conditions.join(',') ?? '',
+        ].join(' ');
+        if (key === undefined)
+            return this.computeTable(input);
+        const cache = input.kind === 'cell' ? this.cellCache : this.tableCache;
+        return this.cached(cache, key, contentKey(key), signature, () => this.computeTable(input));
+    }
+    applyParagraphStyleRunProperties(resolved, styleId, layer) {
+        for (const style of this.chainOf(styleId)) {
+            resolved.apply(entriesOf(style.runPropertiesElement), { layer, styleId: style.styleId });
+            const linked = this.linkedOf(style);
+            if (linked === undefined || linked.type !== 'character')
+                continue;
+            resolved.apply(entriesOf(linked.runPropertiesElement), { layer, styleId: linked.styleId });
+        }
+    }
+    chainOf(styleId) {
+        return this.styles?.chain(styleId) ?? [];
+    }
+    linkedOf(style) {
+        return this.styles?.linkedStyle(style);
+    }
+    applyCharacterStyleRunProperties(resolved, styleId, layer) {
+        for (const style of this.chainOf(styleId)) {
+            if (style.type !== undefined && style.type !== 'character')
+                continue;
+            resolved.apply(entriesOf(style.runPropertiesElement), { layer, styleId: style.styleId });
+        }
+    }
+    applyParagraphStyleChain(resolved, styleId, layer) {
+        for (const style of this.chainOf(styleId)) {
+            resolved.apply(entriesOf(style.paragraphPropertiesElement), { layer, styleId: style.styleId });
+            const linked = this.linkedOf(style);
+            if (linked === undefined || linked.type !== 'character')
+                continue;
+            resolved.apply(entriesOf(linked.paragraphPropertiesElement), {
+                layer,
+                styleId: linked.styleId,
+            });
+        }
+    }
+    defaultsRun() {
+        return this.styles?.defaultRunPropertiesElement();
+    }
+    defaultsParagraph() {
+        return this.styles?.defaultParagraphPropertiesElement();
+    }
+    applyTableStyle(resolved, context, runLevel) {
+        if (context === undefined)
+            return;
+        const chain = this.chainOf(context.styleId);
+        for (const style of chain) {
+            if (style.type !== undefined && style.type !== 'table')
+                continue;
+            const base = runLevel ? style.runPropertiesElement : style.paragraphPropertiesElement;
+            resolved.apply(entriesOf(base), { layer: 'tableStyle', styleId: style.styleId });
+        }
+        for (const condition of context.conditions) {
+            for (const style of chain) {
+                if (style.type !== undefined && style.type !== 'table')
+                    continue;
+                const element = runLevel
+                    ? style.conditionalRunPropertiesElement(condition)
+                    : style.conditionalParagraphPropertiesElement(condition);
+                if (element === undefined)
+                    continue;
+                resolved.apply(entriesOf(element), {
+                    layer: 'tableStyleConditional',
+                    styleId: style.styleId,
+                    condition,
+                });
+            }
+        }
+    }
+    applyNumbering(resolved, numbering) {
+        if (numbering === undefined)
+            return;
+        resolved.apply(entriesOf(numbering.level.paragraphPropertiesElement), {
+            layer: 'numbering',
+            numId: numbering.numId,
+            ilvl: numbering.ilvl,
+        });
+    }
+    applyNumberingRunProperties(resolved, numbering) {
+        if (numbering === undefined)
+            return;
+        resolved.apply(entriesOf(numbering.level.runPropertiesElement), {
+            layer: 'numbering',
+            numId: numbering.numId,
+            ilvl: numbering.ilvl,
+            absoluteToggles: true,
+        });
+    }
+    defaultTableStyleChain() {
+        const styles = this.styles;
+        if (styles === undefined)
+            return [];
+        const declared = styles.defaultStyle('table');
+        if (declared !== undefined)
+            return styles.chain(declared.styleId);
+        const fallback = styles.style('TableNormal');
+        return fallback === undefined ? [] : styles.chain(fallback.styleId);
+    }
+    applyTableStyleLayer(resolved, layers, container, chain, origin, condition) {
+        for (const style of chain) {
+            if (style.type !== undefined && style.type !== 'table')
+                continue;
+            const scope = condition === undefined ? style.element : style.conditionalElement(condition);
+            if (scope === undefined)
+                continue;
+            const element = findOrderedChild(scope, container);
+            if (element === undefined)
+                continue;
+            layers.push(element);
+            const scoped = condition === undefined
+                ? { ...origin, styleId: style.styleId }
+                : { ...origin, styleId: style.styleId, condition };
+            resolved.apply(entriesOf(element), scoped);
+        }
+    }
+    computeTable(input) {
+        const resolved = new ResolvedProperties();
+        const layers = [];
+        const container = input.kind === 'cell' ? 'tcPr' : 'tblPr';
+        const context = input.tableStyle;
+        const chain = context === undefined ? [] : this.chainOf(context.styleId);
+        for (const level of TABLE_CASCADE) {
+            switch (level.id) {
+                case 'docDefaults':
+                    if (context !== undefined)
+                        break;
+                    this.applyTableStyleLayer(resolved, layers, container, this.defaultTableStyleChain(), { layer: level.layer }, undefined);
+                    break;
+                case 'tableStyle':
+                    this.applyTableStyleLayer(resolved, layers, container, chain, { layer: level.layer }, undefined);
+                    break;
+                case 'tableStyleConditional':
+                    for (const condition of context?.conditions ?? []) {
+                        this.applyTableStyleLayer(resolved, layers, container, chain, { layer: level.layer }, condition);
+                    }
+                    break;
+                case 'direct':
+                    layers.push(input.properties);
+                    resolved.apply(entriesOf(input.properties), {
+                        layer: input.kind === 'cell' ? 'tableCell' : level.layer,
+                        absoluteToggles: true,
+                    });
+                    break;
+                default:
+                    break;
+            }
+        }
+        return new ResolvedTableProperties(layers, resolved);
+    }
+    computeRun(input) {
+        const resolved = new ResolvedProperties();
+        const paragraphStyleId = directStyleId(input.paragraphProperties, 'pStyle');
+        const characterStyleId = directStyleId(input.runProperties, 'rStyle');
+        const paragraphMark = input.paragraphProperties === undefined
+            ? undefined
+            : findOrderedChild(input.paragraphProperties, 'rPr');
+        for (const level of RUN_CASCADE) {
+            switch (level.id) {
+                case 'docDefaults':
+                    resolved.apply(entriesOf(this.defaultsRun()), { layer: level.layer });
+                    break;
+                case 'tableStyle':
+                    this.applyTableStyle(resolved, input.tableStyle, true);
+                    break;
+                case 'paragraphStyle':
+                    if (paragraphStyleId !== undefined) {
+                        this.applyParagraphStyleRunProperties(resolved, paragraphStyleId, level.layer);
+                    }
+                    break;
+                case 'paragraphMark':
+                    resolved.apply(entriesOf(paragraphMark), { layer: level.layer });
+                    break;
+                case 'characterStyle':
+                    if (characterStyleId !== undefined) {
+                        this.applyCharacterStyleRunProperties(resolved, characterStyleId, level.layer);
+                    }
+                    break;
+                case 'run':
+                    resolved.apply(entriesOf(input.runProperties), {
+                        layer: level.layer,
+                        absoluteToggles: true,
+                    });
+                    break;
+                default:
+                    break;
+            }
+        }
+        return resolved;
+    }
+    computeNumberingRun(input) {
+        const resolved = new ResolvedProperties();
+        const paragraphStyleId = directStyleId(input.paragraphProperties, 'pStyle');
+        const characterStyleId = directStyleId(input.numbering.level.runPropertiesElement, 'rStyle');
+        const paragraphMark = input.paragraphProperties === undefined
+            ? undefined
+            : findOrderedChild(input.paragraphProperties, 'rPr');
+        for (const level of NUMBER_RUN_CASCADE) {
+            switch (level.id) {
+                case 'docDefaults':
+                    resolved.apply(entriesOf(this.defaultsRun()), { layer: level.layer });
+                    break;
+                case 'tableStyle':
+                    this.applyTableStyle(resolved, input.tableStyle, true);
+                    break;
+                case 'paragraphStyle':
+                    if (paragraphStyleId !== undefined) {
+                        this.applyParagraphStyleRunProperties(resolved, paragraphStyleId, level.layer);
+                    }
+                    break;
+                case 'paragraphMark':
+                    resolved.apply(entriesOf(paragraphMark), { layer: level.layer });
+                    break;
+                case 'characterStyle':
+                    if (characterStyleId !== undefined) {
+                        this.applyCharacterStyleRunProperties(resolved, characterStyleId, level.layer);
+                    }
+                    break;
+                case 'numbering':
+                    this.applyNumberingRunProperties(resolved, input.numbering);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return resolved;
+    }
+    computeParagraph(input) {
+        const resolved = new ResolvedProperties();
+        const paragraphStyleId = directStyleId(input.paragraphProperties, 'pStyle');
+        for (const level of PARAGRAPH_CASCADE) {
+            switch (level.id) {
+                case 'docDefaults':
+                    resolved.apply(entriesOf(this.defaultsParagraph()), { layer: level.layer });
+                    break;
+                case 'tableStyle':
+                    this.applyTableStyle(resolved, input.tableStyle, false);
+                    break;
+                case 'numbering':
+                    this.applyNumbering(resolved, input.numbering);
+                    break;
+                case 'paragraphStyle':
+                    if (paragraphStyleId !== undefined) {
+                        this.applyParagraphStyleChain(resolved, paragraphStyleId, level.layer);
+                    }
+                    break;
+                case 'direct':
+                    resolved.apply(entriesOf(input.paragraphProperties), {
+                        layer: 'paragraphMark',
+                        absoluteToggles: true,
+                    });
+                    break;
+                default:
+                    break;
+            }
+        }
+        return resolved;
+    }
+    effectiveParagraphStyleId(paragraphProperties) {
+        const declared = directStyleId(paragraphProperties, 'pStyle');
+        if (declared !== undefined)
+            return declared;
+        return this.styles?.effectiveDefaultStyle('paragraph')?.styleId ?? 'Normal';
+    }
+}
+//# sourceMappingURL=cascade.js.map