@a3s-lab/office 0.24.0 → 0.25.0

package/dist/{5045.js → 164.js}

@@ -1,6 +1,6 @@
 import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
 import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
-import { OFFICE_KERNEL_SPREADSHEET_MAX_ROWS } from "./5184.js";
+import { directChild, directChildren, descendants, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, attribute, firstDescendant } from "./5184.js";
 import { sparseMatrixColumnCount, cloneSparseMatrix, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, formatSpreadsheetCellRanges, isValidSpreadsheetDefinedName, parseSpreadsheetCellRanges as work_spreadsheet_ranges_parseSpreadsheetCellRanges, sparseArrayIndexes } from "./8715.js";
 import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
 import * as __rspack_external_yjs from "yjs";
@@ -1620,6 +1620,54 @@ function assertInitializedSpreadsheetSession(session) {
     if (metadata?.initialized) return;
     throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The Spreadsheet collaboration session has not been initialized.');
 }
+function* xlsxWorksheetCellEntries(worksheet) {
+    if (Array.isArray(worksheet)) {
+        for(let row = 0; row < worksheet.length; row += 1){
+            const cells = worksheet[row];
+            if (Array.isArray(cells)) for(let column = 0; column < cells.length; column += 1){
+                const cell = cells[column];
+                if (!(!cell || 'object' != typeof cell || Array.isArray(cell))) yield {
+                    address: xlsxCellAddress(row, column),
+                    cell: cell,
+                    column,
+                    row
+                };
+            }
+        }
+        return;
+    }
+    for (const [address, cell] of Object.entries(worksheet)){
+        if (address.startsWith('!') || !cell || 'object' != typeof cell) continue;
+        const position = decodeXlsxCellAddress(address);
+        if (position) yield {
+            address,
+            cell: cell,
+            ...position
+        };
+    }
+}
+function xlsxCellAddress(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 decodeXlsxCellAddress(address) {
+    const match = /^([A-Za-z]+)([1-9][0-9]*)$/.exec(address);
+    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]);
+    if (!Number.isSafeInteger(row) || row <= 0) return null;
+    return {
+        column: column - 1,
+        row: row - 1
+    };
+}
 const spreadsheetFormulaHistoryIgnoredKeys = new Set([
     'ct',
     'm',
@@ -2145,6 +2193,602 @@ function spreadsheetDiagonalBorderLine(value) {
 function isRecord(value) {
     return Boolean(value && 'object' == typeof value && !Array.isArray(value));
 }
+const borderChildOrder = [
+    'start',
+    'end',
+    'left',
+    'right',
+    'top',
+    'bottom',
+    'diagonal',
+    'vertical',
+    'horizontal',
+    'extLst'
+];
+function ensureXlsxStyleCollection(document, name, anchors) {
+    const root = document.documentElement;
+    const existing = directChild(root, name);
+    if (existing) return existing;
+    const collection = document.createElementNS(root.namespaceURI, name);
+    root.insertBefore(collection, directChildren(root).find((child)=>anchors.includes(child.localName)) ?? null);
+    return collection;
+}
+function defaultXlsxFill(document, patternType) {
+    const fill = document.createElementNS(document.documentElement.namespaceURI, 'fill');
+    const pattern = document.createElementNS(document.documentElement.namespaceURI, 'patternFill');
+    pattern.setAttribute('patternType', patternType);
+    fill.append(pattern);
+    return fill;
+}
+function defaultXlsxBorder(document) {
+    const border = document.createElementNS(document.documentElement.namespaceURI, 'border');
+    for (const name of [
+        'left',
+        'right',
+        'top',
+        'bottom',
+        'diagonal'
+    ])border.append(document.createElementNS(document.documentElement.namespaceURI, name));
+    return border;
+}
+function setXlsxBorderLine(document, border, name, line) {
+    removeXlsxChildren(border, name);
+    const element = document.createElementNS(document.documentElement.namespaceURI, name);
+    if (line) {
+        element.setAttribute('style', line.style);
+        const color = xlsxRgbColor(line.color);
+        if (color) {
+            const child = document.createElementNS(document.documentElement.namespaceURI, 'color');
+            child.setAttribute('rgb', color);
+            element.append(child);
+        }
+    }
+    insertXlsxOrderedChild(border, element, borderChildOrder);
+}
+function writeXlsxAlignment(document, xf, style) {
+    let alignment = directChild(xf, 'alignment');
+    if (!alignment) {
+        alignment = document.createElementNS(document.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 && Number.isInteger(style.textRotation) && (style.textRotation >= 0 && style.textRotation <= 180 || 255 === style.textRotation)) alignment.setAttribute('textRotation', String(style.textRotation));
+}
+function setXlsxValueChild(document, parent, name, value, order) {
+    removeXlsxChildren(parent, name);
+    const child = document.createElementNS(document.documentElement.namespaceURI, name);
+    child.setAttribute('val', value);
+    insertXlsxOrderedChild(parent, child, order);
+}
+function setXlsxColorChild(document, parent, color, order) {
+    removeXlsxChildren(parent, 'color');
+    const child = document.createElementNS(document.documentElement.namespaceURI, 'color');
+    child.setAttribute('rgb', color);
+    insertXlsxOrderedChild(parent, child, order);
+}
+function setXlsxToggleChild(document, parent, name, enabled, order) {
+    removeXlsxChildren(parent, name);
+    if (!enabled) return;
+    const child = document.createElementNS(document.documentElement.namespaceURI, name);
+    child.setAttribute('val', '1');
+    insertXlsxOrderedChild(parent, child, order);
+}
+function setXlsxUnderlineChild(document, parent, style, order) {
+    removeXlsxChildren(parent, 'u');
+    if ('none' === style) return;
+    const child = document.createElementNS(document.documentElement.namespaceURI, 'u');
+    child.setAttribute('val', style);
+    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 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: styles ? readIndexedColors(styles) : defaultIndexedColors,
+        theme: readThemeColors(theme)
+    };
+}
+function resolveXlsxColor(element, resolver) {
+    if (!element) return;
+    const direct = normalizedHexColor(attribute(element, 'rgb'));
+    const themeIndex = boundedInteger(attribute(element, 'theme'), 11);
+    const indexed = boundedInteger(attribute(element, 'indexed'), 65535);
+    const automatic = 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(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(attribute(element, 'rgb')));
+    return colors.every(Boolean) ? colors : defaultIndexedColors;
+}
+function drawingColor(element) {
+    if (!element) return;
+    return normalizedHexColor('sysClr' === element.localName ? attribute(element, 'lastClr') : 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 booleanAttribute(element, name) {
+    const value = attribute(element, name)?.trim().toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
+}
+const THEME_COLOR_NAMES = [
+    'lt1',
+    'dk1',
+    'lt2',
+    'dk2',
+    'accent1',
+    'accent2',
+    'accent3',
+    'accent4',
+    'accent5',
+    'accent6',
+    'hlink',
+    'folHlink'
+];
+const MAX_INDEXED_COLOR = 255;
+function readXlsxSemanticColorOrigin(element, colors) {
+    if (!element || attribute(element, 'rgb')) return;
+    const renderedColor = resolveXlsxColor(element, colors);
+    if (!renderedColor) return;
+    const tint = boundedTint(attribute(element, 'tint'));
+    const theme = work_xlsx_cell_style_origin_boundedInteger(attribute(element, 'theme'), THEME_COLOR_NAMES.length - 1);
+    if (null !== theme && colors.theme[theme]) return {
+        kind: 'theme',
+        baseColor: `#${colors.theme[theme]}`,
+        index: theme,
+        renderedColor,
+        ...null === tint ? {} : {
+            tint
+        }
+    };
+    const indexed = work_xlsx_cell_style_origin_boundedInteger(attribute(element, 'indexed'), MAX_INDEXED_COLOR);
+    if (null !== indexed && colors.indexed[indexed]) return {
+        kind: 'indexed',
+        baseColor: `#${colors.indexed[indexed]}`,
+        index: indexed,
+        renderedColor,
+        ...null === tint ? {} : {
+            tint
+        }
+    };
+    if (xlsxBooleanAttribute(element, 'auto')) return {
+        kind: 'automatic',
+        baseColor: '#000000',
+        renderedColor,
+        ...null === tint ? {} : {
+            tint
+        }
+    };
+}
+function withXlsxCellStyleOrigin(cell, origin) {
+    return origin && xlsxCellStyleOriginHasValues(origin) ? {
+        ...cell,
+        a3sXlsxStyleOrigin: origin
+    } : cell;
+}
+function xlsxCellStyleOrigin(cell) {
+    const candidate = cell?.a3sXlsxStyleOrigin;
+    if (!work_xlsx_cell_style_origin_isRecord(candidate)) return;
+    const fontColor = normalizeXlsxSemanticColorOrigin(candidate.fontColor);
+    const fillColor = normalizeXlsxSemanticColorOrigin(candidate.fillColor);
+    const borderColors = normalizedBorderColors(candidate.borderColors);
+    const origin = {
+        ...fontColor ? {
+            fontColor
+        } : {},
+        ...fillColor ? {
+            fillColor
+        } : {},
+        ...borderColors ? {
+            borderColors
+        } : {}
+    };
+    return xlsxCellStyleOriginHasValues(origin) ? origin : void 0;
+}
+function xlsxSemanticColorMatchesValue(origin, value) {
+    return work_xlsx_cell_style_origin_normalizedColor(value) === origin.renderedColor.toLowerCase();
+}
+function xlsxColorElementMatchesOrigin(element, origin) {
+    if (!element || attribute(element, 'rgb')) return false;
+    if ('theme' === origin.kind) {
+        if (attribute(element, 'theme') !== String(origin.index)) return false;
+    } else if ('indexed' === origin.kind) {
+        if (attribute(element, 'indexed') !== String(origin.index)) return false;
+    } else if (!xlsxBooleanAttribute(element, 'auto')) return false;
+    const tint = boundedTint(attribute(element, 'tint'));
+    return tint === (origin.tint ?? null);
+}
+function applyXlsxSemanticColorOrigin(element, origin) {
+    for (const name of [
+        'rgb',
+        'theme',
+        'indexed',
+        'auto',
+        'tint'
+    ])element.removeAttribute(name);
+    if ('theme' === origin.kind) element.setAttribute('theme', String(origin.index));
+    else if ('indexed' === origin.kind) element.setAttribute('indexed', String(origin.index));
+    else element.setAttribute('auto', '1');
+    if (void 0 !== origin.tint) element.setAttribute('tint', String(origin.tint));
+}
+function xlsxSemanticColorOriginKey(origin) {
+    return origin ? `${origin.kind}:${'index' in origin ? origin.index : ''}:${origin.baseColor}:${origin.renderedColor}:${origin.tint ?? ''}` : '';
+}
+function xlsxSemanticColorOriginSupported(origin, palette) {
+    if ('automatic' === origin.kind) return true;
+    return palette?.[origin.kind].get(origin.index)?.toLowerCase() === origin.baseColor.toLowerCase();
+}
+function prepareXlsxSemanticPalette(styles, theme, origins) {
+    const candidates = semanticPaletteCandidates(origins);
+    const supportedTheme = new Map();
+    let themeChanged = false;
+    const scheme = theme ? firstDescendant(theme, 'clrScheme') : void 0;
+    for (const [index, color] of candidates.theme){
+        const name = THEME_COLOR_NAMES[index];
+        const entry = name && scheme ? directChild(scheme, name) : void 0;
+        if (entry) {
+            themeChanged = writeThemeColor(entry, color) || themeChanged;
+            supportedTheme.set(index, color);
+        }
+    }
+    const supportedIndexed = new Map();
+    let stylesChanged = false;
+    if (candidates.indexed.size) {
+        const colors = ensureXlsxStyleCollection(styles, 'colors', [
+            'extLst'
+        ]);
+        let indexedColors = directChild(colors, 'indexedColors');
+        if (!indexedColors) {
+            indexedColors = styles.createElementNS(styles.documentElement.namespaceURI, 'indexedColors');
+            colors.prepend(indexedColors);
+            stylesChanged = true;
+        }
+        const resolver = createXlsxColorResolver(styles, theme);
+        const highestIndex = Math.max(...candidates.indexed.keys());
+        while(directChildren(indexedColors, 'rgbColor').length <= highestIndex){
+            const index = directChildren(indexedColors, 'rgbColor').length;
+            const element = styles.createElementNS(styles.documentElement.namespaceURI, 'rgbColor');
+            element.setAttribute('rgb', `FF${(resolver.indexed[index] ?? '000000').toUpperCase()}`);
+            indexedColors.append(element);
+            stylesChanged = true;
+        }
+        const entries = directChildren(indexedColors, 'rgbColor');
+        for (const [index, color] of candidates.indexed){
+            const expected = `FF${color.slice(1).toUpperCase()}`;
+            const entry = entries[index];
+            if (entry) {
+                if (attribute(entry, 'rgb')?.toUpperCase() !== expected) {
+                    entry.setAttribute('rgb', expected);
+                    stylesChanged = true;
+                }
+                supportedIndexed.set(index, color);
+            }
+        }
+    }
+    return {
+        palette: {
+            indexed: supportedIndexed,
+            theme: supportedTheme
+        },
+        stylesChanged,
+        themeChanged
+    };
+}
+function semanticPaletteCandidates(origins) {
+    const theme = new Map();
+    const indexed = new Map();
+    const themeConflicts = new Set();
+    const indexedConflicts = new Set();
+    for (const origin of origins)for (const color of xlsxCellStyleOriginColors(origin)){
+        if ('automatic' === color.kind) continue;
+        const target = 'theme' === color.kind ? theme : indexed;
+        const conflicts = 'theme' === color.kind ? themeConflicts : indexedConflicts;
+        const current = target.get(color.index);
+        if (current && current.toLowerCase() !== color.baseColor.toLowerCase()) conflicts.add(color.index);
+        else if (!current) target.set(color.index, color.baseColor);
+    }
+    for (const index of themeConflicts)theme.delete(index);
+    for (const index of indexedConflicts)indexed.delete(index);
+    return {
+        indexed,
+        theme
+    };
+}
+function xlsxCellStyleOriginColors(origin) {
+    return [
+        origin.fontColor,
+        origin.fillColor,
+        ...Object.values(origin.borderColors ?? {})
+    ].filter((value)=>Boolean(value));
+}
+function writeThemeColor(entry, color) {
+    const current = directChildren(entry)[0];
+    if (current?.localName === 'srgbClr' && attribute(current, 'val')?.toLowerCase() === color.slice(1).toLowerCase()) return false;
+    for (const child of directChildren(entry))child.remove();
+    const qualifiedName = entry.prefix ? `${entry.prefix}:srgbClr` : 'srgbClr';
+    const replacement = entry.ownerDocument.createElementNS(entry.namespaceURI, qualifiedName);
+    replacement.setAttribute('val', color.slice(1).toUpperCase());
+    entry.append(replacement);
+    return true;
+}
+function normalizedBorderColors(value) {
+    if (!work_xlsx_cell_style_origin_isRecord(value)) return;
+    const result = {};
+    for (const side of [
+        'bottom',
+        'diagonal',
+        'left',
+        'right',
+        'top'
+    ]){
+        const color = normalizeXlsxSemanticColorOrigin(value[side]);
+        if (color) result[side] = color;
+    }
+    return Object.keys(result).length ? result : void 0;
+}
+function normalizeXlsxSemanticColorOrigin(value) {
+    if (!work_xlsx_cell_style_origin_isRecord(value)) return;
+    const baseColor = work_xlsx_cell_style_origin_normalizedColor(value.baseColor);
+    const renderedColor = work_xlsx_cell_style_origin_normalizedColor(value.renderedColor);
+    const tint = normalizedTint(value.tint);
+    if (!baseColor || !renderedColor || void 0 === tint) return;
+    if ('automatic' === value.kind) return {
+        kind: 'automatic',
+        baseColor,
+        renderedColor,
+        ...null === tint ? {} : {
+            tint
+        }
+    };
+    const maximum = 'theme' === value.kind ? THEME_COLOR_NAMES.length - 1 : MAX_INDEXED_COLOR;
+    const index = boundedNumber(value.index, maximum);
+    if ('theme' !== value.kind && 'indexed' !== value.kind || null === index) return;
+    return {
+        kind: value.kind,
+        baseColor,
+        index,
+        renderedColor,
+        ...null === tint ? {} : {
+            tint
+        }
+    };
+}
+function xlsxCellStyleOriginHasValues(origin) {
+    return Boolean(origin.fontColor || origin.fillColor || Object.keys(origin.borderColors ?? {}).length);
+}
+function work_xlsx_cell_style_origin_normalizedColor(value) {
+    const rgb = xlsxRgbColor(value);
+    return rgb ? `#${rgb.slice(-6).toLowerCase()}` : null;
+}
+function normalizedTint(value) {
+    if (void 0 === value) return null;
+    return 'number' == typeof value && Number.isFinite(value) && value >= -1 && value <= 1 ? value : void 0;
+}
+function boundedTint(value) {
+    if (null === value) return null;
+    const tint = Number(value);
+    return Number.isFinite(tint) && tint >= -1 && tint <= 1 ? tint : null;
+}
+function work_xlsx_cell_style_origin_boundedInteger(value, maximum) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    return boundedNumber(Number(value), maximum);
+}
+function boundedNumber(value, maximum) {
+    return 'number' == typeof value && Number.isSafeInteger(value) && value >= 0 && value <= maximum ? value : null;
+}
+function xlsxBooleanAttribute(element, name) {
+    const value = attribute(element, name)?.trim().toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
+}
+function work_xlsx_cell_style_origin_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
 const spreadsheetTextOrientationIds = [
     'horizontal',
     'angleCounterclockwise',
@@ -2309,6 +2953,90 @@ function spreadsheetUnderlineCellValueFromSheetJs(value) {
     if (isSpreadsheetUnderlineStyle(value)) return spreadsheetUnderlineCellValue(value);
     return spreadsheetUnderlineCellValue(spreadsheetUnderlineStyle(value));
 }
+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 directXlsxFontStyle(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: spreadsheetUnderlineStyle(cell.un)
+        } : {}
+    };
+}
+function directXlsxAlignment(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;
+    const rotation = spreadsheetTextOrientationXlsxValueFromCell(cell);
+    if (null !== rotation) alignment.textRotation = rotation;
+    return Object.keys(alignment).length ? alignment : null;
+}
+function xlsxStyleCollectionIndex(collection, childName, value) {
+    const index = nonNegativeInteger(value) ?? 0;
+    return directChildren(collection, childName)[index] ? index : 0;
+}
+function xlsxColorMatches(element, value, colors, fallback) {
+    const rgb = xlsxRgbColor(value);
+    const resolved = resolveXlsxColor(element, colors) ?? fallback;
+    return Boolean(rgb && resolved && `#${rgb.slice(-6).toLowerCase()}` === resolved.toLowerCase());
+}
+function xlsxToggleEnabled(element) {
+    if (!element) return false;
+    const value = attribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function xlsxUnderlineStyle(element) {
+    return element ? spreadsheetUnderlineStyle(spreadsheetUnderlineCellValueFromXlsx(attribute(element, 'val'))) : 'none';
+}
+function xlsxBorderLineMatches(element, line, colors, semanticColor) {
+    const style = element ? attribute(element, 'style') : null;
+    if (!line) return !style;
+    return style === line.style && (semanticColor ? xlsxColorElementMatchesOrigin(element ? directChild(element, 'color') : void 0, semanticColor) : xlsxColorMatches(element ? directChild(element, 'color') : void 0, line.color, colors, '#000000'));
+}
+function activeXlsxSemanticColorOrigin(origin, value, palette) {
+    return origin && xlsxSemanticColorMatchesValue(origin, value) && xlsxSemanticColorOriginSupported(origin, palette) ? origin : void 0;
+}
+function work_xlsx_cell_style_values_xlsxBooleanAttribute(element, name) {
+    if (!element) return false;
+    const value = attribute(element, name)?.trim().toLowerCase();
+    return '1' === value || 'true' === value || 'on' === value;
+}
+function xlsxAlignmentMatches(xf, style) {
+    const alignment = directChild(xf, 'alignment');
+    if (void 0 !== style.horizontal && attribute(alignment ?? xf, 'horizontal') !== style.horizontal) return false;
+    if (void 0 !== style.vertical && attribute(alignment ?? xf, 'vertical') !== style.vertical) return false;
+    if (void 0 !== style.wrapText && (!alignment || null === attribute(alignment, 'wrapText') || work_xlsx_cell_style_values_xlsxBooleanAttribute(alignment, 'wrapText') !== style.wrapText)) return false;
+    if (void 0 !== style.textRotation) {
+        const rotation = nonNegativeInteger(alignment ? attribute(alignment, 'textRotation') : null);
+        if (rotation !== style.textRotation) return false;
+    }
+    return true;
+}
+function nonNegativeInteger(value) {
+    if (null === value || !/^\d+$/.test(value)) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
 const SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS = [
     'greaterThan',
     'greaterThanOrEqual',
@@ -2604,7 +3332,7 @@ function spreadsheetConditionalIconAppearance(icon) {
         ];
         return {
             glyph: glyphs[index],
-            color: icon.iconSet.includes('Gray') ? '#606a78' : palette(icon.count)[index],
+            color: icon.iconSet.includes('Gray') ? '#606a78' : work_spreadsheet_conditional_icons_palette(icon.count)[index],
             label
         };
     }
@@ -2615,7 +3343,7 @@ function spreadsheetConditionalIconAppearance(icon) {
     };
     if (icon.iconSet.includes('TrafficLights')) return {
         glyph: '3TrafficLights2' === icon.iconSet ? '◉' : '●',
-        color: palette(icon.count)[index],
+        color: work_spreadsheet_conditional_icons_palette(icon.count)[index],
         label
     };
     if ('3Signs' === icon.iconSet) return {
@@ -2709,7 +3437,7 @@ function normalizeThreshold(value) {
         gte: false !== source.gte
     } : null;
 }
-function palette(count) {
+function work_spreadsheet_conditional_icons_palette(count) {
     if (3 === count) return COLOR_3;
     if (4 === count) return COLOR_4;
     return COLOR_5;
@@ -2761,25 +3489,25 @@ function effectiveSpreadsheetPageSetup(pageSetup) {
     return {
         paperSize: normalizeSpreadsheetPaperSize(pageSetup?.paperSize),
         orientation: pageSetup?.orientation === 'portrait' ? 'portrait' : 'landscape',
-        scale: boundedInteger(pageSetup?.scale, 10, 400, 100),
+        scale: work_spreadsheet_page_setup_boundedInteger(pageSetup?.scale, 10, 400, 100),
         fitToPage: Boolean(pageSetup?.fitToPage),
-        fitToWidth: boundedInteger(pageSetup?.fitToWidth, 0, 32767, 1),
-        fitToHeight: boundedInteger(pageSetup?.fitToHeight, 0, 32767, 0),
+        fitToWidth: work_spreadsheet_page_setup_boundedInteger(pageSetup?.fitToWidth, 0, 32767, 1),
+        fitToHeight: work_spreadsheet_page_setup_boundedInteger(pageSetup?.fitToHeight, 0, 32767, 0),
         horizontalCentered: Boolean(pageSetup?.horizontalCentered),
         verticalCentered: Boolean(pageSetup?.verticalCentered),
         header: effectiveSpreadsheetHeaderFooterSections(pageSetup?.header),
         footer: effectiveSpreadsheetHeaderFooterSections(pageSetup?.footer),
-        pageNumberStart: boundedInteger(pageSetup?.pageNumberStart, 1, 32767, 1),
+        pageNumberStart: work_spreadsheet_page_setup_boundedInteger(pageSetup?.pageNumberStart, 1, 32767, 1),
         pageOrder: pageSetup?.pageOrder === 'downThenOver' ? 'downThenOver' : 'overThenDown',
         scaleWithDocument: pageSetup?.scaleWithDocument !== false,
         alignWithMargins: pageSetup?.alignWithMargins !== false,
         margins: {
-            top: boundedNumber(pageSetup?.margins?.top, 0, 100, DEFAULT_MARGINS.top),
-            right: boundedNumber(pageSetup?.margins?.right, 0, 100, DEFAULT_MARGINS.right),
-            bottom: boundedNumber(pageSetup?.margins?.bottom, 0, 100, DEFAULT_MARGINS.bottom),
-            left: boundedNumber(pageSetup?.margins?.left, 0, 100, DEFAULT_MARGINS.left),
-            header: boundedNumber(pageSetup?.margins?.header, 0, 100, DEFAULT_MARGINS.header),
-            footer: boundedNumber(pageSetup?.margins?.footer, 0, 100, DEFAULT_MARGINS.footer)
+            top: work_spreadsheet_page_setup_boundedNumber(pageSetup?.margins?.top, 0, 100, DEFAULT_MARGINS.top),
+            right: work_spreadsheet_page_setup_boundedNumber(pageSetup?.margins?.right, 0, 100, DEFAULT_MARGINS.right),
+            bottom: work_spreadsheet_page_setup_boundedNumber(pageSetup?.margins?.bottom, 0, 100, DEFAULT_MARGINS.bottom),
+            left: work_spreadsheet_page_setup_boundedNumber(pageSetup?.margins?.left, 0, 100, DEFAULT_MARGINS.left),
+            header: work_spreadsheet_page_setup_boundedNumber(pageSetup?.margins?.header, 0, 100, DEFAULT_MARGINS.header),
+            footer: work_spreadsheet_page_setup_boundedNumber(pageSetup?.margins?.footer, 0, 100, DEFAULT_MARGINS.footer)
         }
     };
 }
@@ -2796,10 +3524,340 @@ function normalizeSpreadsheetPaperSize(value) {
             return 'a4';
     }
 }
-function boundedInteger(value, minimum, maximum, fallback) {
-    return Math.trunc(boundedNumber(value, minimum, maximum, fallback));
+function work_spreadsheet_page_setup_boundedInteger(value, minimum, maximum, fallback) {
+    return Math.trunc(work_spreadsheet_page_setup_boundedNumber(value, minimum, maximum, fallback));
 }
-function boundedNumber(value, minimum, maximum, fallback) {
+function work_spreadsheet_page_setup_boundedNumber(value, minimum, maximum, fallback) {
     return 'number' == typeof value && Number.isFinite(value) && value >= minimum && value <= maximum ? value : fallback;
 }
-export { DEFAULT_PROTECTION_HINT, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, SPREADSHEET_CONDITIONAL_ICON_SETS, attachSpreadsheetShownCommentCells, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, freezeImportedSpreadsheetCell, importedSheetProtectionAuthority, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetPaperSize, protectedSheetCount, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, registerDerivedSpreadsheetMatrix, registerImportedSpreadsheetMatrix, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameSpreadsheetHistoryValue, sheetHasProtectionState, sheetProtectionAuthority, spreadsheetCellValueWithDiagonalBorder, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetMatrixProfile, spreadsheetProtectionKey, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetTextOrientationXlsxValueFromCell, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withoutEditableRange };
+const MAX_XLSX_RICH_TEXT_CELL_CHARACTERS = 32767;
+const MAX_XLSX_RICH_TEXT_RUNS_PER_CELL = 512;
+const MAX_XLSX_RICH_TEXT_CELLS = 10000;
+const MAX_XLSX_RICH_TEXT_RUNS = 100000;
+const MAX_XLSX_SHARED_RICH_TEXT_ITEMS = 10000;
+const MAX_XLSX_FONT_NAME_CHARACTERS = 128;
+const MAX_XLSX_FONT_SIZE = 409;
+function createXlsxRichTextReadContext(options) {
+    const colors = createXlsxColorResolver(options.styles, options.theme);
+    const sharedStrings = readRichSharedStrings(options.sharedStrings, colors);
+    return {
+        colors,
+        hasRichSharedStrings: sharedStrings.size > 0,
+        remainingCells: MAX_XLSX_RICH_TEXT_CELLS,
+        remainingRuns: MAX_XLSX_RICH_TEXT_RUNS,
+        sharedStrings
+    };
+}
+function readXlsxRichTextCells(worksheet, context) {
+    const result = [];
+    const seen = new Set();
+    for (const element of descendants(worksheet, 'c')){
+        if (context.remainingCells <= 0 || context.remainingRuns <= 0) break;
+        if (directChild(element, 'f')) continue;
+        const reference = attribute(element, 'r');
+        if (!reference) continue;
+        const coordinate = decodeXlsxCellAddress(reference);
+        if (!coordinate || coordinate.column > 16383 || coordinate.row > 1048575 || seen.has(reference)) continue;
+        seen.add(reference);
+        const type = attribute(element, 't');
+        let source = null;
+        if ('s' === type) {
+            const index = work_xlsx_rich_text_nonNegativeInteger(directChild(element, 'v')?.textContent);
+            source = null === index ? null : context.sharedStrings.get(index) ?? null;
+        } else if ('inlineStr' === type) {
+            const inlineString = directChild(element, 'is');
+            source = inlineString ? readRichTextRuns(inlineString, context.colors) : null;
+        }
+        if (!source?.length || source.length > context.remainingRuns) continue;
+        const runs = source.map((run)=>({
+                ...run
+            }));
+        const text = runs.map((run)=>run.v).join('');
+        if (text && !(text.length > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS)) {
+            context.remainingCells -= 1;
+            context.remainingRuns -= runs.length;
+            result.push({
+                ...coordinate,
+                runs,
+                text
+            });
+        }
+    }
+    return result;
+}
+function applyImportedXlsxRichText(cell, richText) {
+    if (!richText) return cell;
+    const next = {
+        ...cell,
+        ct: {
+            ...cell.ct,
+            s: richText.runs.map((run)=>({
+                    ...run
+                })),
+            t: 'inlineStr'
+        },
+        v: richText.text
+    };
+    delete next.m;
+    return next;
+}
+function patchSpreadsheetRichTextFontRuns(cell, patch) {
+    if (!fontPatchHasValues(patch) || cell.ct?.t !== 'inlineStr') return cell;
+    const source = cell.ct.s;
+    if (!Array.isArray(source) || !source.length || source.some((run)=>!work_xlsx_rich_text_isRecord(run) || 'string' != typeof run.v || !validXmlText(run.v))) return cell;
+    const normalizedColor = void 0 === patch.fontColor ? void 0 : normalizedColorValue(patch.fontColor);
+    const runs = source.map((run)=>{
+        const next = {
+            ...run
+        };
+        if (void 0 !== patch.fontFamily) next.ff = patch.fontFamily.trim();
+        if (void 0 !== patch.fontSize) next.fs = patch.fontSize;
+        if (void 0 !== normalizedColor) {
+            next.fc = normalizedColor;
+            delete next.a3sXlsxColorOrigin;
+        }
+        if (void 0 !== patch.bold) next.bl = patch.bold ? 1 : 0;
+        if (void 0 !== patch.italic) next.it = patch.italic ? 1 : 0;
+        if (void 0 !== patch.underline) next.un = spreadsheetUnderlineCellValue(patch.underline);
+        if (void 0 !== patch.strike) next.cl = patch.strike ? 1 : 0;
+        return next;
+    });
+    return {
+        ...cell,
+        ct: {
+            ...cell.ct,
+            s: runs
+        }
+    };
+}
+function xlsxRichTextCellText(cell) {
+    return normalizeRichTextCell(cell)?.text ?? null;
+}
+function sheetHasXlsxRichTextCells(sheet) {
+    for (const [, row] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [, cell] of spreadsheet_sparse_sparseArrayEntries(row))if (cell && normalizeRichTextCell(cell)) return true;
+    return false;
+}
+function xlsxRichTextStyleOrigins(sheet) {
+    const origins = [];
+    for (const [, row] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [, cell] of spreadsheet_sparse_sparseArrayEntries(row))if (cell) for (const run of normalizeRichTextCell(cell)?.runs ?? []){
+        const fontColor = normalizeXlsxSemanticColorOrigin(run.a3sXlsxColorOrigin);
+        if (fontColor && run.fc && xlsxSemanticColorMatchesValue(fontColor, run.fc)) origins.push({
+            fontColor
+        });
+    }
+    return origins;
+}
+function writeXlsxRichTextCells(worksheet, sheet, semanticPalette) {
+    const elements = new Map(descendants(worksheet, 'c').flatMap((element)=>{
+        const reference = attribute(element, 'r');
+        return reference ? [
+            [
+                reference,
+                element
+            ]
+        ] : [];
+    }));
+    let remainingCells = MAX_XLSX_RICH_TEXT_CELLS;
+    let remainingRuns = MAX_XLSX_RICH_TEXT_RUNS;
+    for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values)){
+        if (remainingCells <= 0 || remainingRuns <= 0) return;
+        if (!cell) continue;
+        const richText = normalizeRichTextCell(cell);
+        if (!richText || richText.runs.length > remainingRuns) continue;
+        const element = elements.get(xlsxCellAddress(row, column));
+        if (element) {
+            writeRichTextCell(element, richText, semanticPalette);
+            remainingCells -= 1;
+            remainingRuns -= richText.runs.length;
+        }
+    }
+}
+function readRichSharedStrings(document, colors) {
+    if (!document) return new Map();
+    const result = new Map();
+    let parsedRuns = 0;
+    for (const [index, item] of directChildren(document.documentElement, 'si').entries()){
+        if (result.size >= MAX_XLSX_SHARED_RICH_TEXT_ITEMS || parsedRuns >= MAX_XLSX_RICH_TEXT_RUNS) break;
+        const runs = readRichTextRuns(item, colors);
+        if (runs && !(parsedRuns + runs.length > MAX_XLSX_RICH_TEXT_RUNS)) {
+            result.set(index, runs);
+            parsedRuns += runs.length;
+        }
+    }
+    return result;
+}
+function readRichTextRuns(container, colors) {
+    const elements = directChildren(container, 'r');
+    if (directChild(container, 't') || !elements.length || elements.length > MAX_XLSX_RICH_TEXT_RUNS_PER_CELL) return null;
+    const runs = [];
+    let characterCount = 0;
+    for (const element of elements){
+        const textElement = directChild(element, 't');
+        if (!textElement || textElement.children.length || 1 !== directChildren(element, 't').length) return null;
+        const value = textElement.textContent ?? '';
+        if (value) {
+            characterCount += value.length;
+            if (characterCount > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS || !validXmlText(value)) return null;
+            runs.push(readRichTextRun(element, value, colors));
+        }
+    }
+    return runs.length ? runs : null;
+}
+function readRichTextRun(element, value, colors) {
+    const properties = directChild(element, 'rPr');
+    if (!properties) return {
+        v: value
+    };
+    const run = {
+        v: value
+    };
+    const font = directChild(properties, 'rFont') ?? directChild(properties, 'name');
+    const fontName = attribute(font ?? properties, 'val')?.trim();
+    if (fontName && fontName.length <= MAX_XLSX_FONT_NAME_CHARACTERS) run.ff = fontName;
+    if (work_xlsx_rich_text_xlsxToggleEnabled(directChild(properties, 'b'))) run.bl = 1;
+    if (work_xlsx_rich_text_xlsxToggleEnabled(directChild(properties, 'i'))) run.it = 1;
+    if (work_xlsx_rich_text_xlsxToggleEnabled(directChild(properties, 'strike'))) run.cl = 1;
+    const size = finiteNumber(attribute(directChild(properties, 'sz') ?? properties, 'val'));
+    if (null !== size && size >= 1 && size <= MAX_XLSX_FONT_SIZE) run.fs = size;
+    const underline = directChild(properties, 'u');
+    if (underline) {
+        const value = spreadsheetUnderlineCellValueFromXlsx(attribute(underline, 'val'));
+        if (value) run.un = value;
+    }
+    const colorElement = directChild(properties, 'color');
+    const color = resolveXlsxColor(colorElement, colors);
+    if (color) run.fc = color;
+    const colorOrigin = readXlsxSemanticColorOrigin(colorElement, colors);
+    if (colorOrigin) run.a3sXlsxColorOrigin = colorOrigin;
+    return run;
+}
+function normalizeRichTextCell(cell) {
+    if (cell.f || cell.ct?.t !== 'inlineStr' || !Array.isArray(cell.ct.s)) return null;
+    if (!cell.ct.s.length || cell.ct.s.length > MAX_XLSX_RICH_TEXT_RUNS_PER_CELL) return null;
+    const runs = [];
+    let characterCount = 0;
+    for (const candidate of cell.ct.s){
+        const run = normalizeRichTextRun(candidate);
+        if (!run) return null;
+        if (run.v) {
+            characterCount += run.v.length;
+            if (characterCount > MAX_XLSX_RICH_TEXT_CELL_CHARACTERS) return null;
+            runs.push(run);
+        }
+    }
+    const text = runs.map((run)=>run.v).join('');
+    return runs.length && text ? {
+        runs,
+        text
+    } : null;
+}
+function normalizeRichTextRun(value) {
+    if (!work_xlsx_rich_text_isRecord(value) || 'string' != typeof value.v || !validXmlText(value.v)) return null;
+    const run = {
+        v: value.v
+    };
+    if (1 === Number(value.bl)) run.bl = 1;
+    else if (0 === Number(value.bl) && void 0 !== value.bl) run.bl = 0;
+    if (1 === Number(value.it)) run.it = 1;
+    else if (0 === Number(value.it) && void 0 !== value.it) run.it = 0;
+    if (1 === Number(value.cl)) run.cl = 1;
+    else if (0 === Number(value.cl) && void 0 !== value.cl) run.cl = 0;
+    if ('string' == typeof value.ff && value.ff.trim() && value.ff.trim().length <= MAX_XLSX_FONT_NAME_CHARACTERS) run.ff = value.ff.trim();
+    if ('number' == typeof value.fs && Number.isFinite(value.fs) && value.fs >= 1 && value.fs <= MAX_XLSX_FONT_SIZE) run.fs = value.fs;
+    const color = normalizedColorValue(value.fc);
+    if (color) run.fc = color;
+    const underline = Number(value.un);
+    if (Number.isSafeInteger(underline) && underline >= 0 && underline <= 4 && void 0 !== value.un) run.un = underline;
+    const colorOrigin = normalizeXlsxSemanticColorOrigin(value.a3sXlsxColorOrigin);
+    if (colorOrigin) run.a3sXlsxColorOrigin = colorOrigin;
+    return run;
+}
+function writeRichTextCell(element, richText, semanticPalette) {
+    for (const child of directChildren(element))if ('v' === child.localName || 'is' === child.localName) child.remove();
+    element.setAttribute('t', 'inlineStr');
+    const document = element.ownerDocument;
+    const namespace = document.documentElement.namespaceURI;
+    const inlineString = document.createElementNS(namespace, 'is');
+    for (const run of richText.runs){
+        const runElement = document.createElementNS(namespace, 'r');
+        const properties = writeRichTextRunProperties(document, run, semanticPalette);
+        if (properties) runElement.append(properties);
+        const text = document.createElementNS(namespace, 't');
+        if (/^\s|\s$/.test(run.v)) text.setAttributeNS('http://www.w3.org/XML/1998/namespace', 'xml:space', 'preserve');
+        text.textContent = run.v;
+        runElement.append(text);
+        inlineString.append(runElement);
+    }
+    element.insertBefore(inlineString, directChildren(element).find((child)=>'extLst' === child.localName) ?? null);
+}
+function writeRichTextRunProperties(document, run, semanticPalette) {
+    const namespace = document.documentElement.namespaceURI;
+    const properties = document.createElementNS(namespace, 'rPr');
+    const appendValue = (name, value)=>{
+        const element = document.createElementNS(namespace, name);
+        element.setAttribute('val', value);
+        properties.append(element);
+    };
+    const appendToggle = (name, enabled)=>{
+        if (!enabled) return;
+        const element = document.createElementNS(namespace, name);
+        element.setAttribute('val', '1');
+        properties.append(element);
+    };
+    if (run.ff) appendValue('rFont', run.ff);
+    appendToggle('b', 1 === run.bl);
+    appendToggle('i', 1 === run.it);
+    appendToggle('strike', 1 === run.cl);
+    if (run.fc) {
+        const color = document.createElementNS(namespace, 'color');
+        const semanticOrigin = activeXlsxSemanticColorOrigin(normalizeXlsxSemanticColorOrigin(run.a3sXlsxColorOrigin), run.fc, semanticPalette);
+        if (semanticOrigin) applyXlsxSemanticColorOrigin(color, semanticOrigin);
+        else {
+            const rgb = xlsxRgbColor(run.fc);
+            if (rgb) color.setAttribute('rgb', rgb);
+        }
+        if (color.attributes.length) properties.append(color);
+    }
+    if (void 0 !== run.fs) appendValue('sz', String(run.fs));
+    if (void 0 !== run.un && 0 !== run.un) appendValue('u', spreadsheetUnderlineStyle(run.un));
+    return properties.children.length ? properties : null;
+}
+function fontPatchHasValues(patch) {
+    return void 0 !== patch.fontFamily || void 0 !== patch.fontSize || void 0 !== patch.fontColor || void 0 !== patch.bold || void 0 !== patch.italic || void 0 !== patch.underline || void 0 !== patch.strike;
+}
+function normalizedColorValue(value) {
+    const rgb = xlsxRgbColor(value);
+    return rgb ? `#${rgb.slice(-6).toLowerCase()}` : null;
+}
+function work_xlsx_rich_text_xlsxToggleEnabled(element) {
+    if (!element) return false;
+    const value = attribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function finiteNumber(value) {
+    if (null === value || !value.trim()) return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function work_xlsx_rich_text_nonNegativeInteger(value) {
+    if (null == value || !/^\d+$/.test(value.trim())) return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function validXmlText(value) {
+    for(let index = 0; index < value.length; index += 1){
+        const code = value.charCodeAt(index);
+        if (0x09 !== code && 0x0a !== code && 0x0d !== code && (!(code >= 0x20) || !(code <= 0xd7ff)) && (!(code >= 0xe000) || !(code <= 0xfffd))) {
+            if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length && value.charCodeAt(index + 1) >= 0xdc00 && value.charCodeAt(index + 1) <= 0xdfff) {
+                index += 1;
+                continue;
+            }
+            return false;
+        }
+    }
+    return true;
+}
+function work_xlsx_rich_text_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+export { DEFAULT_PROTECTION_HINT, SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS, SPREADSHEET_CONDITIONAL_ICON_SETS, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, applyXlsxSemanticColorOrigin, attachSpreadsheetShownCommentCells, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxColorResolver, createXlsxRichTextReadContext, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, defaultXlsxBorder, defaultXlsxFill, directXlsxAlignment, directXlsxFontStyle, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, ensureXlsxStyleCollection, freezeImportedSpreadsheetCell, hasXlsxDirectFontStyle, importedSheetProtectionAuthority, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetPaperSize, patchSpreadsheetRichTextFontRuns, prepareXlsxSemanticPalette, protectedSheetCount, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, readXlsxSemanticColorOrigin, registerDerivedSpreadsheetMatrix, registerImportedSpreadsheetMatrix, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, resolveXlsxColor, sameSpreadsheetHistoryValue, setXlsxBorderLine, setXlsxColorChild, setXlsxToggleChild, setXlsxUnderlineChild, setXlsxValueChild, sheetHasProtectionState, sheetHasXlsxRichTextCells, sheetProtectionAuthority, spreadsheetCellValueWithDiagonalBorder, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetMatrixProfile, spreadsheetProtectionKey, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withXlsxCellStyleOrigin, withoutEditableRange, work_xlsx_cell_style_values_xlsxBooleanAttribute, writeXlsxAlignment, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBorderLineMatches, xlsxCellStyleOrigin, xlsxColorElementMatchesOrigin, xlsxColorMatches, xlsxRgbColor, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxSemanticColorOriginKey, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle, xlsxWorksheetCellEntries };