@a3s-lab/office 0.31.0 → 0.32.0

package/dist/9333.js

@@ -0,0 +1,1849 @@
+import { directChild, directChildren, attribute, firstDescendant } from "./4121.js";
+import { sparseMatrixColumnCount, cloneSparseMatrix, sparseArrayIndexes, sparseArrayEntries as spreadsheet_sparse_sparseArrayEntries, formatSpreadsheetCellRanges, parseSpreadsheetCellRanges as work_spreadsheet_ranges_parseSpreadsheetCellRanges } from "./8715.js";
+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',
+    'v'
+]);
+function sameSpreadsheetHistoryValue(left, right) {
+    if (left === right) return true;
+    if (null === left || null === right || typeof left !== typeof right) return false;
+    const leftFormulaCell = spreadsheetFormulaCell(left);
+    const rightFormulaCell = spreadsheetFormulaCell(right);
+    if (leftFormulaCell || rightFormulaCell) return Boolean(leftFormulaCell && rightFormulaCell && sameSpreadsheetFormulaHistoryCell(leftFormulaCell, rightFormulaCell));
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+        const leftKeys = Object.keys(left).filter((key)=>void 0 !== left[Number(key)]);
+        const rightKeys = Object.keys(right).filter((key)=>void 0 !== right[Number(key)]);
+        return leftKeys.length === rightKeys.length && leftKeys.every((key)=>Object.hasOwn(right, key) && sameSpreadsheetHistoryValue(left[Number(key)], right[Number(key)]));
+    }
+    if ('object' != typeof left || 'object' != typeof right) return false;
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).filter((key)=>void 0 !== leftRecord[key]);
+    const rightKeys = Object.keys(rightRecord).filter((key)=>void 0 !== rightRecord[key]);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key)=>sameSpreadsheetHistoryValue(leftRecord[key], rightRecord[key]));
+}
+function spreadsheetFormulaCell(value) {
+    return value && 'object' == typeof value && 'string' == typeof value.f ? value : null;
+}
+function sameSpreadsheetFormulaHistoryCell(left, right) {
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).filter((key)=>!spreadsheetFormulaHistoryIgnoredKeys.has(key) && void 0 !== leftRecord[key]);
+    const rightKeys = Object.keys(rightRecord).filter((key)=>!spreadsheetFormulaHistoryIgnoredKeys.has(key) && void 0 !== rightRecord[key]);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key)=>sameSpreadsheetHistoryValue(leftRecord[key], rightRecord[key])) && sameSpreadsheetHistoryValue(spreadsheetFormulaHistoryCellType(left.ct), spreadsheetFormulaHistoryCellType(right.ct));
+}
+function spreadsheetFormulaHistoryCellType(cellType) {
+    if (!cellType) return;
+    const { fa, t: _type, ...retainedCellType } = cellType;
+    const normalized = {
+        ...retainedCellType,
+        ...fa && 'General' !== fa ? {
+            fa
+        } : {}
+    };
+    return Object.keys(normalized).length ? normalized : void 0;
+}
+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 (!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 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, colors) {
+    const candidates = semanticPaletteCandidates(colors);
+    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(colors) {
+    const theme = new Map();
+    const indexed = new Map();
+    const themeConflicts = new Set();
+    const indexedConflicts = new Set();
+    for (const color of colors){
+        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 xlsxCellStyleOriginSemanticColors(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 (!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 (!isRecord(value)) return;
+    const baseColor = normalizedColor(value.baseColor);
+    const renderedColor = 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 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 isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const XLSX_GRADIENT_FILL_CELL_KEY = 'a3sXlsxGradientFill';
+const MAX_XLSX_GRADIENT_STOPS = 256;
+function readXlsxGradientFill(element, colors) {
+    if (!element) return;
+    const type = attribute(element, 'type') ?? 'linear';
+    if ('linear' !== type && 'path' !== type) return;
+    const children = directChildren(element);
+    if (children.length < 2 || children.length > MAX_XLSX_GRADIENT_STOPS || children.some((child)=>'stop' !== child.localName)) return;
+    const stops = [];
+    for (const stop of children){
+        const position = unitInterval(attribute(stop, 'position'));
+        const stopChildren = directChildren(stop);
+        const colorElement = stopChildren[0];
+        if (null === position || 1 !== stopChildren.length || colorElement?.localName !== 'color') return;
+        const renderedColor = resolveXlsxColor(colorElement, colors);
+        const color = work_xlsx_gradient_fill_normalizedColor(renderedColor);
+        if (!color || (stops.at(-1)?.position ?? 0) > position) return;
+        const colorOrigin = readXlsxSemanticColorOrigin(colorElement, colors);
+        stops.push({
+            color,
+            ...colorOrigin ? {
+                colorOrigin
+            } : {},
+            position
+        });
+    }
+    if ('linear' === type) {
+        const degree = optionalFiniteNumber(attribute(element, 'degree'), 0);
+        return null === degree ? void 0 : {
+            degree,
+            stops,
+            type
+        };
+    }
+    const left = optionalUnitInterval(attribute(element, 'left'), 0);
+    const right = optionalUnitInterval(attribute(element, 'right'), 0);
+    const top = optionalUnitInterval(attribute(element, 'top'), 0);
+    const bottom = optionalUnitInterval(attribute(element, 'bottom'), 0);
+    if (null === left || null === right || null === top || null === bottom || left > right || top > bottom) return;
+    return {
+        bottom,
+        left,
+        right,
+        stops,
+        top,
+        type
+    };
+}
+function withXlsxGradientFill(cell, fill) {
+    const normalized = normalizeXlsxGradientFill(fill);
+    return normalized ? {
+        ...cell,
+        [XLSX_GRADIENT_FILL_CELL_KEY]: normalized
+    } : cell;
+}
+function deleteXlsxGradientFill(cell) {
+    delete cell[XLSX_GRADIENT_FILL_CELL_KEY];
+}
+function xlsxGradientFill(cell) {
+    return normalizeXlsxGradientFill(cell?.[XLSX_GRADIENT_FILL_CELL_KEY]);
+}
+function activeXlsxGradientFill(cell) {
+    const fill = xlsxGradientFill(cell);
+    return fill && work_xlsx_gradient_fill_normalizedColor(cell?.bg) === xlsxGradientFillFallbackColor(fill) ? fill : void 0;
+}
+function normalizeXlsxGradientFill(value) {
+    if (!work_xlsx_gradient_fill_isRecord(value) || !Array.isArray(value.stops)) return;
+    if (value.stops.length < 2 || value.stops.length > MAX_XLSX_GRADIENT_STOPS) return;
+    const stops = [];
+    for (const valueStop of value.stops){
+        if (!work_xlsx_gradient_fill_isRecord(valueStop)) return;
+        const position = normalizedUnitInterval(valueStop.position);
+        const color = work_xlsx_gradient_fill_normalizedColor(valueStop.color);
+        if (null === position || !color || (stops.at(-1)?.position ?? 0) > position) return;
+        const colorOrigin = normalizeXlsxSemanticColorOrigin(valueStop.colorOrigin);
+        stops.push({
+            color,
+            ...colorOrigin ? {
+                colorOrigin
+            } : {},
+            position
+        });
+    }
+    if ('linear' === value.type) {
+        const degree = finiteNumber(value.degree);
+        return null === degree ? void 0 : {
+            degree,
+            stops,
+            type: 'linear'
+        };
+    }
+    if ('path' !== value.type) return;
+    const left = normalizedUnitInterval(value.left);
+    const right = normalizedUnitInterval(value.right);
+    const top = normalizedUnitInterval(value.top);
+    const bottom = normalizedUnitInterval(value.bottom);
+    if (null === left || null === right || null === top || null === bottom || left > right || top > bottom) return;
+    return {
+        bottom,
+        left,
+        right,
+        stops,
+        top,
+        type: 'path'
+    };
+}
+function xlsxGradientFillFallbackColor(fill) {
+    return fill.stops[0]?.color ?? '#ffffff';
+}
+function xlsxGradientFillSemanticColors(fill) {
+    return (fill?.stops ?? []).flatMap((stop)=>stop.colorOrigin ? [
+            stop.colorOrigin
+        ] : []);
+}
+function xlsxGradientFillKey(fill) {
+    if (!fill) return '';
+    const geometry = 'linear' === fill.type ? `linear:${fill.degree}` : `path:${fill.left}:${fill.right}:${fill.top}:${fill.bottom}`;
+    return `${geometry}:${fill.stops.map((stop)=>`${stop.position}:${stop.color}:${xlsxSemanticColorOriginKey(stop.colorOrigin)}`).join('|')}`;
+}
+function unitInterval(value) {
+    if (null === value || !value.trim()) return null;
+    return normalizedUnitInterval(Number(value));
+}
+function optionalUnitInterval(value, fallback) {
+    return null === value ? fallback : unitInterval(value);
+}
+function normalizedUnitInterval(value) {
+    return 'number' == typeof value && Number.isFinite(value) && value >= 0 && value <= 1 ? value : null;
+}
+function optionalFiniteNumber(value, fallback) {
+    if (null === value) return fallback;
+    if (!value.trim()) return null;
+    return finiteNumber(Number(value));
+}
+function finiteNumber(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : null;
+}
+function work_xlsx_gradient_fill_normalizedColor(value) {
+    const rgb = xlsxRgbColor(value);
+    return rgb ? `#${rgb.slice(-6).toLowerCase()}` : null;
+}
+function work_xlsx_gradient_fill_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const XLSX_PATTERN_FILL_CELL_KEY = 'a3sXlsxPatternFill';
+const xlsxPatternFillTypes = [
+    'darkDown',
+    'darkGray',
+    'darkGrid',
+    'darkHorizontal',
+    'darkTrellis',
+    'darkUp',
+    'darkVertical',
+    'gray0625',
+    'gray125',
+    'lightDown',
+    'lightGray',
+    'lightGrid',
+    'lightHorizontal',
+    'lightTrellis',
+    'lightUp',
+    'lightVertical',
+    'mediumGray'
+];
+const xlsxPatternFillTypeSet = new Set(xlsxPatternFillTypes);
+function readXlsxPatternFill(pattern, colors) {
+    if (!pattern) return;
+    const patternType = attribute(pattern, 'patternType');
+    if (!patternType || !isXlsxPatternFillType(patternType)) return;
+    const foreground = directChild(pattern, 'fgColor');
+    const background = directChild(pattern, 'bgColor');
+    const foregroundColor = foreground ? resolveXlsxColor(foreground, colors) : '#000000';
+    const backgroundColor = background ? resolveXlsxColor(background, colors) : '#ffffff';
+    const normalizedForegroundColor = work_xlsx_pattern_fill_normalizedColor(foregroundColor);
+    const normalizedBackgroundColor = work_xlsx_pattern_fill_normalizedColor(backgroundColor);
+    if (!normalizedForegroundColor || !normalizedBackgroundColor) return;
+    const foregroundColorOrigin = readXlsxSemanticColorOrigin(foreground, colors);
+    const backgroundColorOrigin = readXlsxSemanticColorOrigin(background, colors);
+    return {
+        backgroundColor: normalizedBackgroundColor,
+        ...backgroundColorOrigin ? {
+            backgroundColorOrigin
+        } : {},
+        foregroundColor: normalizedForegroundColor,
+        ...foregroundColorOrigin ? {
+            foregroundColorOrigin
+        } : {},
+        patternType
+    };
+}
+function withXlsxPatternFill(cell, fill) {
+    const normalized = normalizeXlsxPatternFill(fill);
+    return normalized ? {
+        ...cell,
+        [XLSX_PATTERN_FILL_CELL_KEY]: normalized
+    } : cell;
+}
+function deleteXlsxPatternFill(cell) {
+    delete cell[XLSX_PATTERN_FILL_CELL_KEY];
+}
+function xlsxPatternFill(cell) {
+    return normalizeXlsxPatternFill(cell?.[XLSX_PATTERN_FILL_CELL_KEY]);
+}
+function activeXlsxPatternFill(cell) {
+    const fill = xlsxPatternFill(cell);
+    return fill && work_xlsx_pattern_fill_normalizedColor(cell?.bg) === fill.backgroundColor ? fill : void 0;
+}
+function normalizeXlsxPatternFill(value) {
+    if (!work_xlsx_pattern_fill_isRecord(value) || !isXlsxPatternFillType(value.patternType)) return;
+    const foregroundColor = work_xlsx_pattern_fill_normalizedColor(value.foregroundColor);
+    const backgroundColor = work_xlsx_pattern_fill_normalizedColor(value.backgroundColor);
+    if (!foregroundColor || !backgroundColor) return;
+    const foregroundColorOrigin = normalizeXlsxSemanticColorOrigin(value.foregroundColorOrigin);
+    const backgroundColorOrigin = normalizeXlsxSemanticColorOrigin(value.backgroundColorOrigin);
+    return {
+        backgroundColor,
+        ...backgroundColorOrigin ? {
+            backgroundColorOrigin
+        } : {},
+        foregroundColor,
+        ...foregroundColorOrigin ? {
+            foregroundColorOrigin
+        } : {},
+        patternType: value.patternType
+    };
+}
+function xlsxPatternFillSemanticColors(fill) {
+    return fill ? [
+        fill.foregroundColorOrigin,
+        fill.backgroundColorOrigin
+    ].filter((value)=>Boolean(value)) : [];
+}
+function xlsxPatternFillKey(fill) {
+    return fill ? [
+        fill.patternType,
+        fill.foregroundColor,
+        xlsxSemanticColorOriginKey(fill.foregroundColorOrigin),
+        fill.backgroundColor,
+        xlsxSemanticColorOriginKey(fill.backgroundColorOrigin)
+    ].join(':') : '';
+}
+function isXlsxPatternFillType(value) {
+    return 'string' == typeof value && xlsxPatternFillTypeSet.has(value);
+}
+function work_xlsx_pattern_fill_normalizedColor(value) {
+    const rgb = xlsxRgbColor(value);
+    return rgb ? `#${rgb.slice(-6).toLowerCase()}` : null;
+}
+function work_xlsx_pattern_fill_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const SPREADSHEET_SHOWN_COMMENT_CELLS_PROPERTY = '__a3sShownCommentCells';
+const spreadsheetMatrixProfiles = new WeakMap();
+function freezeImportedSpreadsheetCell(cell) {
+    const gradientFill = cell[XLSX_GRADIENT_FILL_CELL_KEY];
+    if (gradientFill && 'object' == typeof gradientFill) {
+        const stops = gradientFill.stops;
+        if (Array.isArray(stops)) {
+            for (const stop of stops)if (stop && 'object' == typeof stop) {
+                freezeObject(stop.colorOrigin);
+                freezeObject(stop);
+            }
+            Object.freeze(stops);
+        }
+    }
+    freezeObject(gradientFill);
+    const patternFill = cell[XLSX_PATTERN_FILL_CELL_KEY];
+    if (patternFill && 'object' == typeof patternFill) {
+        const record = patternFill;
+        freezeObject(record.foregroundColorOrigin);
+        freezeObject(record.backgroundColorOrigin);
+    }
+    freezeObject(patternFill);
+    freezeObject(cell.mc);
+    freezeObject(cell.ct?.s);
+    freezeObject(cell.ct);
+    freezeObject(cell.ps);
+    freezeObject(cell.hl);
+    freezeObject(cell.spl);
+    return Object.freeze(cell);
+}
+function registerImportedSpreadsheetMatrix(data, options) {
+    data.length = Math.max(data.length, options.rowCount);
+    data[0] ??= [];
+    for (const rowIndex of sparseArrayIndexes(data)){
+        const row = data[rowIndex];
+        if (row) {
+            row.length = Math.max(row.length, options.columnCount);
+            Object.freeze(row);
+        }
+    }
+    registerSpreadsheetMatrixProfile(data, options);
+}
+function registerDerivedSpreadsheetMatrix(data, source, changes) {
+    const sourceProfile = spreadsheetMatrixProfiles.get(source);
+    if (!sourceProfile?.fortuneReady) return false;
+    const formulaCells = new Map(sourceProfile.formulaCells.map(({ column, row })=>[
+            spreadsheetCoordinateKey(row, column),
+            {
+                column,
+                row
+            }
+        ]));
+    const shownCommentCells = new Map(sourceProfile.shownCommentCells.map(({ c, r })=>[
+            spreadsheetCoordinateKey(r, c),
+            {
+                c,
+                r
+            }
+        ]));
+    let populatedCellCount = sourceProfile.populatedCellCount;
+    let protectionCellKey = sourceProfile.protectionCellKey;
+    let protectionCells;
+    for (const { column, current, previous, row } of changes){
+        const coordinateKey = spreadsheetCoordinateKey(row, column);
+        if (null == previous && null != current) populatedCellCount += 1;
+        if (null != previous && null == current) populatedCellCount -= 1;
+        if (current?.f) formulaCells.set(coordinateKey, {
+            column,
+            row
+        });
+        else formulaCells.delete(coordinateKey);
+        if (current?.ps?.isShow) shownCommentCells.set(coordinateKey, {
+            c: column,
+            r: row
+        });
+        else shownCommentCells.delete(coordinateKey);
+        if (spreadsheetProtectionSignature(previous) !== spreadsheetProtectionSignature(current)) {
+            protectionCells ??= spreadsheetProtectionCells(protectionCellKey);
+            const signature = spreadsheetProtectionSignature(current);
+            if (null === signature) protectionCells.delete(coordinateKey);
+            else protectionCells.set(coordinateKey, signature);
+        }
+        const changedRow = data[row];
+        if (changedRow && !Object.isFrozen(changedRow)) Object.freeze(changedRow);
+    }
+    if (protectionCells) protectionCellKey = Array.from(protectionCells, ([coordinate, value])=>({
+            coordinate,
+            value
+        })).sort((left, right)=>compareSpreadsheetCoordinates(left.coordinate, right.coordinate)).map(({ coordinate, value })=>`${coordinate}:${value}`).join(',');
+    registerSpreadsheetMatrixProfile(data, {
+        columnCount: Math.max(sourceProfile.columnCount, ...changes.map(({ column, row })=>Math.max(column + 1, data[row]?.length ?? 0))),
+        formulaCells: Array.from(formulaCells.values()).sort(compareSpreadsheetCells),
+        fortuneReady: true,
+        populatedCellCount: Math.max(0, populatedCellCount),
+        protectionCellKey,
+        rowCount: Math.max(sourceProfile.rowCount, data.length, ...changes.map(({ row })=>row + 1)),
+        shownCommentCells: Array.from(shownCommentCells.values()).sort((left, right)=>left.r - right.r || left.c - right.c)
+    }, {
+        historyRoot: sourceProfile.historyRoot,
+        historyState: changes.some(({ current, previous })=>!sameSpreadsheetHistoryValue(current, previous)) ? Object.freeze({}) : sourceProfile.historyState
+    });
+    return true;
+}
+function spreadsheetMatrixProfile(data) {
+    return data ? spreadsheetMatrixProfiles.get(data) : void 0;
+}
+function attachSpreadsheetShownCommentCells(data, cells) {
+    Object.defineProperty(data, SPREADSHEET_SHOWN_COMMENT_CELLS_PROPERTY, {
+        configurable: false,
+        enumerable: false,
+        value: cells,
+        writable: false
+    });
+}
+function registerSpreadsheetMatrixProfile(data, options, history) {
+    const initialHistoryState = Object.freeze({});
+    const profile = Object.freeze({
+        columnCount: options.columnCount,
+        formulaCells: Object.freeze(options.formulaCells.map((cell)=>Object.freeze({
+                ...cell
+            }))),
+        fortuneReady: options.fortuneReady,
+        historyRoot: history?.historyRoot ?? initialHistoryState,
+        historyState: history?.historyState ?? initialHistoryState,
+        populatedCellCount: options.populatedCellCount,
+        protectionCellKey: options.protectionCellKey,
+        rowCount: options.rowCount,
+        shownCommentCells: Object.freeze(options.shownCommentCells.map((cell)=>Object.freeze({
+                ...cell
+            })))
+    });
+    attachSpreadsheetShownCommentCells(data, profile.shownCommentCells);
+    Object.freeze(data);
+    spreadsheetMatrixProfiles.set(data, profile);
+}
+function spreadsheetProtectionCells(value) {
+    const cells = new Map();
+    for (const entry of value.split(',')){
+        if (!entry) continue;
+        const separator = entry.indexOf(':');
+        if (!(separator <= 0)) cells.set(entry.slice(0, separator), entry.slice(separator + 1));
+    }
+    return cells;
+}
+function spreadsheetProtectionSignature(cell) {
+    const hidden = cell?.hi;
+    if (cell?.lo === void 0 && void 0 === hidden) return null;
+    return `${cell?.lo ?? ''}:${hidden ?? ''}`;
+}
+function spreadsheetCoordinateKey(row, column) {
+    return `${row}_${column}`;
+}
+function compareSpreadsheetCoordinates(left, right) {
+    const [leftRow = 0, leftColumn = 0] = left.split('_').map(Number);
+    const [rightRow = 0, rightColumn = 0] = right.split('_').map(Number);
+    return leftRow - rightRow || leftColumn - rightColumn;
+}
+function compareSpreadsheetCells(left, right) {
+    return left.row - right.row || left.column - right.column;
+}
+function freezeObject(value) {
+    if (value && 'object' == typeof value) Object.freeze(value);
+}
+const DEFAULT_PROTECTION_HINT = '此工作表已受保护。若要更改锁定的单元格，请先取消工作表保护。';
+function defaultSheetProtectionAuthority(enabled = false) {
+    return {
+        sheet: enabled ? 1 : 0,
+        selectLockedCells: 1,
+        selectunLockedCells: 1,
+        formatCells: 0,
+        formatColumns: 0,
+        formatRows: 0,
+        insertColumns: 0,
+        insertRows: 0,
+        insertHyperlinks: 0,
+        deleteColumns: 0,
+        deleteRows: 0,
+        sort: 0,
+        filter: 0,
+        usePivotTablereports: 0,
+        editObjects: 0,
+        editScenarios: 0,
+        hintText: '',
+        defaultSheetHintText: DEFAULT_PROTECTION_HINT,
+        allowRangeList: [],
+        cellProtectionRanges: []
+    };
+}
+function sheetProtectionAuthority(sheet) {
+    return normalizeSheetProtectionAuthority(sheet.config?.authority);
+}
+function normalizeSheetProtectionAuthority(source) {
+    const defaults = defaultSheetProtectionAuthority();
+    if (!source || 'object' != typeof source) return defaults;
+    const authority = source;
+    return {
+        sheet: flag(authority.sheet, defaults.sheet),
+        selectLockedCells: flag(authority.selectLockedCells, defaults.selectLockedCells),
+        selectunLockedCells: flag(authority.selectunLockedCells, defaults.selectunLockedCells),
+        formatCells: flag(authority.formatCells, defaults.formatCells),
+        formatColumns: flag(authority.formatColumns, defaults.formatColumns),
+        formatRows: flag(authority.formatRows, defaults.formatRows),
+        insertColumns: flag(authority.insertColumns, defaults.insertColumns),
+        insertRows: flag(authority.insertRows, defaults.insertRows),
+        insertHyperlinks: flag(authority.insertHyperlinks, defaults.insertHyperlinks),
+        deleteColumns: flag(authority.deleteColumns, defaults.deleteColumns),
+        deleteRows: flag(authority.deleteRows, defaults.deleteRows),
+        sort: flag(authority.sort, defaults.sort),
+        filter: flag(authority.filter, defaults.filter),
+        usePivotTablereports: flag(authority.usePivotTablereports, defaults.usePivotTablereports),
+        editObjects: flag(authority.editObjects, defaults.editObjects),
+        editScenarios: flag(authority.editScenarios, defaults.editScenarios),
+        hintText: stringValue(authority.hintText),
+        defaultSheetHintText: stringValue(authority.defaultSheetHintText) || DEFAULT_PROTECTION_HINT,
+        allowRangeList: editableRangeList(authority.allowRangeList),
+        cellProtectionRanges: cellProtectionRangeList(authority.cellProtectionRanges),
+        xlsxAttributes: stringRecord(authority.xlsxAttributes)
+    };
+}
+function importedSheetProtectionAuthority(authority, cellProtectionRanges) {
+    if (!authority && !cellProtectionRanges.length) return;
+    const normalized = normalizeSheetProtectionAuthority(authority);
+    normalized.cellProtectionRanges = [
+        ...cellProtectionRanges,
+        ...normalized.allowRangeList.filter((range)=>!editableRangeRequiresCredentials(range)).flatMap((range)=>work_spreadsheet_ranges_parseSpreadsheetCellRanges(range.sqref) ?? []).map((range)=>({
+                range,
+                locked: false,
+                hidden: false
+            }))
+    ];
+    return normalized;
+}
+function withSheetProtection(sheet, enabled) {
+    const authority = sheetProtectionAuthority(sheet);
+    authority.sheet = enabled ? 1 : 0;
+    return withAuthority(sheet, authority);
+}
+function withSheetSelectionPermissions(sheet, permissions) {
+    const authority = sheetProtectionAuthority(sheet);
+    if (void 0 !== permissions.selectLockedCells) authority.selectLockedCells = permissions.selectLockedCells ? 1 : 0;
+    if (void 0 !== permissions.selectUnlockedCells) authority.selectunLockedCells = permissions.selectUnlockedCells ? 1 : 0;
+    return withAuthority(sheet, authority);
+}
+function withEditableRange(sheet, index, editableRange) {
+    const authority = sheetProtectionAuthority(sheet);
+    const nextRange = {
+        name: editableRange.name.trim(),
+        sqref: canonicalRangeReference(editableRange.sqref),
+        hintText: editableRange.hintText?.trim() || void 0,
+        xlsxAttributes: editableRange.xlsxAttributes
+    };
+    if (null !== index && authority.allowRangeList[index]) authority.allowRangeList[index] = nextRange;
+    else authority.allowRangeList.push(nextRange);
+    const ranges = work_spreadsheet_ranges_parseSpreadsheetCellRanges(nextRange.sqref) ?? [];
+    const next = withCellProtection(sheet, ranges, false);
+    const nextAuthority = sheetProtectionAuthority(next);
+    nextAuthority.allowRangeList = authority.allowRangeList;
+    return withAuthority(next, nextAuthority);
+}
+function withoutEditableRange(sheet, index) {
+    const authority = sheetProtectionAuthority(sheet);
+    const removed = authority.allowRangeList[index];
+    if (!removed) return sheet;
+    authority.allowRangeList.splice(index, 1);
+    const removedRanges = work_spreadsheet_ranges_parseSpreadsheetCellRanges(removed.sqref) ?? [];
+    let next = withCellProtection(sheet, removedRanges, true);
+    for (const editableRange of authority.allowRangeList)if (!editableRangeRequiresCredentials(editableRange)) next = withCellProtection(next, work_spreadsheet_ranges_parseSpreadsheetCellRanges(editableRange.sqref) ?? [], false);
+    const nextAuthority = sheetProtectionAuthority(next);
+    nextAuthority.allowRangeList = authority.allowRangeList;
+    return withAuthority(next, nextAuthority);
+}
+function withCellProtection(sheet, ranges, locked, hidden = false) {
+    if (!ranges.length) return sheet;
+    const data = cloneSparseMatrix(sheet.data);
+    let rowCount = Math.max(sheet.row ?? 0, data.length);
+    let columnCount = Math.max(sheet.column ?? 0, sparseMatrixColumnCount(data));
+    for (const range of ranges){
+        rowCount = Math.max(rowCount, range.row[1] + 1);
+        columnCount = Math.max(columnCount, range.column[1] + 1);
+        for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(data))if (!(row < range.row[0]) && !(row > range.row[1])) for (const [column, source] of spreadsheet_sparse_sparseArrayEntries(values)){
+            if (column < range.column[0] || column > range.column[1]) continue;
+            const cell = {
+                ...source ?? {}
+            };
+            cell.lo = locked ? 1 : 0;
+            if (hidden) cell.hi = 1;
+            else if (void 0 !== cell.hi) delete cell.hi;
+            data[row][column] = cell;
+        }
+    }
+    normalizeMatrix(data, rowCount, columnCount);
+    const authority = sheetProtectionAuthority(sheet);
+    authority.cellProtectionRanges.push(...ranges.map((range)=>({
+            range,
+            locked,
+            hidden
+        })));
+    return withAuthority({
+        ...sheet,
+        row: rowCount,
+        column: columnCount,
+        data
+    }, authority);
+}
+function editableRangeRequiresCredentials(range) {
+    const attributes = range.xlsxAttributes ?? {};
+    return Boolean(attributes.password || attributes.hashValue || attributes.saltValue || attributes.securityDescriptor || attributes.securitydescriptor);
+}
+function sheetHasProtectionState(sheet) {
+    const authority = sheetProtectionAuthority(sheet);
+    if (1 === authority.sheet || authority.allowRangeList.length || Object.keys(authority.xlsxAttributes ?? {}).length) return true;
+    return (sheet.data ?? []).some((row)=>row.some((cell)=>cell?.lo !== void 0 || cell?.hi !== void 0));
+}
+function protectedSheetCount(sheets) {
+    return sheets.filter((sheet)=>1 === sheetProtectionAuthority(sheet).sheet).length;
+}
+function unlockedCellCount(sheet) {
+    return (sheet.data ?? []).reduce((total, row)=>total + row.reduce((rowTotal, cell)=>rowTotal + (cell?.lo === 0 ? 1 : 0), 0), 0);
+}
+function spreadsheetProtectionKey(sheets) {
+    return sheets.map((sheet)=>{
+        const authority = sheetProtectionAuthority(sheet);
+        const profile = spreadsheetMatrixProfile(sheet.data);
+        let protectionCellKey = profile?.protectionCellKey;
+        if (void 0 === protectionCellKey) {
+            const cells = [];
+            for (const [row, values] of spreadsheet_sparse_sparseArrayEntries(sheet.data))for (const [column, cell] of spreadsheet_sparse_sparseArrayEntries(values)){
+                const hidden = cell?.hi;
+                if (cell?.lo !== void 0 || void 0 !== hidden) cells.push(`${row}_${column}:${cell?.lo ?? ''}:${hidden ?? ''}`);
+            }
+            protectionCellKey = cells.join(',');
+        }
+        return `${sheet.id ?? sheet.name}:${JSON.stringify(authority)}:${protectionCellKey}`;
+    }).join('|');
+}
+function editableRangeCellCount(ranges) {
+    return ranges.reduce((total, range)=>total + (range.row[1] - range.row[0] + 1) * (range.column[1] - range.column[0] + 1), 0);
+}
+function withAuthority(sheet, authority) {
+    return {
+        ...sheet,
+        config: {
+            ...sheet.config ?? {},
+            authority
+        }
+    };
+}
+function editableRangeList(value) {
+    if (!Array.isArray(value)) return [];
+    return value.flatMap((item, index)=>{
+        if (!item || 'object' != typeof item) return [];
+        const range = item;
+        const sqref = stringValue(range.sqref);
+        if (!sqref || !work_spreadsheet_ranges_parseSpreadsheetCellRanges(sqref)) return [];
+        return [
+            {
+                name: stringValue(range.name) || `Range ${index + 1}`,
+                sqref: canonicalRangeReference(sqref),
+                hintText: stringValue(range.hintText) || void 0,
+                xlsxAttributes: stringRecord(range.xlsxAttributes)
+            }
+        ];
+    });
+}
+function canonicalRangeReference(value) {
+    const ranges = work_spreadsheet_ranges_parseSpreadsheetCellRanges(value);
+    return ranges ? formatSpreadsheetCellRanges(ranges) : value.trim();
+}
+function normalizeMatrix(data, rows, columns) {
+    data.length = Math.max(data.length, rows);
+    for (const [, row] of spreadsheet_sparse_sparseArrayEntries(data))row.length = Math.max(row.length, columns);
+}
+function cellProtectionRangeList(value) {
+    if (!Array.isArray(value)) return [];
+    return value.flatMap((item)=>{
+        if (!item || 'object' != typeof item) return [];
+        const candidate = item;
+        const range = candidate.range;
+        if (!range || !Array.isArray(range.row) || !Array.isArray(range.column) || range.row.length < 2 || range.column.length < 2 || ![
+            ...range.row,
+            ...range.column
+        ].every((index)=>Number.isSafeInteger(index) && index >= 0)) return [];
+        return [
+            {
+                range: {
+                    row: [
+                        Math.min(range.row[0], range.row[1]),
+                        Math.max(range.row[0], range.row[1])
+                    ],
+                    column: [
+                        Math.min(range.column[0], range.column[1]),
+                        Math.max(range.column[0], range.column[1])
+                    ]
+                },
+                locked: false !== candidate.locked,
+                hidden: true === candidate.hidden
+            }
+        ];
+    });
+}
+function flag(value, fallback) {
+    if (1 === value || true === value || '1' === value) return 1;
+    if (0 === value || false === value || '0' === value) return 0;
+    return fallback;
+}
+function stringValue(value) {
+    return 'string' == typeof value ? value : '';
+}
+function stringRecord(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return;
+    const entries = Object.entries(value).filter((entry)=>'string' == typeof entry[1]);
+    return entries.length ? Object.fromEntries(entries) : void 0;
+}
+const SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS = [
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'equal',
+    'notEqual',
+    'between',
+    'notBetween'
+];
+function isSpreadsheetConditionalComparisonOperator(value) {
+    return SPREADSHEET_CONDITIONAL_COMPARISON_OPERATORS.some((operator)=>operator === value);
+}
+function spreadsheetConditionalComparisonNeedsUpperValue(operator) {
+    return 'between' === operator || 'notBetween' === operator;
+}
+const DEFAULT_DATA_BAR_MIN_LENGTH = 10;
+const DEFAULT_DATA_BAR_MAX_LENGTH = 90;
+function defaultSpreadsheetColorScaleThresholds(colorCount) {
+    return 3 === colorCount ? [
+        {
+            type: 'min'
+        },
+        {
+            type: 'percentile',
+            value: 50
+        },
+        {
+            type: 'max'
+        }
+    ] : [
+        {
+            type: 'min'
+        },
+        {
+            type: 'max'
+        }
+    ];
+}
+function defaultSpreadsheetDataBarOptions() {
+    return {
+        thresholds: [
+            {
+                type: 'min'
+            },
+            {
+                type: 'max'
+            }
+        ],
+        showValue: true,
+        minLength: DEFAULT_DATA_BAR_MIN_LENGTH,
+        maxLength: DEFAULT_DATA_BAR_MAX_LENGTH
+    };
+}
+function normalizeSpreadsheetConditionalThreshold(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (![
+        'min',
+        'max',
+        'num',
+        'percent',
+        'percentile'
+    ].includes(String(source.type))) return null;
+    const type = source.type;
+    if ('min' === type || 'max' === type) return {
+        type
+    };
+    if ('number' != typeof source.value || !Number.isFinite(source.value)) return null;
+    return {
+        type,
+        value: source.value
+    };
+}
+function normalizeSpreadsheetConditionalVisualOptions(value, expectedThresholdCount, kind) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (!Array.isArray(source.thresholds) || source.thresholds.length !== expectedThresholdCount) return null;
+    const thresholds = source.thresholds.map(normalizeSpreadsheetConditionalThreshold);
+    if (thresholds.some((threshold)=>!threshold)) return null;
+    if ('colorScale' === kind) return {
+        thresholds: thresholds
+    };
+    const minLength = source.minLength ?? DEFAULT_DATA_BAR_MIN_LENGTH;
+    const maxLength = source.maxLength ?? DEFAULT_DATA_BAR_MAX_LENGTH;
+    if ('number' != typeof minLength || !Number.isFinite(minLength) || minLength < 0 || minLength > 100 || 'number' != typeof maxLength || !Number.isFinite(maxLength) || maxLength < 0 || maxLength > 100 || minLength > maxLength) return null;
+    return {
+        thresholds: thresholds,
+        showValue: false !== source.showValue,
+        minLength,
+        maxLength
+    };
+}
+function spreadsheetConditionalThresholdValue(threshold, sourceValues) {
+    const values = sourceValues.filter(Number.isFinite).sort((left, right)=>left - right);
+    if (!values.length) return null;
+    const minimum = values[0];
+    const maximum = values.at(-1);
+    if ('min' === threshold.type) return minimum;
+    if ('max' === threshold.type) return maximum;
+    if ('num' === threshold.type) return threshold.value ?? null;
+    const percentage = threshold.value;
+    if (void 0 === percentage || !Number.isFinite(percentage)) return null;
+    if ('percent' === threshold.type) return minimum + (maximum - minimum) * percentage / 100;
+    const position = Math.max(0, Math.min(100, percentage)) / 100 * (values.length - 1);
+    const lower = Math.floor(position);
+    const upper = Math.ceil(position);
+    if (lower === upper) return values[lower];
+    return values[lower] + (values[upper] - values[lower]) * (position - lower);
+}
+function spreadsheetConditionalThresholdsEqual(left, right) {
+    return left.length === right.length && left.every((threshold, index)=>threshold.type === right[index]?.type && threshold.value === right[index]?.value);
+}
+const SPREADSHEET_CONDITIONAL_ICON_SETS = [
+    {
+        name: '3Arrows',
+        label: '三向彩色箭头',
+        count: 3
+    },
+    {
+        name: '3ArrowsGray',
+        label: '三向灰色箭头',
+        count: 3
+    },
+    {
+        name: '3Flags',
+        label: '三色旗帜',
+        count: 3
+    },
+    {
+        name: '3TrafficLights1',
+        label: '三色交通灯（实心）',
+        count: 3
+    },
+    {
+        name: '3TrafficLights2',
+        label: '三色交通灯（边框）',
+        count: 3
+    },
+    {
+        name: '3Signs',
+        label: '三色标志',
+        count: 3
+    },
+    {
+        name: '3Symbols',
+        label: '三色符号（圆形）',
+        count: 3
+    },
+    {
+        name: '3Symbols2',
+        label: '三色符号',
+        count: 3
+    },
+    {
+        name: '4Arrows',
+        label: '四向彩色箭头',
+        count: 4
+    },
+    {
+        name: '4ArrowsGray',
+        label: '四向灰色箭头',
+        count: 4
+    },
+    {
+        name: '4RedToBlack',
+        label: '红到黑圆点',
+        count: 4
+    },
+    {
+        name: '4Rating',
+        label: '四级评分',
+        count: 4
+    },
+    {
+        name: '4TrafficLights',
+        label: '四色交通灯',
+        count: 4
+    },
+    {
+        name: '5Arrows',
+        label: '五向彩色箭头',
+        count: 5
+    },
+    {
+        name: '5ArrowsGray',
+        label: '五向灰色箭头',
+        count: 5
+    },
+    {
+        name: '5Rating',
+        label: '五级评分',
+        count: 5
+    },
+    {
+        name: '5Quarters',
+        label: '五级圆饼',
+        count: 5
+    }
+];
+const COLOR_3 = [
+    '#c62828',
+    '#f9a825',
+    '#2e7d32'
+];
+const COLOR_4 = [
+    '#c62828',
+    '#ef6c00',
+    '#7cb342',
+    '#2e7d32'
+];
+const COLOR_5 = [
+    '#c62828',
+    '#ef6c00',
+    '#f9a825',
+    '#7cb342',
+    '#2e7d32'
+];
+function isSpreadsheetConditionalIconSetName(value) {
+    return SPREADSHEET_CONDITIONAL_ICON_SETS.some((item)=>item.name === value);
+}
+function spreadsheetConditionalIconSetCount(iconSet) {
+    return SPREADSHEET_CONDITIONAL_ICON_SETS.find((item)=>item.name === iconSet).count;
+}
+function defaultSpreadsheetConditionalIconThresholds(iconSet) {
+    const count = spreadsheetConditionalIconSetCount(iconSet);
+    return Array.from({
+        length: count
+    }, (_, index)=>0 === index ? {
+            type: 'min',
+            gte: true
+        } : {
+            type: 'percent',
+            value: Math.round(100 * index / count),
+            gte: true
+        });
+}
+function normalizeSpreadsheetConditionalIconSetFormat(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    if (!isSpreadsheetConditionalIconSetName(source.iconSet) || !Array.isArray(source.thresholds)) return null;
+    const count = spreadsheetConditionalIconSetCount(source.iconSet);
+    if (source.thresholds.length !== count) return null;
+    const thresholds = source.thresholds.map(normalizeThreshold);
+    if (thresholds.some((threshold)=>!threshold)) return null;
+    return {
+        iconSet: source.iconSet,
+        showValue: false !== source.showValue,
+        reverse: true === source.reverse,
+        percent: false !== source.percent,
+        thresholds: thresholds
+    };
+}
+function spreadsheetConditionalIconForValue(sourceFormat, value, sourceValues) {
+    const format = normalizeSpreadsheetConditionalIconSetFormat(sourceFormat);
+    const values = sourceValues.filter(Number.isFinite);
+    if (!format || !Number.isFinite(value) || !values.length) return null;
+    const count = spreadsheetConditionalIconSetCount(format.iconSet);
+    let level = 0;
+    for(let index = 1; index < count; index += 1){
+        const threshold = format.thresholds[index];
+        const cutoff = spreadsheetConditionalThresholdValue(threshold, values);
+        if (null === cutoff) return null;
+        if (threshold.gte ? value >= cutoff : value > cutoff) level = index;
+    }
+    return {
+        iconSet: format.iconSet,
+        index: format.reverse ? count - 1 - level : level,
+        count,
+        showValue: format.showValue
+    };
+}
+function spreadsheetConditionalIconAppearance(icon) {
+    const index = Math.max(0, Math.min(icon.count - 1, icon.index));
+    const definition = SPREADSHEET_CONDITIONAL_ICON_SETS.find((item)=>item.name === icon.iconSet);
+    const label = `${definition.label} ${index + 1}/${icon.count}`;
+    if (icon.iconSet.includes('Arrows')) {
+        const glyphs = 3 === icon.count ? [
+            '↓',
+            '→',
+            '↑'
+        ] : 4 === icon.count ? [
+            '↓',
+            '↘',
+            '↗',
+            '↑'
+        ] : [
+            '↓',
+            '↘',
+            '→',
+            '↗',
+            '↑'
+        ];
+        return {
+            glyph: glyphs[index],
+            color: icon.iconSet.includes('Gray') ? '#606a78' : work_spreadsheet_conditional_icons_palette(icon.count)[index],
+            label
+        };
+    }
+    if ('3Flags' === icon.iconSet) return {
+        glyph: '⚑',
+        color: COLOR_3[index],
+        label
+    };
+    if (icon.iconSet.includes('TrafficLights')) return {
+        glyph: '3TrafficLights2' === icon.iconSet ? '◉' : '●',
+        color: work_spreadsheet_conditional_icons_palette(icon.count)[index],
+        label
+    };
+    if ('3Signs' === icon.iconSet) return {
+        glyph: [
+            '◆',
+            '▲',
+            '●'
+        ][index],
+        color: COLOR_3[index],
+        label
+    };
+    if ('3Symbols' === icon.iconSet || '3Symbols2' === icon.iconSet) return {
+        glyph: [
+            '✕',
+            '!',
+            '✓'
+        ][index],
+        color: COLOR_3[index],
+        label
+    };
+    if ('4RedToBlack' === icon.iconSet) return {
+        glyph: '●',
+        color: [
+            '#c62828',
+            '#e45b4f',
+            '#697386',
+            '#111827'
+        ][index],
+        label
+    };
+    if ('4Rating' === icon.iconSet) return {
+        glyph: [
+            '▁',
+            '▃',
+            '▆',
+            '█'
+        ][index],
+        color: '#54708f',
+        label
+    };
+    if ('5Rating' === icon.iconSet) return {
+        glyph: [
+            '▁',
+            '▂',
+            '▄',
+            '▆',
+            '█'
+        ][index],
+        color: '#54708f',
+        label
+    };
+    return {
+        glyph: [
+            '○',
+            '◔',
+            '◑',
+            '◕',
+            '●'
+        ][index],
+        color: '#54708f',
+        label
+    };
+}
+function drawSpreadsheetConditionalIcon(context, bounds, icon, background, maskValue = !icon.showValue) {
+    const width = bounds.endX - bounds.startX;
+    const height = bounds.endY - bounds.startY;
+    if (width < 6 || height < 6) return;
+    const appearance = spreadsheetConditionalIconAppearance(icon);
+    context.save();
+    context.beginPath();
+    context.rect(bounds.startX + 1, bounds.startY + 1, Math.max(0, width - 3), Math.max(0, height - 3));
+    context.clip();
+    if (maskValue) {
+        context.fillStyle = background;
+        context.fillRect(bounds.startX + 1, bounds.startY + 1, Math.max(0, width - 3), Math.max(0, height - 3));
+    }
+    const size = Math.max(9, Math.min(16, height - 5));
+    context.fillStyle = appearance.color;
+    context.font = `700 ${size}px "Arial Unicode MS", "Segoe UI Symbol", sans-serif`;
+    context.textAlign = 'left';
+    context.textBaseline = 'middle';
+    context.fillText(appearance.glyph, bounds.startX + 4, bounds.startY + height / 2);
+    context.restore();
+}
+function normalizeThreshold(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const source = value;
+    const threshold = normalizeSpreadsheetConditionalThreshold(source);
+    return threshold ? {
+        ...threshold,
+        gte: false !== source.gte
+    } : null;
+}
+function work_spreadsheet_conditional_icons_palette(count) {
+    if (3 === count) return COLOR_3;
+    if (4 === count) return COLOR_4;
+    return COLOR_5;
+}
+function effectiveSpreadsheetHeaderFooterSections(sections) {
+    return {
+        left: sections?.left ?? '',
+        center: sections?.center ?? '',
+        right: sections?.right ?? ''
+    };
+}
+const DEFAULT_MARGINS = {
+    top: 19.05,
+    right: 17.78,
+    bottom: 19.05,
+    left: 17.78,
+    header: 7.62,
+    footer: 7.62
+};
+const PAPER_DIMENSIONS = {
+    a3: {
+        width: 297,
+        height: 420
+    },
+    a4: {
+        width: 210,
+        height: 297
+    },
+    a5: {
+        width: 148,
+        height: 210
+    },
+    letter: {
+        width: 215.9,
+        height: 279.4
+    },
+    legal: {
+        width: 215.9,
+        height: 355.6
+    },
+    tabloid: {
+        width: 279.4,
+        height: 431.8
+    }
+};
+PAPER_DIMENSIONS.a4.height, DEFAULT_MARGINS.left, DEFAULT_MARGINS.right;
+PAPER_DIMENSIONS.a4.width, DEFAULT_MARGINS.top, DEFAULT_MARGINS.bottom;
+function effectiveSpreadsheetPageSetup(pageSetup) {
+    return {
+        paperSize: normalizeSpreadsheetPaperSize(pageSetup?.paperSize),
+        orientation: pageSetup?.orientation === 'portrait' ? 'portrait' : 'landscape',
+        scale: work_spreadsheet_page_setup_boundedInteger(pageSetup?.scale, 10, 400, 100),
+        fitToPage: Boolean(pageSetup?.fitToPage),
+        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: 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: 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)
+        }
+    };
+}
+function normalizeSpreadsheetPaperSize(value) {
+    switch(value){
+        case 'a3':
+        case 'a4':
+        case 'a5':
+        case 'letter':
+        case 'legal':
+        case 'tabloid':
+            return value;
+        default:
+            return 'a4';
+    }
+}
+function work_spreadsheet_page_setup_boundedInteger(value, minimum, maximum, fallback) {
+    return Math.trunc(work_spreadsheet_page_setup_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, XLSX_GRADIENT_FILL_CELL_KEY, XLSX_PATTERN_FILL_CELL_KEY, activeXlsxGradientFill, activeXlsxPatternFill, applyXlsxSemanticColorOrigin, attachSpreadsheetShownCommentCells, createXlsxColorResolver, decodeXlsxCellAddress, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, defaultXlsxBorder, defaultXlsxFill, deleteXlsxGradientFill, deleteXlsxPatternFill, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, ensureXlsxStyleCollection, freezeImportedSpreadsheetCell, importedSheetProtectionAuthority, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetPaperSize, normalizeXlsxGradientFill, normalizeXlsxPatternFill, normalizeXlsxSemanticColorOrigin, prepareXlsxSemanticPalette, protectedSheetCount, readXlsxGradientFill, readXlsxPatternFill, readXlsxSemanticColorOrigin, registerDerivedSpreadsheetMatrix, registerImportedSpreadsheetMatrix, resolveXlsxColor, sameSpreadsheetHistoryValue, setXlsxBorderLine, setXlsxColorChild, setXlsxToggleChild, setXlsxUnderlineChild, setXlsxValueChild, sheetHasProtectionState, sheetProtectionAuthority, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetMatrixProfile, spreadsheetProtectionKey, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withXlsxCellStyleOrigin, withXlsxGradientFill, withXlsxPatternFill, withoutEditableRange, writeXlsxAlignment, xlsxCellAddress, xlsxCellStyleOrigin, xlsxCellStyleOriginSemanticColors, xlsxColorElementMatchesOrigin, xlsxGradientFillFallbackColor, xlsxGradientFillKey, xlsxGradientFillSemanticColors, xlsxPatternFillKey, xlsxPatternFillSemanticColors, xlsxPatternFillTypes, xlsxRgbColor, xlsxSemanticColorMatchesValue, xlsxSemanticColorOriginKey, xlsxSemanticColorOriginSupported, xlsxWorksheetCellEntries };