@a3s-lab/office 0.1.0

package/dist/8728.js

@@ -0,0 +1,723 @@
+import { formatSpreadsheetCellRanges, parseSpreadsheetCellRanges } from "./8715.js";
+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: []
+    };
+}
+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),
+        xlsxAttributes: stringRecord(authority.xlsxAttributes)
+    };
+}
+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 = parseSpreadsheetCellRanges(nextRange.sqref) ?? [];
+    return withAuthority(withCellProtection(sheet, ranges, false), authority);
+}
+function withoutEditableRange(sheet, index) {
+    const authority = sheetProtectionAuthority(sheet);
+    const removed = authority.allowRangeList[index];
+    if (!removed) return sheet;
+    authority.allowRangeList.splice(index, 1);
+    const removedRanges = parseSpreadsheetCellRanges(removed.sqref) ?? [];
+    let next = withCellProtection(sheet, removedRanges, true);
+    for (const editableRange of authority.allowRangeList)if (!editableRangeRequiresCredentials(editableRange)) next = withCellProtection(next, parseSpreadsheetCellRanges(editableRange.sqref) ?? [], false);
+    return withAuthority(next, authority);
+}
+function withCellProtection(sheet, ranges, locked, hidden = false) {
+    if (!ranges.length) return sheet;
+    const data = cloneMatrix(sheet.data);
+    let rowCount = Math.max(sheet.row ?? 0, data.length);
+    let columnCount = Math.max(sheet.column ?? 0, ...data.map((row)=>row.length));
+    for (const range of ranges){
+        rowCount = Math.max(rowCount, range.row[1] + 1);
+        columnCount = Math.max(columnCount, range.column[1] + 1);
+        for(let row = range.row[0]; row <= range.row[1]; row += 1){
+            data[row] ??= [];
+            for(let column = range.column[0]; column <= range.column[1]; column += 1){
+                const cell = {
+                    ...data[row][column] ?? {}
+                };
+                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);
+    return {
+        ...sheet,
+        row: rowCount,
+        column: columnCount,
+        data
+    };
+}
+function applySpreadsheetCellProtectionRanges(data, ranges, rowCount, columnCount) {
+    for (const item of ranges){
+        const lastRow = Math.min(item.range.row[1], rowCount - 1);
+        const lastColumn = Math.min(item.range.column[1], columnCount - 1);
+        for(let row = Math.max(0, item.range.row[0]); row <= lastRow; row += 1){
+            data[row] ??= [];
+            for(let column = Math.max(0, item.range.column[0]); column <= lastColumn; column += 1){
+                const cell = {
+                    ...data[row][column] ?? {}
+                };
+                cell.lo = item.locked ? 1 : 0;
+                if (item.hidden) cell.hi = 1;
+                else if (void 0 !== cell.hi) delete cell.hi;
+                data[row][column] = cell;
+            }
+        }
+    }
+}
+function applyPasswordlessEditableRanges(data, ranges, rowCount, columnCount) {
+    const protectionRanges = ranges.filter((range)=>!editableRangeRequiresCredentials(range)).flatMap((range)=>parseSpreadsheetCellRanges(range.sqref) ?? []).map((range)=>({
+            range,
+            locked: false,
+            hidden: false
+        }));
+    applySpreadsheetCellProtectionRanges(data, protectionRanges, rowCount, columnCount);
+}
+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 cells = [];
+        for (const [row, values] of (sheet.data ?? []).entries())for (const [column, cell] of values.entries()){
+            const hidden = cell?.hi;
+            if (cell?.lo !== void 0 || void 0 !== hidden) cells.push(`${row}_${column}:${cell?.lo ?? ''}:${hidden ?? ''}`);
+        }
+        return `${sheet.id ?? sheet.name}:${JSON.stringify(authority)}:${cells.join(',')}`;
+    }).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 || !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 = parseSpreadsheetCellRanges(value);
+    return ranges ? formatSpreadsheetCellRanges(ranges) : value.trim();
+}
+function cloneMatrix(source) {
+    return (source ?? []).map((row)=>[
+            ...row
+        ]);
+}
+function normalizeMatrix(data, rows, columns) {
+    while(data.length < rows)data.push([]);
+    for(let index = 0; index < data.length; index += 1){
+        const row = data[index] ?? [];
+        data[index] = row;
+        while(row.length < columns)row.push(null);
+    }
+}
+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' : 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: 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 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: boundedInteger(pageSetup?.scale, 10, 400, 100),
+        fitToPage: Boolean(pageSetup?.fitToPage),
+        fitToWidth: boundedInteger(pageSetup?.fitToWidth, 0, 32767, 1),
+        fitToHeight: 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),
+        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)
+        }
+    };
+}
+function normalizeSpreadsheetPaperSize(value) {
+    switch(value){
+        case 'a3':
+        case 'a4':
+        case 'a5':
+        case 'letter':
+        case 'legal':
+        case 'tabloid':
+            return value;
+        default:
+            return 'a4';
+    }
+}
+function boundedInteger(value, minimum, maximum, fallback) {
+    return Math.trunc(boundedNumber(value, minimum, maximum, fallback));
+}
+function 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, applyPasswordlessEditableRanges, applySpreadsheetCellProtectionRanges, defaultSpreadsheetColorScaleThresholds, defaultSpreadsheetConditionalIconThresholds, defaultSpreadsheetDataBarOptions, drawSpreadsheetConditionalIcon, editableRangeCellCount, editableRangeRequiresCredentials, effectiveSpreadsheetPageSetup, isSpreadsheetConditionalComparisonOperator, isSpreadsheetConditionalIconSetName, normalizeSheetProtectionAuthority, normalizeSpreadsheetConditionalIconSetFormat, normalizeSpreadsheetConditionalVisualOptions, normalizeSpreadsheetPaperSize, protectedSheetCount, sheetHasProtectionState, sheetProtectionAuthority, spreadsheetConditionalComparisonNeedsUpperValue, spreadsheetConditionalIconForValue, spreadsheetConditionalIconSetCount, spreadsheetConditionalThresholdValue, spreadsheetConditionalThresholdsEqual, spreadsheetProtectionKey, unlockedCellCount, withEditableRange, withSheetProtection, withSheetSelectionPermissions, withoutEditableRange };