@a3s-lab/office 0.36.0 → 0.37.0

package/dist/3266.js

@@ -173,6 +173,340 @@ function nearestSpreadsheetTableCell(sheet, table, row, column) {
     }
     return null;
 }
+const MAX_SPREADSHEET_TABLE_TOTALS_FORMULA_LENGTH = 8192;
+const MAX_SPREADSHEET_TABLE_TOTALS_LABEL_LENGTH = 255;
+const DEFAULT_SPREADSHEET_TABLE_TOTALS_LABEL = 'Total';
+const SPREADSHEET_TABLE_TOTALS_FUNCTIONS = Object.freeze([
+    'sum',
+    'average',
+    'count',
+    'countNums',
+    'max',
+    'min',
+    'stdDev',
+    'stdDevP',
+    'var',
+    'varP',
+    'custom'
+]);
+const UNSAFE_TOTALS_FUNCTIONS = new Set([
+    'CALL',
+    'DDE',
+    'DDE.REQUEST',
+    'DDE.POKE',
+    'EXEC',
+    'HYPERLINK',
+    'INDIRECT',
+    'OFFSET',
+    'REGISTER.ID',
+    'RTD',
+    'WEBSERVICE'
+]);
+const SUBTOTAL_CODES = {
+    average: 101,
+    count: 103,
+    countNums: 102,
+    max: 104,
+    min: 105,
+    stdDev: 107,
+    stdDevP: 108,
+    sum: 109,
+    var: 110,
+    varP: 111
+};
+const OOXML_TOTALS_FUNCTIONS = {
+    average: 'average',
+    count: 'count',
+    countNums: 'countNums',
+    max: 'max',
+    min: 'min',
+    stdDev: 'stdDev',
+    stdDevP: 'stdDevp',
+    sum: 'sum',
+    var: 'var',
+    varP: 'varp'
+};
+const TOTALS_FUNCTION_LABELS = {
+    sum: '求和',
+    average: '平均值',
+    count: '计数',
+    countNums: '数值计数',
+    max: '最大值',
+    min: '最小值',
+    stdDev: '标准差',
+    stdDevP: '总体标准差',
+    var: '方差',
+    varP: '总体方差',
+    custom: '自定义'
+};
+function spreadsheetTableTotalsFunctionLabel(value) {
+    return value ? TOTALS_FUNCTION_LABELS[value] : '不汇总';
+}
+function normalizeSpreadsheetTableTotalsFunction(value) {
+    if ('string' != typeof value) return;
+    if ('none' === value || '' === value) return;
+    return SPREADSHEET_TABLE_TOTALS_FUNCTIONS.includes(value) ? value : void 0;
+}
+function normalizeSpreadsheetTableTotalsFormula(value) {
+    if ('string' != typeof value) return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    const formula = trimmed.startsWith('=') ? trimmed : `=${trimmed}`;
+    if (formula.startsWith('==') || formula.length > MAX_SPREADSHEET_TABLE_TOTALS_FORMULA_LENGTH || /[\u0000-\u001f\u007f]/u.test(formula) || formulaHasExternalReference(formula) || spreadsheetFormulaFunctions(formula).some((name)=>UNSAFE_TOTALS_FUNCTIONS.has(name))) return;
+    const editable = editableSpreadsheetFormula(formula).trim();
+    return editable || void 0;
+}
+function normalizeSpreadsheetTableTotalsLabel(value) {
+    if ('string' != typeof value) return;
+    const label = value.trim();
+    if (!label || Array.from(label).length > MAX_SPREADSHEET_TABLE_TOTALS_LABEL_LENGTH || /[\u0000-\u001f\u007f]/u.test(label)) return;
+    return label;
+}
+function spreadsheetTableTotalsFunctionFromOoxml(value) {
+    if ('string' != typeof value) return;
+    const normalized = value.trim().toLowerCase();
+    if ('custom' === normalized) return 'custom';
+    const entry = Object.entries(OOXML_TOTALS_FUNCTIONS).find(([, token])=>token.toLowerCase() === normalized);
+    return entry?.[0];
+}
+function spreadsheetTableTotalsFunctionToOoxml(value) {
+    if (!value || 'custom' === value) return 'custom' === value ? 'custom' : void 0;
+    return OOXML_TOTALS_FUNCTIONS[value];
+}
+function spreadsheetTableTotalsFormula(table, columnOffset) {
+    const column = table.columns[columnOffset];
+    if (!column) return;
+    const custom = normalizeSpreadsheetTableTotalsFormula(column.totalsFormula);
+    if (custom) return custom;
+    const functionName = normalizeSpreadsheetTableTotalsFunction(column.totalsFunction);
+    if (!functionName || 'custom' === functionName) return;
+    const code = SUBTOTAL_CODES[functionName];
+    if (!code) return;
+    return `=SUBTOTAL(${code},${table.name}[${escapeStructuredColumnName(column.name)}])`;
+}
+function spreadsheetTableTotalsColumnPatch(columns, patches) {
+    if (void 0 === patches) return columns.map((column)=>({
+            ...column
+        }));
+    const entries = Array.isArray(patches) ? patches.flatMap((patch, offset)=>patch ? [
+            [
+                String(offset),
+                patch
+            ]
+        ] : []) : Object.entries(patches);
+    const next = columns.map((column)=>({
+            ...column
+        }));
+    for (const [rawOffset, patch] of entries){
+        const offset = Number(rawOffset);
+        if (!Number.isSafeInteger(offset) || offset < 0 || offset >= next.length || !patch || 'object' != typeof patch || Array.isArray(patch)) return null;
+        const current = next[offset];
+        if (!current) return null;
+        const candidate = {
+            ...current
+        };
+        if (Object.hasOwn(patch, 'totalsFunction')) if (null === patch.totalsFunction || '' === patch.totalsFunction) delete candidate.totalsFunction;
+        else {
+            const functionName = normalizeSpreadsheetTableTotalsFunction(patch.totalsFunction);
+            if (!functionName) return null;
+            candidate.totalsFunction = functionName;
+        }
+        if (Object.hasOwn(patch, 'totalsLabel')) if (null === patch.totalsLabel || '' === patch.totalsLabel) delete candidate.totalsLabel;
+        else {
+            const label = normalizeSpreadsheetTableTotalsLabel(patch.totalsLabel);
+            if (!label) return null;
+            candidate.totalsLabel = label;
+        }
+        if (Object.hasOwn(patch, 'totalsFormula')) if (null === patch.totalsFormula || '' === patch.totalsFormula) delete candidate.totalsFormula;
+        else {
+            const formula = normalizeSpreadsheetTableTotalsFormula(patch.totalsFormula);
+            if (!formula) return null;
+            candidate.totalsFormula = formula;
+        }
+        if (candidate.totalsFormula) {
+            if (void 0 !== candidate.totalsFunction && 'custom' !== candidate.totalsFunction) return null;
+            candidate.totalsFunction = 'custom';
+        } else if ('custom' === candidate.totalsFunction) return null;
+        if (void 0 !== candidate.totalsFunction && 'custom' !== candidate.totalsFunction) delete candidate.totalsFormula;
+        if (void 0 !== candidate.totalsFunction && candidate.totalsLabel) delete candidate.totalsLabel;
+        next[offset] = candidate;
+    }
+    return next;
+}
+function withDefaultSpreadsheetTableTotalsLabel(columns, totalsRow) {
+    const next = columns.map((column)=>({
+            ...column
+        }));
+    if (!totalsRow || !next.length) return next;
+    const hasExplicitLabel = next.some((column)=>column.totalsLabel);
+    if (hasExplicitLabel) return next;
+    const first = next[0];
+    if (first && !first.totalsFunction && !first.totalsFormula) first.totalsLabel = DEFAULT_SPREADSHEET_TABLE_TOTALS_LABEL;
+    return next;
+}
+function spreadsheetTableTotalsRowHasContent(sheet, table, row = table.totalsRow ? table.range.row[1] : table.range.row[1] + 1) {
+    for(let column = table.range.column[0]; column <= table.range.column[1]; column += 1)if (!spreadsheetTableTotalsCellIsEmpty(spreadsheetTableTotalsCellAt(sheet, row, column))) return true;
+    return false;
+}
+function synchronizeSpreadsheetTableTotalsRow(sheet, previousTable, nextTable, options = {}) {
+    if (!nextTable.totalsRow) return sheet;
+    const force = true === options.force;
+    const previousRow = previousTable?.range.row[1];
+    const nextRow = nextTable.range.row[1];
+    const width = nextTable.range.column[1] - nextTable.range.column[0] + 1;
+    const updates = new Map();
+    for(let offset = 0; offset < width; offset += 1){
+        const column = nextTable.range.column[0] + offset;
+        const nextColumn = nextTable.columns[offset];
+        if (!nextColumn) continue;
+        const previousColumn = previousTable?.columns[offset];
+        const oldFormula = previousTable ? spreadsheetTableTotalsFormula(previousTable, offset) : void 0;
+        const newFormula = spreadsheetTableTotalsFormula(nextTable, offset);
+        const oldLabel = normalizeSpreadsheetTableTotalsLabel(previousColumn?.totalsLabel);
+        const newLabel = normalizeSpreadsheetTableTotalsLabel(nextColumn.totalsLabel);
+        const changed = force || void 0 === previousTable || previousTable.name !== nextTable.name || previousTable.range.row[1] !== nextTable.range.row[1] || previousColumn?.totalsFunction !== nextColumn.totalsFunction || previousColumn?.totalsFormula !== nextColumn.totalsFormula || previousColumn?.totalsLabel !== nextColumn.totalsLabel || previousColumn?.name !== nextColumn.name;
+        const current = spreadsheetTableTotalsCellAt(sheet, nextRow, column);
+        const previousCell = void 0 === previousRow ? null : spreadsheetTableTotalsCellAt(sheet, previousRow, column);
+        const styleSource = current ?? previousCell;
+        const empty = spreadsheetTableTotalsCellIsEmpty(current);
+        const currentFormula = normalizeSpreadsheetTableTotalsFormula(current?.f);
+        const generatedFormula = Boolean(oldFormula && currentFormula && formulasEqual(currentFormula, oldFormula));
+        const generatedLabel = Boolean(oldLabel && !current?.f && spreadsheetTableCellText(current) === oldLabel);
+        const replaceable = force || empty || changed && (generatedFormula || generatedLabel);
+        if (newFormula && replaceable) updates.set(column, spreadsheetCellWithTotalsFormula(styleSource, newFormula));
+        else if (newLabel && replaceable) updates.set(column, spreadsheetCellWithTotalsLabel(styleSource, newLabel));
+        else if (!newFormula && !newLabel && changed && (generatedFormula || generatedLabel)) updates.set(column, clearSpreadsheetTableTotalsCell(current));
+    }
+    return applySpreadsheetTableTotalsCellUpdates(sheet, nextRow, updates);
+}
+function reconcileSpreadsheetTableTotalsColumns(sheet, table, editedOffsets) {
+    return table.columns.map((column, offset)=>{
+        const candidate = {
+            ...column
+        };
+        const declaredFunction = normalizeSpreadsheetTableTotalsFunction(candidate.totalsFunction);
+        const declaredFormula = normalizeSpreadsheetTableTotalsFormula(candidate.totalsFormula);
+        if (declaredFunction) candidate.totalsFunction = declaredFunction;
+        else delete candidate.totalsFunction;
+        if (declaredFormula) candidate.totalsFormula = declaredFormula;
+        else delete candidate.totalsFormula;
+        const label = normalizeSpreadsheetTableTotalsLabel(candidate.totalsLabel);
+        if (label) candidate.totalsLabel = label;
+        else delete candidate.totalsLabel;
+        if (!table.totalsRow) return candidate;
+        const cell = spreadsheetTableTotalsCellAt(sheet, table.range.row[1], table.range.column[0] + offset);
+        if (editedOffsets && !editedOffsets.has(offset)) return candidate;
+        const cellFormula = normalizeSpreadsheetTableTotalsFormula(cell?.f);
+        const expected = spreadsheetTableTotalsFormula({
+            ...table,
+            columns: [
+                {
+                    ...candidate
+                }
+            ]
+        }, 0);
+        if (cellFormula) {
+            if (expected && formulasEqual(cellFormula, expected)) return candidate;
+            delete candidate.totalsFunction;
+            delete candidate.totalsFormula;
+            candidate.totalsFunction = 'custom';
+            candidate.totalsFormula = cellFormula;
+            return candidate;
+        }
+        delete candidate.totalsFunction;
+        delete candidate.totalsFormula;
+        const cellLabel = normalizeSpreadsheetTableTotalsLabel(spreadsheetTableCellText(cell));
+        if (cellLabel) if (candidate.totalsLabel && candidate.totalsLabel !== cellLabel) delete candidate.totalsLabel;
+        else candidate.totalsLabel = cellLabel;
+        else delete candidate.totalsLabel;
+        return candidate;
+    });
+}
+function escapeStructuredColumnName(value) {
+    return value.replaceAll(']', ']]');
+}
+function formulasEqual(left, right) {
+    return left.trim().replace(/\s+/g, '').toLocaleLowerCase() === right.trim().replace(/\s+/g, '').toLocaleLowerCase();
+}
+function spreadsheetTableTotalsCellAt(sheet, row, column) {
+    return sheet.data?.[row]?.[column] ?? sheet.celldata?.find((entry)=>entry.r === row && entry.c === column)?.v ?? null;
+}
+function spreadsheetTableTotalsCellIsEmpty(cell) {
+    return !cell?.f && (cell?.v === void 0 || null === cell.v || '' === cell.v) && (cell?.m === void 0 || null === cell.m || '' === cell.m);
+}
+function spreadsheetTableCellText(cell) {
+    const value = cell?.m ?? cell?.v;
+    return null == value ? '' : String(value);
+}
+function spreadsheetCellWithTotalsFormula(source, formula) {
+    const { f: _formula, m: _display, v: _value, ...presentation } = source ?? {};
+    return {
+        ...presentation,
+        f: formula
+    };
+}
+function spreadsheetCellWithTotalsLabel(source, label) {
+    const { f: _formula, ...withoutFormula } = source ?? {};
+    return {
+        ...withoutFormula,
+        m: label,
+        v: label
+    };
+}
+function clearSpreadsheetTableTotalsCell(source) {
+    if (!source) return null;
+    const { f: _formula, m: _display, v: _value, ...presentation } = source;
+    return Object.keys(presentation).length ? presentation : null;
+}
+function applySpreadsheetTableTotalsCellUpdates(sheet, rowIndex, updates) {
+    if (!updates.size) return sheet;
+    if (void 0 !== sheet.data) {
+        const data = sheet.data.slice();
+        const source = data[rowIndex];
+        const row = source ? source.slice() : [];
+        for (const [column, cell] of updates)row[column] = cell;
+        data[rowIndex] = row;
+        return {
+            ...sheet,
+            data
+        };
+    }
+    const entries = [
+        ...sheet.celldata ?? []
+    ];
+    const indexes = new Map(entries.map((entry, index)=>[
+            `${entry.r}:${entry.c}`,
+            index
+        ]));
+    for (const [column, cell] of updates){
+        const key = `${rowIndex}:${column}`;
+        const index = indexes.get(key);
+        if (null === cell) {
+            if (void 0 !== index) entries.splice(index, 1);
+            if (void 0 !== index) {
+                indexes.clear();
+                entries.forEach((entry, nextIndex)=>{
+                    indexes.set(`${entry.r}:${entry.c}`, nextIndex);
+                });
+            }
+            continue;
+        }
+        const entry = {
+            r: rowIndex,
+            c: column,
+            v: cell
+        };
+        if (void 0 === index) {
+            indexes.set(key, entries.length);
+            entries.push(entry);
+        } else entries[index] = entry;
+    }
+    entries.sort((left, right)=>left.r - right.r || left.c - right.c);
+    return {
+        ...sheet,
+        celldata: entries
+    };
+}
 function requiredCoordinate(value, maximum, label, sheetId) {
     if (!Number.isSafeInteger(value) || value < 0 || value >= maximum) invalidWorkOfficeSpreadsheetInput(`a valid ${label} coordinate in sheet '${sheetId}'`);
     return value;
@@ -428,20 +762,46 @@ function requiredSpreadsheetTableColumns(value, width, label) {
         const record = requiredInputRecord(candidate, `${label} column`);
         assertOptionalRecordKeys(record, [
             'name',
-            'calculatedFormula'
+            'calculatedFormula',
+            'totalsFunction',
+            'totalsLabel',
+            'totalsFormula'
         ], `column for ${label}`);
         const name = requiredTableColumnName(record.name, label);
         const normalized = name.toLocaleLowerCase();
         if (names.has(normalized)) invalidWorkOfficeSpreadsheetInput(`unique column names for ${label}`);
         names.add(normalized);
-        if (void 0 === record.calculatedFormula) return {
+        let calculatedFormula;
+        if (void 0 !== record.calculatedFormula) {
+            calculatedFormula = normalizeSpreadsheetTableCalculatedFormula(record.calculatedFormula);
+            if (!calculatedFormula || calculatedFormula !== record.calculatedFormula) invalidWorkOfficeSpreadsheetInput(`a bounded structured calculated-column formula for ${label}`);
+        }
+        const totalsFunction = void 0 === record.totalsFunction ? void 0 : normalizeSpreadsheetTableTotalsFunction(record.totalsFunction);
+        if (void 0 !== record.totalsFunction && (!totalsFunction || totalsFunction !== record.totalsFunction)) invalidWorkOfficeSpreadsheetInput(`a supported totals-row function for ${label}`);
+        const totalsLabel = void 0 === record.totalsLabel ? void 0 : normalizeSpreadsheetTableTotalsLabel(record.totalsLabel);
+        if (void 0 !== record.totalsLabel && (!totalsLabel || totalsLabel !== record.totalsLabel)) invalidWorkOfficeSpreadsheetInput(`a bounded totals-row label for ${label}`);
+        const totalsFormula = void 0 === record.totalsFormula ? void 0 : normalizeSpreadsheetTableTotalsFormula(record.totalsFormula);
+        if (void 0 !== record.totalsFormula && (!totalsFormula || totalsFormula !== record.totalsFormula)) invalidWorkOfficeSpreadsheetInput(`a bounded totals-row formula for ${label}`);
+        if (totalsFormula && 'custom' !== totalsFunction) invalidWorkOfficeSpreadsheetInput(`custom totals-row formulas to declare the custom function for ${label}`);
+        if ('custom' === totalsFunction && !totalsFormula) invalidWorkOfficeSpreadsheetInput(`custom totals-row functions to include a formula for ${label}`);
+        if ((totalsFunction || totalsFormula) && totalsLabel) invalidWorkOfficeSpreadsheetInput(`totals-row labels not to share a cell with a formula for ${label}`);
+        if (!calculatedFormula && !totalsFunction && !totalsLabel && !totalsFormula) return {
             name
         };
-        const calculatedFormula = normalizeSpreadsheetTableCalculatedFormula(record.calculatedFormula);
-        if (!calculatedFormula || calculatedFormula !== record.calculatedFormula) invalidWorkOfficeSpreadsheetInput(`a bounded structured calculated-column formula for ${label}`);
         return {
             name,
-            calculatedFormula
+            ...calculatedFormula ? {
+                calculatedFormula
+            } : {},
+            ...totalsFunction ? {
+                totalsFunction
+            } : {},
+            ...totalsLabel ? {
+                totalsLabel
+            } : {},
+            ...totalsFormula ? {
+                totalsFormula
+            } : {}
         };
     });
 }
@@ -2563,4 +2923,4 @@ function work_xlsx_rich_text_nonNegativeInteger(value) {
 function work_xlsx_rich_text_isRecord(value) {
     return 'object' == typeof value && null !== value && !Array.isArray(value);
 }
-export { activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, fillSpreadsheetTableCalculatedColumns, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetTableCalculatedFormula, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetTableCalculatedColumns, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameXlsxRichTextRunStyle, sheetHasXlsxRichTextCells, spreadsheetCellValueWithDiagonalBorder, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, validXlsxRichText, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };
+export { SPREADSHEET_TABLE_TOTALS_FUNCTIONS, activeXlsxNativeFill, activeXlsxSemanticColorOrigin, applyImportedXlsxRichText, boundedSpreadsheetDataValidationText, coalesceXlsxRichTextRuns, createWorkOfficeSpreadsheetCollaborationBinding as createOfficeSpreadsheetCollaborationBinding, createXlsxRichTextReadContext, deleteXlsxNativeFills, directXlsxAlignment, directXlsxFontStyle, fillSpreadsheetTableCalculatedColumns, hasXlsxDirectFontStyle, initializeWorkOfficeSpreadsheetCollaboration as initializeOfficeSpreadsheetCollaboration, isHighSurrogate, isLowSurrogate, isSpreadsheetTextOrientationId, isSpreadsheetUnderlineStyle, normalizeSpreadsheetDataValidationErrorStyle, normalizeSpreadsheetDateValidationBoundary, normalizeSpreadsheetTableCalculatedFormula, normalizeSpreadsheetTableTotalsFormula, normalizeSpreadsheetTableTotalsLabel, normalizeXlsxRichTextCell, normalizeXlsxRichTextColor, normalizeXlsxRichTextEditSource, normalizeXlsxRichTextRun, patchSpreadsheetRichTextFontRuns, readWorkOfficeSpreadsheetCollaboration as readOfficeSpreadsheetCollaboration, readXlsxRichTextCells, reconcileSpreadsheetTableCalculatedColumns, reconcileSpreadsheetTableTotalsColumns, replaceWorkOfficeSpreadsheetCollaboration as replaceOfficeSpreadsheetCollaboration, sameXlsxRichTextRunStyle, sheetHasXlsxRichTextCells, spreadsheetCellValueWithDiagonalBorder, spreadsheetDateValidationFormula, spreadsheetDiagonalBorderFromCellValue, spreadsheetExplicitTextOrientationFromCell, spreadsheetTableTotalsColumnPatch, spreadsheetTableTotalsFunctionFromOoxml, spreadsheetTableTotalsFunctionLabel, spreadsheetTableTotalsFunctionToOoxml, spreadsheetTableTotalsRowHasContent, spreadsheetTextOrientationCellStyle, spreadsheetTextOrientationChoiceFromCell, spreadsheetTextOrientationFromAngle, spreadsheetTextOrientationFromCell, spreadsheetTextOrientationFromChoice, spreadsheetTextOrientationFromXlsx, spreadsheetUnderlineCellValue, spreadsheetUnderlineCellValueFromSheetJs, spreadsheetUnderlineCellValueFromXlsx, spreadsheetUnderlineStyle, spreadsheetVisibleTextRotationFromCell, synchronizeSpreadsheetTableTotalsRow, validXlsxRichText, withDefaultSpreadsheetTableTotalsLabel, writeXlsxRichTextCells, xlsxAlignmentMatches, xlsxBooleanAttribute, xlsxBorderLineMatches, xlsxColorMatches, xlsxNativeFillCellKeys, xlsxNativeFillKey, xlsxNativeFillSemanticColors, xlsxRichTextCellText, xlsxRichTextStyleOrigins, xlsxStyleCollectionIndex, xlsxToggleEnabled, xlsxUnderlineStyle };