@a3s-lab/office 0.13.0 → 0.14.0

package/dist/4104.js

@@ -3061,6 +3061,1006 @@ function work_xlsx_images_partNumber(path) {
 function work_xlsx_images_escapeXml(value) {
     return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
 }
+const xlsxStyleByFortuneStyle = {
+    1: 'thin',
+    2: 'hair',
+    3: 'dotted',
+    4: 'dashed',
+    5: 'dashDot',
+    6: 'dashDotDot',
+    7: 'double',
+    8: 'medium',
+    9: 'mediumDashed',
+    10: 'mediumDashDot',
+    11: 'mediumDashDotDot',
+    12: 'slantDashDot',
+    13: 'thick'
+};
+const fortuneStyleByXlsxStyle = new Map(Object.entries(xlsxStyleByFortuneStyle).map(([fortune, xlsx])=>[
+        xlsx,
+        fortune
+    ]));
+function collectXlsxCellBorders(sheet) {
+    const targets = spreadsheetBorderTargets(sheet);
+    const borders = new Map();
+    const source = Array.isArray(sheet.config?.borderInfo) ? sheet.config.borderInfo : [];
+    for (const candidate of source){
+        if (!work_xlsx_cell_borders_isRecord(candidate)) continue;
+        if ('cell' === candidate.rangeType) {
+            applySpreadsheetCellBorderRecord(candidate, targets, borders);
+            continue;
+        }
+        if ('range' !== candidate.rangeType || 'string' != typeof candidate.borderType || !Array.isArray(candidate.range)) continue;
+        const line = spreadsheetBorderLine(candidate);
+        for (const rangeCandidate of candidate.range){
+            const range = spreadsheetBorderRange(rangeCandidate);
+            if (range) {
+                for (const target of targets.values())if (spreadsheetBorderRangeContains(range, target)) applySpreadsheetRangeBorder(borders, target, range, candidate.borderType, line);
+            }
+        }
+    }
+    return borders;
+}
+function fortuneBorderInfoFromXlsxCells(entries) {
+    return entries.flatMap(({ border, column, row })=>{
+        if (!border) return [];
+        const value = {
+            col_index: column,
+            row_index: row
+        };
+        setFortuneBorderLine(value, 'l', border.left);
+        setFortuneBorderLine(value, 'r', border.right);
+        setFortuneBorderLine(value, 't', border.top);
+        setFortuneBorderLine(value, 'b', border.bottom);
+        if (border.diagonal) setFortuneBorderLine(value, 's', border.diagonal);
+        return Object.keys(value).length > 2 ? [
+            {
+                rangeType: 'cell',
+                value
+            }
+        ] : [];
+    });
+}
+function xlsxCellBorderKey(row, column) {
+    return `${row}_${column}`;
+}
+function xlsxCellBorderLineFromFortune(value) {
+    if (null === value) return null;
+    if (!work_xlsx_cell_borders_isRecord(value)) return;
+    const style = xlsxStyleByFortuneStyle[String(value.style ?? '')];
+    const color = normalizeRgbColor(value.color);
+    return style && color ? {
+        color,
+        style
+    } : void 0;
+}
+function fortuneBorderStyle(style) {
+    return fortuneStyleByXlsxStyle.get(style) ?? '1';
+}
+function spreadsheetBorderTargets(sheet) {
+    const targets = new Map();
+    for (const [row, values] of sparseArrayEntries(sheet.data))for (const [column, cell] of sparseArrayEntries(values))if (cell) targets.set(xlsxCellBorderKey(row, column), {
+        column,
+        row
+    });
+    for (const candidate of Array.isArray(sheet.config?.borderInfo) ? sheet.config.borderInfo : []){
+        if (!work_xlsx_cell_borders_isRecord(candidate) || 'cell' !== candidate.rangeType) continue;
+        const value = candidate.value;
+        if (!work_xlsx_cell_borders_isRecord(value)) continue;
+        const row = nonNegativeInteger(value.row_index);
+        const column = nonNegativeInteger(value.col_index);
+        if (null !== row && null !== column) targets.set(xlsxCellBorderKey(row, column), {
+            column,
+            row
+        });
+    }
+    return targets;
+}
+function applySpreadsheetCellBorderRecord(record, targets, borders) {
+    if (!work_xlsx_cell_borders_isRecord(record.value)) return;
+    const row = nonNegativeInteger(record.value.row_index);
+    const column = nonNegativeInteger(record.value.col_index);
+    if (null === row || null === column) return;
+    const key = xlsxCellBorderKey(row, column);
+    if (!targets.has(key)) return;
+    const border = {
+        ...borders.get(key) ?? {}
+    };
+    applyCellLine(border, 'left', record.value.l);
+    applyCellLine(border, 'right', record.value.r);
+    applyCellLine(border, 'top', record.value.t);
+    applyCellLine(border, 'bottom', record.value.b);
+    const diagonal = xlsxCellBorderLineFromFortune(record.value.s);
+    if (void 0 !== diagonal) {
+        border.diagonal = diagonal;
+        border.diagonalUp = null !== diagonal;
+        border.diagonalDown = false;
+    }
+    borders.set(key, border);
+}
+function applyCellLine(border, side, value) {
+    const line = xlsxCellBorderLineFromFortune(value);
+    if (void 0 !== line) border[side] = line;
+}
+function applySpreadsheetRangeBorder(borders, target, range, borderType, line) {
+    const key = xlsxCellBorderKey(target.row, target.column);
+    const border = {
+        ...borders.get(key) ?? {}
+    };
+    const onTop = target.row === range.row[0];
+    const onBottom = target.row === range.row[1];
+    const onLeft = target.column === range.column[0];
+    const onRight = target.column === range.column[1];
+    switch(borderType){
+        case 'border-top':
+            if (onTop) border.top = line;
+            break;
+        case 'border-bottom':
+            if (onBottom) border.bottom = line;
+            break;
+        case 'border-left':
+            if (onLeft) border.left = line;
+            break;
+        case 'border-right':
+            if (onRight) border.right = line;
+            break;
+        case 'border-none':
+            border.top = null;
+            border.bottom = null;
+            border.left = null;
+            border.right = null;
+            border.diagonal = null;
+            border.diagonalUp = false;
+            border.diagonalDown = false;
+            break;
+        case 'border-all':
+            border.top = line;
+            border.bottom = line;
+            border.left = line;
+            border.right = line;
+            break;
+        case 'border-outside':
+            if (onTop) border.top = line;
+            if (onBottom) border.bottom = line;
+            if (onLeft) border.left = line;
+            if (onRight) border.right = line;
+            break;
+        case 'border-inside':
+            if (!onTop) border.top = line;
+            if (!onBottom) border.bottom = line;
+            if (!onLeft) border.left = line;
+            if (!onRight) border.right = line;
+            break;
+        case 'border-horizontal':
+            if (!onTop) border.top = line;
+            if (!onBottom) border.bottom = line;
+            break;
+        case 'border-vertical':
+            if (!onLeft) border.left = line;
+            if (!onRight) border.right = line;
+            break;
+        case 'border-slash':
+            border.diagonal = line;
+            border.diagonalUp = null !== line;
+            border.diagonalDown = false;
+            break;
+        default:
+            return;
+    }
+    borders.set(key, border);
+}
+function spreadsheetBorderLine(record) {
+    const style = xlsxStyleByFortuneStyle[String(record.style ?? '')];
+    const color = normalizeRgbColor(record.color);
+    return style && color ? {
+        color,
+        style
+    } : null;
+}
+function spreadsheetBorderRange(value) {
+    if (!work_xlsx_cell_borders_isRecord(value)) return null;
+    const row = spreadsheetBorderAxis(value.row);
+    const column = spreadsheetBorderAxis(value.column);
+    return row && column ? {
+        column,
+        row
+    } : null;
+}
+function spreadsheetBorderAxis(value) {
+    if (!Array.isArray(value) || 2 !== value.length) return null;
+    const start = nonNegativeInteger(value[0]);
+    const end = nonNegativeInteger(value[1]);
+    return null !== start && null !== end && start <= end ? [
+        start,
+        end
+    ] : null;
+}
+function spreadsheetBorderRangeContains(range, target) {
+    return target.row >= range.row[0] && target.row <= range.row[1] && target.column >= range.column[0] && target.column <= range.column[1];
+}
+function setFortuneBorderLine(target, name, line) {
+    if (!line) return;
+    target[name] = {
+        color: normalizeRgbColor(line.color) ?? '#000000',
+        style: fortuneBorderStyle(line.style)
+    };
+}
+function normalizeRgbColor(value) {
+    if ('string' != typeof value) return null;
+    const color = value.trim().toLowerCase();
+    if (/^#[0-9a-f]{6}$/.test(color)) return color;
+    if (!/^#[0-9a-f]{3}$/.test(color)) return null;
+    return `#${[
+        ...color.slice(1)
+    ].map((character)=>character.repeat(2)).join('')}`;
+}
+function nonNegativeInteger(value) {
+    return 'number' == typeof value && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function work_xlsx_cell_borders_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const borderChildOrder = [
+    'start',
+    'end',
+    'left',
+    'right',
+    'top',
+    'bottom',
+    'diagonal',
+    'vertical',
+    'horizontal',
+    'extLst'
+];
+function ensureXlsxStyleCollection(document1, name, anchors) {
+    const root = document1.documentElement;
+    const existing = directChild(root, name);
+    if (existing) return existing;
+    const collection = document1.createElementNS(root.namespaceURI, name);
+    root.insertBefore(collection, directChildren(root).find((child)=>anchors.includes(child.localName)) ?? null);
+    return collection;
+}
+function defaultXlsxFill(document1, patternType) {
+    const fill = document1.createElementNS(document1.documentElement.namespaceURI, 'fill');
+    const pattern = document1.createElementNS(document1.documentElement.namespaceURI, 'patternFill');
+    pattern.setAttribute('patternType', patternType);
+    fill.append(pattern);
+    return fill;
+}
+function defaultXlsxBorder(document1) {
+    const border = document1.createElementNS(document1.documentElement.namespaceURI, 'border');
+    for (const name of [
+        'left',
+        'right',
+        'top',
+        'bottom',
+        'diagonal'
+    ])border.append(document1.createElementNS(document1.documentElement.namespaceURI, name));
+    return border;
+}
+function setXlsxBorderLine(document1, border, name, line) {
+    removeXlsxChildren(border, name);
+    const element = document1.createElementNS(document1.documentElement.namespaceURI, name);
+    if (line) {
+        element.setAttribute('style', line.style);
+        const color = xlsxRgbColor(line.color);
+        if (color) {
+            const child = document1.createElementNS(document1.documentElement.namespaceURI, 'color');
+            child.setAttribute('rgb', color);
+            element.append(child);
+        }
+    }
+    insertXlsxOrderedChild(border, element, borderChildOrder);
+}
+function writeXlsxAlignment(document1, xf, style) {
+    let alignment = directChild(xf, 'alignment');
+    if (!alignment) {
+        alignment = document1.createElementNS(document1.documentElement.namespaceURI, 'alignment');
+        xf.insertBefore(alignment, directChildren(xf).find((child)=>[
+                'protection',
+                'extLst'
+            ].includes(child.localName)) ?? null);
+    }
+    if (void 0 !== style.horizontal) alignment.setAttribute('horizontal', style.horizontal);
+    if (void 0 !== style.vertical) alignment.setAttribute('vertical', style.vertical);
+    if (void 0 !== style.wrapText) alignment.setAttribute('wrapText', style.wrapText ? '1' : '0');
+    if (void 0 !== style.textRotation) alignment.setAttribute('textRotation', String(style.textRotation));
+}
+function setXlsxValueChild(document1, parent, name, value, order) {
+    removeXlsxChildren(parent, name);
+    const child = document1.createElementNS(document1.documentElement.namespaceURI, name);
+    child.setAttribute('val', value);
+    insertXlsxOrderedChild(parent, child, order);
+}
+function setXlsxColorChild(document1, parent, color, order) {
+    removeXlsxChildren(parent, 'color');
+    const child = document1.createElementNS(document1.documentElement.namespaceURI, 'color');
+    child.setAttribute('rgb', color);
+    insertXlsxOrderedChild(parent, child, order);
+}
+function setXlsxToggleChild(document1, parent, name, enabled, order) {
+    removeXlsxChildren(parent, name);
+    if (!enabled) return;
+    const child = document1.createElementNS(document1.documentElement.namespaceURI, name);
+    child.setAttribute('val', '1');
+    insertXlsxOrderedChild(parent, child, order);
+}
+function setXlsxUnderlineChild(document1, parent, enabled, order) {
+    removeXlsxChildren(parent, 'u');
+    if (!enabled) return;
+    const child = document1.createElementNS(document1.documentElement.namespaceURI, 'u');
+    child.setAttribute('val', 'single');
+    insertXlsxOrderedChild(parent, child, order);
+}
+function xlsxRgbColor(value) {
+    if ('string' != typeof value) return null;
+    const color = value.trim().replace('#', '').toUpperCase();
+    if (/^[0-9A-F]{6}$/.test(color)) return `FF${color}`;
+    if (/^[0-9A-F]{8}$/.test(color)) return color;
+    if (/^[0-9A-F]{3}$/.test(color)) return `FF${[
+        ...color
+    ].map((character)=>character.repeat(2)).join('')}`;
+    return null;
+}
+function removeXlsxChildren(parent, name) {
+    for (const child of directChildren(parent, name))child.remove();
+}
+function insertXlsxOrderedChild(parent, child, order) {
+    const requested = order.indexOf(child.localName);
+    const anchor = directChildren(parent).find((candidate)=>order.indexOf(candidate.localName) > requested);
+    parent.insertBefore(child, anchor ?? null);
+}
+const fontChildOrder = [
+    'name',
+    'charset',
+    'family',
+    'b',
+    'i',
+    'strike',
+    'outline',
+    'shadow',
+    'condense',
+    'extend',
+    'color',
+    'sz',
+    'u',
+    'vertAlign',
+    'scheme'
+];
+class XlsxDirectCellStyleWriter {
+    styles;
+    fonts;
+    fills;
+    borders;
+    cellXfs;
+    generatedFonts = new Map();
+    generatedFills = new Map();
+    generatedBorders = new Map();
+    generatedStyles = new Map();
+    changed = false;
+    constructor(styles){
+        this.styles = styles;
+        const root = styles.documentElement;
+        this.fonts = ensureXlsxStyleCollection(styles, 'fonts', [
+            'fills',
+            'borders',
+            'cellStyleXfs',
+            'cellXfs',
+            'cellStyles',
+            'dxfs',
+            'tableStyles',
+            'colors',
+            'extLst'
+        ]);
+        if (!directChildren(this.fonts, 'font').length) {
+            this.fonts.append(styles.createElementNS(root.namespaceURI, 'font'));
+            this.changed = true;
+        }
+        this.fills = ensureXlsxStyleCollection(styles, 'fills', [
+            'borders',
+            'cellStyleXfs',
+            'cellXfs',
+            'cellStyles',
+            'dxfs',
+            'tableStyles',
+            'colors',
+            'extLst'
+        ]);
+        if (!directChildren(this.fills, 'fill').length) {
+            this.fills.append(defaultXlsxFill(styles, 'none'));
+            this.fills.append(defaultXlsxFill(styles, 'gray125'));
+            this.changed = true;
+        }
+        this.borders = ensureXlsxStyleCollection(styles, 'borders', [
+            'cellStyleXfs',
+            'cellXfs',
+            'cellStyles',
+            'dxfs',
+            'tableStyles',
+            'colors',
+            'extLst'
+        ]);
+        if (!directChildren(this.borders, 'border').length) {
+            this.borders.append(defaultXlsxBorder(styles));
+            this.changed = true;
+        }
+        this.cellXfs = ensureXlsxStyleCollection(styles, 'cellXfs', [
+            'cellStyles',
+            'dxfs',
+            'tableStyles',
+            'colors',
+            'extLst'
+        ]);
+        if (!directChildren(this.cellXfs, 'xf').length) {
+            const base = styles.createElementNS(root.namespaceURI, 'xf');
+            base.setAttribute('numFmtId', '0');
+            base.setAttribute('fontId', '0');
+            base.setAttribute('fillId', '0');
+            base.setAttribute('borderId', '0');
+            base.setAttribute('xfId', '0');
+            this.cellXfs.append(base);
+            this.changed = true;
+        }
+        this.updateCounts();
+    }
+    styleId(baseStyleId, cell, border) {
+        const styles = directChildren(this.cellXfs, 'xf');
+        const baseIndex = Number.isInteger(baseStyleId) && styles[baseStyleId] ? baseStyleId : 0;
+        const base = styles[baseIndex];
+        const fontId = this.fontId(work_xlsx_cell_style_writer_nonNegativeInteger(work_ooxml_package_attribute(base, 'fontId')) ?? 0, cell);
+        const fillId = this.fillId(work_xlsx_cell_style_writer_nonNegativeInteger(work_ooxml_package_attribute(base, 'fillId')) ?? 0, cell);
+        const borderId = this.borderId(work_xlsx_cell_style_writer_nonNegativeInteger(work_ooxml_package_attribute(base, 'borderId')) ?? 0, border);
+        const alignment = directAlignment(cell);
+        const key = `${baseIndex}:${fontId}:${fillId}:${borderId}:${JSON.stringify(alignment)}`;
+        const cached = this.generatedStyles.get(key);
+        if (void 0 !== cached) return cached;
+        const clone = base.cloneNode(true);
+        clone.setAttribute('fontId', String(fontId));
+        clone.setAttribute('fillId', String(fillId));
+        clone.setAttribute('borderId', String(borderId));
+        if (hasXlsxDirectFontStyle(cell)) clone.setAttribute('applyFont', '1');
+        if (void 0 !== cell.bg) clone.setAttribute('applyFill', '1');
+        if (border) clone.setAttribute('applyBorder', '1');
+        if (alignment) {
+            writeXlsxAlignment(this.styles, clone, alignment);
+            clone.setAttribute('applyAlignment', '1');
+        }
+        const index = styles.length;
+        this.cellXfs.append(clone);
+        this.generatedStyles.set(key, index);
+        this.changed = true;
+        this.updateCounts();
+        return index;
+    }
+    fontId(baseFontId, cell) {
+        if (!hasXlsxDirectFontStyle(cell)) return baseFontId;
+        const fonts = directChildren(this.fonts, 'font');
+        const baseIndex = fonts[baseFontId] ? baseFontId : 0;
+        const style = directFontStyle(cell);
+        const key = `${baseIndex}:${JSON.stringify(style)}`;
+        const cached = this.generatedFonts.get(key);
+        if (void 0 !== cached) return cached;
+        const font = fonts[baseIndex].cloneNode(true);
+        if (void 0 !== style.name) setXlsxValueChild(this.styles, font, 'name', style.name, fontChildOrder);
+        if (void 0 !== style.size) setXlsxValueChild(this.styles, font, 'sz', String(style.size), fontChildOrder);
+        if (void 0 !== style.color) setXlsxColorChild(this.styles, font, style.color, fontChildOrder);
+        if (void 0 !== style.bold) setXlsxToggleChild(this.styles, font, 'b', style.bold, fontChildOrder);
+        if (void 0 !== style.italic) setXlsxToggleChild(this.styles, font, 'i', style.italic, fontChildOrder);
+        if (void 0 !== style.strike) setXlsxToggleChild(this.styles, font, 'strike', style.strike, fontChildOrder);
+        if (void 0 !== style.underline) setXlsxUnderlineChild(this.styles, font, style.underline, fontChildOrder);
+        const index = fonts.length;
+        this.fonts.append(font);
+        this.generatedFonts.set(key, index);
+        this.changed = true;
+        this.updateCounts();
+        return index;
+    }
+    fillId(baseFillId, cell) {
+        if (void 0 === cell.bg) return baseFillId;
+        const color = xlsxRgbColor(cell.bg);
+        if (!color) return baseFillId;
+        const cached = this.generatedFills.get(color);
+        if (void 0 !== cached) return cached;
+        const fill = this.styles.createElementNS(this.styles.documentElement.namespaceURI, 'fill');
+        const pattern = this.styles.createElementNS(this.styles.documentElement.namespaceURI, 'patternFill');
+        pattern.setAttribute('patternType', 'solid');
+        const foreground = this.styles.createElementNS(this.styles.documentElement.namespaceURI, 'fgColor');
+        foreground.setAttribute('rgb', color);
+        const background = this.styles.createElementNS(this.styles.documentElement.namespaceURI, 'bgColor');
+        background.setAttribute('indexed', '64');
+        pattern.append(foreground, background);
+        fill.append(pattern);
+        const index = directChildren(this.fills, 'fill').length;
+        this.fills.append(fill);
+        this.generatedFills.set(color, index);
+        this.changed = true;
+        this.updateCounts();
+        return index;
+    }
+    borderId(baseBorderId, update) {
+        if (!update) return baseBorderId;
+        const borders = directChildren(this.borders, 'border');
+        const baseIndex = borders[baseBorderId] ? baseBorderId : 0;
+        const key = `${baseIndex}:${JSON.stringify(update)}`;
+        const cached = this.generatedBorders.get(key);
+        if (void 0 !== cached) return cached;
+        const border = borders[baseIndex].cloneNode(true);
+        for (const [name, line] of [
+            [
+                'left',
+                update.left
+            ],
+            [
+                'right',
+                update.right
+            ],
+            [
+                'top',
+                update.top
+            ],
+            [
+                'bottom',
+                update.bottom
+            ],
+            [
+                'diagonal',
+                update.diagonal
+            ]
+        ])if (void 0 !== line) setXlsxBorderLine(this.styles, border, name, line);
+        if (void 0 !== update.diagonalUp) border.setAttribute('diagonalUp', update.diagonalUp ? '1' : '0');
+        if (void 0 !== update.diagonalDown) border.setAttribute('diagonalDown', update.diagonalDown ? '1' : '0');
+        const index = borders.length;
+        this.borders.append(border);
+        this.generatedBorders.set(key, index);
+        this.changed = true;
+        this.updateCounts();
+        return index;
+    }
+    updateCounts() {
+        this.fonts.setAttribute('count', String(directChildren(this.fonts, 'font').length));
+        this.fills.setAttribute('count', String(directChildren(this.fills, 'fill').length));
+        this.borders.setAttribute('count', String(directChildren(this.borders, 'border').length));
+        this.cellXfs.setAttribute('count', String(directChildren(this.cellXfs, 'xf').length));
+    }
+}
+function hasXlsxDirectCellStyle(cell) {
+    return Boolean(hasXlsxDirectFontStyle(cell) || void 0 !== cell.bg || void 0 !== cell.ht || void 0 !== cell.vt || void 0 !== cell.tb || void 0 !== cell.tr);
+}
+function hasXlsxDirectFontStyle(cell) {
+    return Boolean(void 0 !== cell.bl || void 0 !== cell.it || void 0 !== cell.un || void 0 !== cell.cl || void 0 !== cell.ff || void 0 !== cell.fs || void 0 !== cell.fc);
+}
+function directFontStyle(cell) {
+    const color = void 0 !== cell.fc ? xlsxRgbColor(cell.fc) : null;
+    return {
+        ...void 0 !== cell.bl ? {
+            bold: 1 === Number(cell.bl)
+        } : {},
+        ...color ? {
+            color
+        } : {},
+        ...void 0 !== cell.it ? {
+            italic: 1 === Number(cell.it)
+        } : {},
+        ...'string' == typeof cell.ff && cell.ff.trim() ? {
+            name: cell.ff.trim()
+        } : {},
+        ...'number' == typeof cell.fs && Number.isFinite(cell.fs) && cell.fs > 0 ? {
+            size: cell.fs
+        } : {},
+        ...void 0 !== cell.cl ? {
+            strike: 1 === Number(cell.cl)
+        } : {},
+        ...void 0 !== cell.un ? {
+            underline: 1 === Number(cell.un)
+        } : {}
+    };
+}
+function directAlignment(cell) {
+    const alignment = {};
+    if (void 0 !== cell.ht) alignment.horizontal = 0 === Number(cell.ht) ? 'center' : 2 === Number(cell.ht) ? 'right' : 'left';
+    if (void 0 !== cell.vt) alignment.vertical = 0 === Number(cell.vt) ? 'center' : 1 === Number(cell.vt) ? 'top' : 'bottom';
+    if (void 0 !== cell.tb) alignment.wrapText = '2' === cell.tb;
+    if (void 0 !== cell.tr) {
+        const rotation = Number(cell.tr);
+        if (Number.isFinite(rotation) && rotation >= 0 && rotation <= 180) alignment.textRotation = Math.round(rotation);
+    }
+    return Object.keys(alignment).length ? alignment : null;
+}
+function work_xlsx_cell_style_writer_nonNegativeInteger(value) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
+const defaultThemeColors = [
+    'ffffff',
+    '000000',
+    'e7e6e6',
+    '44546a',
+    '4472c4',
+    'ed7d31',
+    'a5a5a5',
+    'ffc000',
+    '5b9bd5',
+    '70ad47',
+    '0563c1',
+    '954f72'
+];
+const themeColorNames = [
+    'lt1',
+    'dk1',
+    'lt2',
+    'dk2',
+    'accent1',
+    'accent2',
+    'accent3',
+    'accent4',
+    'accent5',
+    'accent6',
+    'hlink',
+    'folHlink'
+];
+const defaultIndexedColors = [
+    '000000',
+    'ffffff',
+    'ff0000',
+    '00ff00',
+    '0000ff',
+    'ffff00',
+    'ff00ff',
+    '00ffff',
+    '000000',
+    'ffffff',
+    'ff0000',
+    '00ff00',
+    '0000ff',
+    'ffff00',
+    'ff00ff',
+    '00ffff',
+    '800000',
+    '008000',
+    '000080',
+    '808000',
+    '800080',
+    '008080',
+    'c0c0c0',
+    '808080',
+    '9999ff',
+    '993366',
+    'ffffcc',
+    'ccffff',
+    '660066',
+    'ff8080',
+    '0066cc',
+    'ccccff',
+    '000080',
+    'ff00ff',
+    'ffff00',
+    '00ffff',
+    '800080',
+    '800000',
+    '008080',
+    '0000ff',
+    '00ccff',
+    'ccffff',
+    'ccffcc',
+    'ffff99',
+    '99ccff',
+    'ff99cc',
+    'cc99ff',
+    'ffcc99',
+    '3366ff',
+    '33cccc',
+    '99cc00',
+    'ffcc00',
+    'ff9900',
+    'ff6600',
+    '666699',
+    '969696',
+    '003366',
+    '339966',
+    '003300',
+    '333300',
+    '993300',
+    '993366',
+    '333399',
+    '333333'
+];
+function createXlsxColorResolver(styles, theme) {
+    return {
+        indexed: readIndexedColors(styles),
+        theme: readThemeColors(theme)
+    };
+}
+function resolveXlsxColor(element, resolver) {
+    if (!element) return;
+    const direct = normalizedHexColor(work_ooxml_package_attribute(element, 'rgb'));
+    const themeIndex = boundedInteger(work_ooxml_package_attribute(element, 'theme'), 11);
+    const indexed = boundedInteger(work_ooxml_package_attribute(element, 'indexed'), 65535);
+    const automatic = work_xlsx_colors_booleanAttribute(element, 'auto');
+    const source = direct ?? (null === themeIndex ? void 0 : resolver.theme[themeIndex]) ?? (null === indexed ? void 0 : resolver.indexed[indexed]) ?? (automatic ? '000000' : void 0);
+    if (!source) return;
+    const tint = Number(work_ooxml_package_attribute(element, 'tint'));
+    return `#${Number.isFinite(tint) && tint >= -1 && tint <= 1 ? tintXlsxColor(source, tint) : source}`;
+}
+function readThemeColors(theme) {
+    if (!theme) return defaultThemeColors;
+    const scheme = firstDescendant(theme, 'clrScheme');
+    if (!scheme) return defaultThemeColors;
+    return themeColorNames.map((name, index)=>{
+        const entry = directChild(scheme, name);
+        const color = entry ? drawingColor(directChildren(entry)[0]) : void 0;
+        return color ?? defaultThemeColors[index];
+    });
+}
+function readIndexedColors(styles) {
+    const indexed = firstDescendant(styles, 'indexedColors');
+    if (!indexed) return defaultIndexedColors;
+    const colors = directChildren(indexed, 'rgbColor').map((element)=>normalizedHexColor(work_ooxml_package_attribute(element, 'rgb')));
+    return colors.every(Boolean) ? colors : defaultIndexedColors;
+}
+function drawingColor(element) {
+    if (!element) return;
+    return normalizedHexColor('sysClr' === element.localName ? work_ooxml_package_attribute(element, 'lastClr') : work_ooxml_package_attribute(element, 'val'));
+}
+function tintXlsxColor(color, tint) {
+    const [hue, saturation, lightness] = rgbToHsl([
+        0,
+        2,
+        4
+    ].map((offset)=>Number.parseInt(color.slice(offset, offset + 2), 16) / 255));
+    const tintedLightness = tint < 0 ? lightness * (1 + tint) : 1 - (1 - lightness) * (1 - tint);
+    return hslToRgb(hue, saturation, tintedLightness).map((channel)=>Math.round(255 * channel)).map((channel)=>channel.toString(16).padStart(2, '0')).join('');
+}
+function rgbToHsl([red, green, blue]) {
+    const maximum = Math.max(red, green, blue);
+    const minimum = Math.min(red, green, blue);
+    const delta = maximum - minimum;
+    const lightness = (maximum + minimum) / 2;
+    if (0 === delta) return [
+        0,
+        0,
+        lightness
+    ];
+    const saturation = delta / (1 - Math.abs(2 * lightness - 1));
+    const hue = maximum === red ? ((green - blue) / delta + (green < blue ? 6 : 0)) / 6 : maximum === green ? ((blue - red) / delta + 2) / 6 : ((red - green) / delta + 4) / 6;
+    return [
+        hue,
+        saturation,
+        lightness
+    ];
+}
+function hslToRgb(hue, saturation, lightness) {
+    if (0 === saturation) return [
+        lightness,
+        lightness,
+        lightness
+    ];
+    const chroma = 2 * saturation * (lightness < 0.5 ? lightness : 1 - lightness);
+    const minimum = lightness - chroma / 2;
+    const channels = [
+        minimum,
+        minimum,
+        minimum
+    ];
+    const sector = 6 * hue;
+    switch(Math.floor(sector)){
+        case 0:
+        case 6:
+            channels[0] += chroma;
+            channels[1] += chroma * sector;
+            break;
+        case 1:
+            channels[0] += chroma * (2 - sector);
+            channels[1] += chroma;
+            break;
+        case 2:
+            channels[1] += chroma;
+            channels[2] += chroma * (sector - 2);
+            break;
+        case 3:
+            channels[1] += chroma * (4 - sector);
+            channels[2] += chroma;
+            break;
+        case 4:
+            channels[0] += chroma * (sector - 4);
+            channels[2] += chroma;
+            break;
+        case 5:
+            channels[0] += chroma;
+            channels[2] += chroma * (6 - sector);
+            break;
+    }
+    return channels;
+}
+function normalizedHexColor(value) {
+    if (!value || !/^[0-9a-f]{6,8}$/i.test(value)) return;
+    return value.slice(-6).toLowerCase();
+}
+function boundedInteger(value, maximum) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed <= maximum ? parsed : null;
+}
+function work_xlsx_colors_booleanAttribute(element, name) {
+    const value = work_ooxml_package_attribute(element, name)?.trim().toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
+}
+const xlsxCellBorderStyles = new Set([
+    'dashDot',
+    'dashDotDot',
+    'dashed',
+    'dotted',
+    'double',
+    'hair',
+    'medium',
+    'mediumDashDot',
+    'mediumDashDotDot',
+    'mediumDashed',
+    'slantDashDot',
+    'thick',
+    'thin'
+]);
+function readXlsxDirectCellStyles(worksheet, styles, theme = null) {
+    if (!styles) return [];
+    const colors = createXlsxColorResolver(styles, theme);
+    const fonts = directChildren(directChild(styles.documentElement, 'fonts') ?? styles, 'font');
+    const fills = directChildren(directChild(styles.documentElement, 'fills') ?? styles, 'fill');
+    const borders = directChildren(directChild(styles.documentElement, 'borders') ?? styles, 'border');
+    const cellXfs = directChildren(directChild(styles.documentElement, 'cellXfs') ?? styles, 'xf');
+    if (!cellXfs.length) return [];
+    return descendants(worksheet, 'c').flatMap((cell)=>{
+        const coordinate = decodeCell(work_ooxml_package_attribute(cell, 'r'));
+        const styleId = work_xlsx_cell_styles_nonNegativeInteger(work_ooxml_package_attribute(cell, 's'));
+        const xf = null === styleId ? void 0 : cellXfs[styleId];
+        if (!coordinate || !xf) return [];
+        const style = readDirectCellStyle(xf, fonts, fills, colors);
+        const border = readDirectCellBorder(xf, borders, colors);
+        return Object.keys(style).length || border ? [
+            {
+                ...coordinate,
+                border,
+                style
+            }
+        ] : [];
+    });
+}
+function sheetHasDirectCellStyles(sheet) {
+    if (Array.isArray(sheet.config?.borderInfo) && sheet.config.borderInfo.length) return true;
+    for (const [, row] of sparseArrayEntries(sheet.data))for (const [, cell] of sparseArrayEntries(row))if (cell && hasXlsxDirectCellStyle(cell)) return true;
+    return false;
+}
+function writeXlsxDirectCellStyles(worksheet, sheet, styles) {
+    const borders = collectXlsxCellBorders(sheet);
+    const cells = new Map(descendants(worksheet, 'c').flatMap((element)=>{
+        const reference = work_ooxml_package_attribute(element, 'r');
+        return reference ? [
+            [
+                reference,
+                element
+            ]
+        ] : [];
+    }));
+    for (const [row, values] of sparseArrayEntries(sheet.data))for (const [column, cell] of sparseArrayEntries(values)){
+        const border = borders.get(xlsxCellBorderKey(row, column));
+        if (!cell || !hasXlsxDirectCellStyle(cell) && !border) continue;
+        const element = cells.get(encodeCell(row, column));
+        if (!element) continue;
+        const baseStyleId = work_xlsx_cell_styles_nonNegativeInteger(work_ooxml_package_attribute(element, 's')) ?? 0;
+        const styleId = styles.styleId(baseStyleId, cell, border);
+        if (styleId) element.setAttribute('s', String(styleId));
+        else element.removeAttribute('s');
+    }
+}
+function readDirectCellStyle(xf, fonts, fills, colors) {
+    const style = {};
+    const fontId = work_xlsx_cell_styles_nonNegativeInteger(work_ooxml_package_attribute(xf, 'fontId')) ?? 0;
+    const font = fonts[fontId];
+    if (font && (0 !== fontId || work_xlsx_cell_styles_booleanAttribute(xf, 'applyFont'))) readDirectFontStyle(style, font, colors);
+    const fillId = work_xlsx_cell_styles_nonNegativeInteger(work_ooxml_package_attribute(xf, 'fillId')) ?? 0;
+    const fill = fills[fillId];
+    if (fill && (0 !== fillId || work_xlsx_cell_styles_booleanAttribute(xf, 'applyFill'))) readDirectFillStyle(style, fill, colors);
+    const alignment = directChild(xf, 'alignment');
+    if (alignment) readDirectAlignmentStyle(style, alignment);
+    return style;
+}
+function readDirectFontStyle(style, font, colors) {
+    const bold = directChild(font, 'b');
+    if (bold && toggleEnabled(bold)) style.bl = 1;
+    const italic = directChild(font, 'i');
+    if (italic && toggleEnabled(italic)) style.it = 1;
+    const strike = directChild(font, 'strike');
+    if (strike && toggleEnabled(strike)) style.cl = 1;
+    const underline = directChild(font, 'u');
+    if (underline && underlineEnabled(underline)) style.un = 1;
+    const name = work_ooxml_package_attribute(directChild(font, 'name') ?? font, 'val')?.trim();
+    if (name) style.ff = name;
+    const size = Number(work_ooxml_package_attribute(directChild(font, 'sz') ?? font, 'val'));
+    if (Number.isFinite(size) && size > 0) style.fs = size;
+    const color = resolveXlsxColor(directChild(font, 'color'), colors);
+    if (color) style.fc = color;
+}
+function readDirectFillStyle(style, fill, colors) {
+    const pattern = directChild(fill, 'patternFill');
+    if (!pattern || 'solid' !== work_ooxml_package_attribute(pattern, 'patternType')) return;
+    const color = resolveXlsxColor(directChild(pattern, 'fgColor'), colors);
+    if (color) style.bg = color;
+}
+function readDirectAlignmentStyle(style, alignment) {
+    const horizontal = work_ooxml_package_attribute(alignment, 'horizontal');
+    if ('center' === horizontal) style.ht = 0;
+    else if ('left' === horizontal) style.ht = 1;
+    else if ('right' === horizontal) style.ht = 2;
+    const vertical = work_ooxml_package_attribute(alignment, 'vertical');
+    if ('center' === vertical) style.vt = 0;
+    else if ('top' === vertical) style.vt = 1;
+    else if ('bottom' === vertical) style.vt = 2;
+    if (work_xlsx_cell_styles_booleanAttribute(alignment, 'wrapText')) style.tb = '2';
+    const rotation = work_xlsx_cell_styles_nonNegativeInteger(work_ooxml_package_attribute(alignment, 'textRotation'));
+    if (null !== rotation && rotation <= 180) style.tr = String(rotation);
+}
+function readDirectCellBorder(xf, borders, colors) {
+    const borderId = work_xlsx_cell_styles_nonNegativeInteger(work_ooxml_package_attribute(xf, 'borderId')) ?? 0;
+    const source = borders[borderId];
+    if (!source || 0 === borderId && !work_xlsx_cell_styles_booleanAttribute(xf, 'applyBorder')) return;
+    const border = {};
+    readBorderLine(border, 'left', directChild(source, 'left'), colors);
+    readBorderLine(border, 'right', directChild(source, 'right'), colors);
+    readBorderLine(border, 'top', directChild(source, 'top'), colors);
+    readBorderLine(border, 'bottom', directChild(source, 'bottom'), colors);
+    readBorderLine(border, 'diagonal', directChild(source, 'diagonal'), colors);
+    if (border.diagonal) {
+        border.diagonalUp = work_xlsx_cell_styles_booleanAttribute(source, 'diagonalUp');
+        border.diagonalDown = work_xlsx_cell_styles_booleanAttribute(source, 'diagonalDown');
+    }
+    return Object.keys(border).length ? border : void 0;
+}
+function readBorderLine(border, name, element, colors) {
+    if (!element) return;
+    const style = work_ooxml_package_attribute(element, 'style');
+    if (!style || !xlsxCellBorderStyles.has(style)) return;
+    border[name] = {
+        color: resolveXlsxColor(directChild(element, 'color'), colors) ?? '#000000',
+        style: style
+    };
+}
+function toggleEnabled(element) {
+    const value = work_ooxml_package_attribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function underlineEnabled(element) {
+    const value = work_ooxml_package_attribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'none' !== value;
+}
+function work_xlsx_cell_styles_booleanAttribute(element, name) {
+    const value = work_ooxml_package_attribute(element, name)?.trim().toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
+}
+function encodeCell(row, column) {
+    let value = column + 1;
+    let label = '';
+    while(value > 0){
+        value -= 1;
+        label = String.fromCharCode(65 + value % 26) + label;
+        value = Math.floor(value / 26);
+    }
+    return `${label}${row + 1}`;
+}
+function decodeCell(reference) {
+    const match = /^([A-Z]{1,3})([1-9]\d{0,6})$/i.exec(reference ?? '');
+    if (!match) return null;
+    let column = 0;
+    for (const character of match[1].toUpperCase())column = 26 * column + character.charCodeAt(0) - 64;
+    const row = Number(match[2]);
+    return column <= 16384 && row <= 1048576 ? {
+        column: column - 1,
+        row: row - 1
+    } : null;
+}
+function work_xlsx_cell_styles_nonNegativeInteger(value) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
 function readXlsxDifferentialFormats(styles) {
     const container = styles ? firstDescendant(styles, 'dxfs') : null;
     if (!container) return [];
@@ -3492,7 +4492,7 @@ function writeRule(document1, rule, priority, differentialFormats) {
     if ('textContains' === rule.conditionName && values[0]) {
         element.setAttribute('type', 'containsText');
         element.setAttribute('text', values[0]);
-        const firstCell = encodeCell(rule.cellrange[0].row[0], rule.cellrange[0].column[0]);
+        const firstCell = work_xlsx_conditional_format_write_encodeCell(rule.cellrange[0].row[0], rule.cellrange[0].column[0]);
         appendFormula(document1, element, `NOT(ISERROR(SEARCH("${values[0].replaceAll('"', '""')}",${firstCell})))`);
         return finish();
     }
@@ -3609,11 +4609,11 @@ function validIndex(value) {
     return 'number' == typeof value && Number.isInteger(value) && value >= 0;
 }
 function encodeRange(range) {
-    const start = encodeCell(range.row[0], range.column[0]);
-    const end = encodeCell(range.row[1], range.column[1]);
+    const start = work_xlsx_conditional_format_write_encodeCell(range.row[0], range.column[0]);
+    const end = work_xlsx_conditional_format_write_encodeCell(range.row[1], range.column[1]);
     return start === end ? start : `${start}:${end}`;
 }
-function encodeCell(row, column) {
+function work_xlsx_conditional_format_write_encodeCell(row, column) {
     let value = column + 1;
     let label = '';
     while(value > 0){
@@ -4405,7 +5405,7 @@ function writeCellProtectionStyles(worksheet, sheet, styles) {
         const compact = compactProtectionAt(authority, row, column);
         if (void 0 === cell.lo && void 0 === cell.hi && void 0 === compact) continue;
         const element = ensureCellElement(worksheet, row, column);
-        const baseStyle = nonNegativeInteger(work_ooxml_package_attribute(element, 's')) ?? 0;
+        const baseStyle = work_xlsx_protection_nonNegativeInteger(work_ooxml_package_attribute(element, 's')) ?? 0;
         const styleId = styles.styleId(baseStyle, void 0 === cell.lo ? compact?.locked ?? true : 0 !== cell.lo, void 0 === cell.hi ? compact?.hidden ?? false : 1 === cell.hi);
         if (styleId) element.setAttribute('s', String(styleId));
         else element.removeAttribute('s');
@@ -4572,7 +5572,7 @@ function work_xlsx_protection_parseSqref(value) {
     return value ? parseSpreadsheetCellRanges(value.trim().replace(/\s+/g, ',')) ?? [] : [];
 }
 function indexedStyle(styles, value) {
-    const index = nonNegativeInteger(value);
+    const index = work_xlsx_protection_nonNegativeInteger(value);
     return null === index ? null : styles[index] ?? null;
 }
 function parseCellReference(value) {
@@ -4613,18 +5613,18 @@ function work_xlsx_protection_booleanAttribute(element, name, fallback) {
     if ('0' === value || 'false' === value || 'off' === value) return false;
     return fallback;
 }
-function nonNegativeInteger(value) {
+function work_xlsx_protection_nonNegativeInteger(value) {
     if (null === value || !/^\d+$/.test(value)) return null;
     return Number(value);
 }
 function work_xlsx_protection_positiveInteger(value) {
-    const parsed = nonNegativeInteger(value);
+    const parsed = work_xlsx_protection_nonNegativeInteger(value);
     return null !== parsed && parsed > 0 ? parsed : null;
 }
 function sameProtection(left, right) {
     return left.locked === right.locked && left.hidden === right.hidden;
 }
-const XLSX_IMPORTED_WORKSHEET_ELEMENTS = [
+const IMPORTED_WORKSHEET_ELEMENTS = new Set([
     'pane',
     'dataValidation',
     'conditionalFormatting',
@@ -4638,10 +5638,51 @@ const XLSX_IMPORTED_WORKSHEET_ELEMENTS = [
     'headerFooter',
     'pageSetUpPr',
     'drawing'
-];
+]);
+const DIAGNOSTIC_WORKSHEET_ELEMENTS = new Set([
+    'conditionalFormatting',
+    'dataValidation',
+    'sheetProtection',
+    'protectedRange',
+    'pageSetup',
+    'pageMargins',
+    'printOptions',
+    'headerFooter',
+    'pageSetUpPr',
+    'rowBreaks',
+    'colBreaks'
+]);
+const WORKSHEET_SCAN_PATTERN = /<(?:[A-Za-z_][\w.-]*:)?(?:(cols|f|pane|dataValidation|conditionalFormatting|sheetProtection|protectedRange|rowBreaks|colBreaks|pageSetup|pageMargins|printOptions|headerFooter|pageSetUpPr|drawing)(?=[\s/>])|(row)(?=[\s/>])[^>]*\s(?:collapsed|customFormat|customHeight|hidden|ht|outlineLevel|thickBot|thickTop)\s*=|(c)(?=[\s/>])[^>]*\ss\s*=)/g;
+function scanXlsxWorksheetXml(source) {
+    let hasDirectCellStyles = false;
+    let hasDiagnosticFeatures = false;
+    let hasFormulaFeatures = false;
+    let hasImportedFeatures = false;
+    let requiresSheetJsCellStyles = false;
+    WORKSHEET_SCAN_PATTERN.lastIndex = 0;
+    for(let match = WORKSHEET_SCAN_PATTERN.exec(source); match;){
+        const element = match[1];
+        if (match[3]) hasDirectCellStyles = true;
+        if (match[2] || match[3] || 'cols' === element) requiresSheetJsCellStyles = true;
+        if ('f' === element) hasFormulaFeatures = true;
+        if (element && IMPORTED_WORKSHEET_ELEMENTS.has(element)) hasImportedFeatures = true;
+        if (element && DIAGNOSTIC_WORKSHEET_ELEMENTS.has(element)) hasDiagnosticFeatures = true;
+        if (hasDirectCellStyles && hasDiagnosticFeatures && hasFormulaFeatures && hasImportedFeatures && requiresSheetJsCellStyles) break;
+        match = WORKSHEET_SCAN_PATTERN.exec(source);
+    }
+    WORKSHEET_SCAN_PATTERN.lastIndex = 0;
+    return {
+        hasDirectCellStyles,
+        hasDiagnosticFeatures,
+        hasFormulaFeatures,
+        hasImportedFeatures,
+        requiresSheetJsCellStyles
+    };
+}
 async function readXlsxSheetFeaturesFromPackage(archive, worksheetScans) {
     const worksheetParts = await work_xlsx_interop_readWorksheetParts(archive);
     const styles = archive.has('xl/styles.xml') ? await archive.xml('xl/styles.xml') : null;
+    const theme = archive.has('xl/theme/theme1.xml') ? await archive.xml('xl/theme/theme1.xml') : null;
     const differentialFormats = readXlsxDifferentialFormats(styles);
     const features = new Map();
     const imageBudget = {
@@ -4650,17 +5691,19 @@ async function readXlsxSheetFeaturesFromPackage(archive, worksheetScans) {
     for (const [sheetName, partPath] of worksheetParts){
         if (!archive.has(partPath)) continue;
         const scan = worksheetScans?.[partPath];
-        if (scan && !scan.hasImportedFeatures) {
+        if (scan && !scan.hasImportedFeatures && !scan.hasDirectCellStyles) {
             features.set(sheetName, emptyXlsxSheetFeatures());
             continue;
         }
         const source = await archive.text(partPath);
-        if (!scan && !xmlContainsAnyElement(source, XLSX_IMPORTED_WORKSHEET_ELEMENTS)) {
+        const detected = scan ?? scanXlsxWorksheetXml(source);
+        if (!detected.hasImportedFeatures && !detected.hasDirectCellStyles) {
             features.set(sheetName, emptyXlsxSheetFeatures());
             continue;
         }
         const document1 = parseXml(source, partPath);
         features.set(sheetName, {
+            directCellStyles: readXlsxDirectCellStyles(document1, styles, theme),
             frozen: parseFrozenPane(document1) ?? void 0,
             validations: parseDataValidations(document1),
             conditionalFormats: readXlsxConditionalFormats(document1, differentialFormats),
@@ -4675,6 +5718,7 @@ async function readXlsxSheetFeaturesFromPackage(archive, worksheetScans) {
 }
 function emptyXlsxSheetFeatures() {
     return {
+        directCellStyles: [],
         validations: [],
         conditionalFormats: [],
         protection: {
@@ -4698,17 +5742,18 @@ async function patchXlsxSheetFeatures(buffer, content) {
             pageSetup.sheetId,
             pageSetup
         ]));
-    if (!sheets.some((sheet)=>sheet.frozen || Object.keys(sheet.dataVerification ?? {}).length || sheet.dataValidationRanges?.length || sheet.luckysheet_conditionformat_save?.length || sheetHasProtectionState(sheet) || Boolean(sheet.id && (pageBreaksBySheetId.get(sheet.id)?.rows?.length ?? 0) + (pageBreaksBySheetId.get(sheet.id)?.columns?.length ?? 0)) || Boolean(sheet.id && pageSetupsBySheetId.has(sheet.id)))) return buffer;
+    if (!sheets.some((sheet)=>sheet.frozen || Object.keys(sheet.dataVerification ?? {}).length || sheet.dataValidationRanges?.length || sheet.luckysheet_conditionformat_save?.length || sheetHasDirectCellStyles(sheet) || sheetHasProtectionState(sheet) || Boolean(sheet.id && (pageBreaksBySheetId.get(sheet.id)?.rows?.length ?? 0) + (pageBreaksBySheetId.get(sheet.id)?.columns?.length ?? 0)) || Boolean(sheet.id && pageSetupsBySheetId.has(sheet.id)))) return buffer;
     const archive = await work_ooxml_package_OoxmlPackage.load(buffer);
     const worksheetParts = await work_xlsx_interop_readWorksheetParts(archive);
     const zip = await jszip.loadAsync(buffer);
     const styles = archive.has('xl/styles.xml') ? await archive.xml('xl/styles.xml') : null;
     const differentialFormats = styles ? new XlsxDifferentialFormatWriter(styles) : void 0;
+    const directCellStyles = styles ? new XlsxDirectCellStyleWriter(styles) : void 0;
     const cellProtection = styles ? new XlsxCellProtectionWriter(styles) : void 0;
     for (const sheet of sheets){
         const pageBreaks = sheet.id ? pageBreaksBySheetId.get(sheet.id) : void 0;
         const pageSetup = sheet.id ? pageSetupsBySheetId.get(sheet.id) : void 0;
-        if (!sheet.frozen && !Object.keys(sheet.dataVerification ?? {}).length && !sheet.dataValidationRanges?.length && !sheet.luckysheet_conditionformat_save?.length && !sheetHasProtectionState(sheet) && !(pageBreaks?.rows?.length || pageBreaks?.columns?.length) && !pageSetup) continue;
+        if (!sheet.frozen && !Object.keys(sheet.dataVerification ?? {}).length && !sheet.dataValidationRanges?.length && !sheet.luckysheet_conditionformat_save?.length && !sheetHasDirectCellStyles(sheet) && !sheetHasProtectionState(sheet) && !(pageBreaks?.rows?.length || pageBreaks?.columns?.length) && !pageSetup) continue;
         const exportedName = sheet.name.slice(0, 31) || '工作表';
         const partPath = worksheetParts.get(exportedName);
         const entry = partPath ? zip.file(partPath) : null;
@@ -4717,12 +5762,13 @@ async function patchXlsxSheetFeatures(buffer, content) {
         if (sheet.frozen) writeFrozenPane(document1, sheet.frozen);
         writeDataValidations(document1, sheet.dataVerification, sheet.dataValidationRanges);
         writeXlsxConditionalFormats(document1, sheet.luckysheet_conditionformat_save, differentialFormats);
+        if (directCellStyles) writeXlsxDirectCellStyles(document1, sheet, directCellStyles);
         writeXlsxProtection(document1, sheet, cellProtection);
         writeXlsxPageSetup(document1, pageSetup);
         writeXlsxManualPageBreaks(document1, pageBreaks);
         zip.file(partPath, new XMLSerializer().serializeToString(document1));
     }
-    if (differentialFormats?.changed || cellProtection?.changed) zip.file('xl/styles.xml', differentialFormats?.serialize() ?? cellProtection?.serialize() ?? '');
+    if (styles && (differentialFormats?.changed || directCellStyles?.changed || cellProtection?.changed)) zip.file('xl/styles.xml', new XMLSerializer().serializeToString(styles));
     return zip.generateAsync({
         type: 'arraybuffer',
         compression: 'DEFLATE'
@@ -6004,6 +7050,7 @@ function xlsxCellStyle(cell) {
         font: {
             bold: Boolean(cell.bl),
             italic: Boolean(cell.it),
+            strike: Boolean(cell.cl),
             underline: Boolean(cell.un),
             name: cell.ff,
             sz: cell.fs,
@@ -6585,6 +7632,10 @@ async function importWorkSpreadsheetFile(file, extension, context) {
         if (!worksheet) continue;
         const plainWorksheet = packageScanResult?.plainWorksheets?.[name];
         const features = sheetFeatures.get(name);
+        const directCellStyles = new Map((features?.directCellStyles ?? []).map((entry)=>[
+                spreadsheetCellKey(entry.row, entry.column),
+                entry
+            ]));
         const range = safeSpreadsheetRange(worksheet, XLSX);
         let rowCount = Math.max(plainWorksheet?.rowCount ?? range.e.r + 1, 40);
         let columnCount = Math.max(plainWorksheet?.columnCount ?? range.e.c + 1, 12);
@@ -6611,8 +7662,10 @@ async function importWorkSpreadsheetFile(file, extension, context) {
                 const comment = importXlsxCellComment(source.c);
                 updateSpreadsheetWorksheetCompatibilitySummary(compatibilitySummary, source);
                 if (hyperlink) hyperlinks[`${row}_${column}`] = hyperlink;
+                const directCellStyle = directCellStyles.get(spreadsheetCellKey(row, column));
+                directCellStyles.delete(spreadsheetCellKey(row, column));
                 data[row] ??= [];
-                data[row][column] = freezeImportedSpreadsheetCell(fortuneCellFromXlsx(source, row, column, id, hyperlink, comment, XLSX));
+                data[row][column] = freezeImportedSpreadsheetCell(fortuneCellFromXlsx(source, row, column, id, hyperlink, comment, XLSX, directCellStyle?.style));
                 if (source.f) formulaCells.push({
                     column,
                     row
@@ -6625,10 +7678,26 @@ async function importWorkSpreadsheetFile(file, extension, context) {
             }
             releaseImportedWorksheetCells(worksheet);
         }
+        for (const { column, row, style } of directCellStyles.values()){
+            rowCount = Math.max(rowCount, row + 1);
+            columnCount = Math.max(columnCount, column + 1);
+            data[row] ??= [];
+            const existing = data[row][column];
+            data[row][column] = freezeImportedSpreadsheetCell({
+                ...existing ?? {},
+                ...style
+            });
+            if (!existing) entryIndex += 1;
+        }
         populatedCellCount += entryIndex;
         worksheetCompatibility.set(name, compatibilitySummary);
         data.length = Math.max(data.length, rowCount);
         const config = fortuneSheetConfig(worksheet);
+        const importedBorderInfo = fortuneBorderInfoFromXlsxCells(features?.directCellStyles ?? []);
+        if (importedBorderInfo.length) config.borderInfo = [
+            ...Array.isArray(config.borderInfo) ? config.borderInfo : [],
+            ...importedBorderInfo
+        ];
         registerImportedSpreadsheetMatrix(data, {
             columnCount,
             formulaCells,
@@ -6807,8 +7876,11 @@ function fortuneSheetConfig(worksheet) {
     }
     return config;
 }
-function fortuneCellFromXlsx(source, row, column, sheetId, hyperlink, comment, XLSX) {
-    const cell = fortuneCellStyle(source);
+function fortuneCellFromXlsx(source, row, column, sheetId, hyperlink, comment, XLSX, directStyle) {
+    const cell = {
+        ...fortuneCellStyle(source),
+        ...directStyle
+    };
     if (void 0 !== source.v) cell.v = source.v;
     const displayText = fortuneCellDisplayText(source, XLSX);
     if (void 0 !== displayText) cell.m = displayText;
@@ -6825,6 +7897,9 @@ function fortuneCellFromXlsx(source, row, column, sheetId, hyperlink, comment, X
     }
     return cell;
 }
+function spreadsheetCellKey(row, column) {
+    return `${row}_${column}`;
+}
 function fortuneCellStyle(source) {
     const style = source.s;
     const font = style && 'object' == typeof style ? style.font : void 0;
@@ -6833,6 +7908,7 @@ function fortuneCellStyle(source) {
     const target = {};
     if (font?.bold) target.bl = 1;
     if (font?.italic) target.it = 1;
+    if (font?.strike) target.cl = 1;
     if (font?.underline) target.un = 1;
     if (font?.name) target.ff = font.name;
     if (font?.sz !== void 0) target.fs = font.sz;