@a3s-lab/office 0.1.0

package/dist/0~6552.js

@@ -0,0 +1,787 @@
+import { Extension } from "@tiptap/core";
+import { Table, TableCell, TableHeader, TableRow, TableView } from "@tiptap/extension-table";
+import { NodeSelection, Plugin } from "@tiptap/pm/state";
+import { CellSelection, TableMap, isInTable, selectedRect } from "@tiptap/pm/tables";
+const DOCUMENT_TABLE_STYLE_OPTIONS = [
+    {
+        id: 'grid',
+        label: '网格',
+        headerColor: '#f1f4f9',
+        bodyColor: '#ffffff',
+        alternateColor: '#ffffff',
+        borderColor: '#cfd5df',
+        borderStyle: 'solid',
+        borderWidth: 1
+    },
+    {
+        id: 'blueStripe',
+        label: '蓝色条纹',
+        headerColor: '#d9eaf7',
+        bodyColor: '#ffffff',
+        alternateColor: '#f7fbff',
+        borderColor: '#9fbad0',
+        borderStyle: 'solid',
+        borderWidth: 1
+    },
+    {
+        id: 'greenStripe',
+        label: '绿色条纹',
+        headerColor: '#ddeee7',
+        bodyColor: '#ffffff',
+        alternateColor: '#f4faf7',
+        borderColor: '#abc8be',
+        borderStyle: 'solid',
+        borderWidth: 1
+    },
+    {
+        id: 'grayStripe',
+        label: '灰色条纹',
+        headerColor: '#e7e9ed',
+        bodyColor: '#ffffff',
+        alternateColor: '#f6f7f9',
+        borderColor: '#b9c0ca',
+        borderStyle: 'solid',
+        borderWidth: 1
+    },
+    {
+        id: 'clean',
+        label: '简洁',
+        headerColor: '#f1f4f9',
+        bodyColor: '#ffffff',
+        alternateColor: '#ffffff',
+        borderColor: '#cfd5df',
+        borderStyle: 'none',
+        borderWidth: 0
+    }
+];
+const DEFAULT_DOCUMENT_TABLE_CELL_FORMAT = {
+    backgroundColor: '#ffffff',
+    verticalAlign: 'top',
+    borderColor: '#cfd5df',
+    borderStyle: 'solid',
+    borderWidth: 1
+};
+const DEFAULT_DOCUMENT_TABLE_HEADER_FORMAT = {
+    ...DEFAULT_DOCUMENT_TABLE_CELL_FORMAT,
+    backgroundColor: '#f1f4f9'
+};
+const DocumentTableCell = TableCell.extend({
+    addAttributes () {
+        return {
+            ...this.parent?.(),
+            ...documentTableCellAttributes(DEFAULT_DOCUMENT_TABLE_CELL_FORMAT)
+        };
+    }
+});
+const DocumentTableHeader = TableHeader.extend({
+    addAttributes () {
+        return {
+            ...this.parent?.(),
+            ...documentTableCellAttributes(DEFAULT_DOCUMENT_TABLE_HEADER_FORMAT)
+        };
+    }
+});
+const DocumentTableFormatting = Extension.create({
+    name: 'documentTableFormatting',
+    addCommands () {
+        return {
+            setDocumentTableCellFormat: (format)=>(props)=>setSelectedCellFormat(props, format),
+            setDocumentTableHorizontalAlignment: (alignment)=>(props)=>setSelectedCellAlignment(props, alignment),
+            applyDocumentTableStyle: (style)=>(props)=>applyTableStyle(props, style)
+        };
+    }
+});
+function documentTableCellFormat(state) {
+    const position = selectedTableCellPositions(state.selection)[0];
+    const node = void 0 === position ? null : state.doc.nodeAt(position);
+    return node && isTableCell(node) ? formatFromAttributes(node.attrs) : null;
+}
+function documentTableHorizontalAlignment(state) {
+    const position = selectedTableCellPositions(state.selection)[0];
+    const cell = void 0 === position ? null : state.doc.nodeAt(position);
+    let alignment = 'left';
+    cell?.descendants((node)=>{
+        if ('paragraph' !== node.type.name && 'heading' !== node.type.name) return true;
+        if ('center' === node.attrs.textAlign || 'right' === node.attrs.textAlign) alignment = node.attrs.textAlign;
+        return false;
+    });
+    return alignment;
+}
+function activeDocumentTableStyle(state) {
+    const context = selectedTable(state.selection);
+    if (!context) return null;
+    for (const style of DOCUMENT_TABLE_STYLE_OPTIONS){
+        let matches = true;
+        context.node.forEach((row, _rowOffset, rowIndex)=>{
+            row.forEach((cell)=>{
+                const expected = tableStyleCellFormat(style, cell, rowIndex);
+                const actual = formatFromAttributes(cell.attrs);
+                if (expected.backgroundColor !== actual.backgroundColor || expected.borderColor !== actual.borderColor || expected.borderStyle !== actual.borderStyle || expected.borderWidth !== actual.borderWidth) matches = false;
+            });
+        });
+        if (matches) return style.id;
+    }
+    return null;
+}
+function documentTableCellAttributes(defaults) {
+    return {
+        backgroundColor: {
+            default: defaults.backgroundColor,
+            parseHTML: (element)=>normalizeTableColor(element.dataset.officeCellFill || element.style.backgroundColor) ?? defaults.backgroundColor,
+            renderHTML: (attributes)=>{
+                const color = normalizeTableColor(String(attributes.backgroundColor ?? '')) ?? defaults.backgroundColor;
+                return {
+                    'data-office-cell-fill': color,
+                    style: `background-color: ${color}`
+                };
+            }
+        },
+        verticalAlign: {
+            default: defaults.verticalAlign,
+            parseHTML: (element)=>normalizeDocumentTableVerticalAlign(element.dataset.officeCellVerticalAlign || element.style.verticalAlign) ?? defaults.verticalAlign,
+            renderHTML: (attributes)=>{
+                const alignment = normalizeDocumentTableVerticalAlign(String(attributes.verticalAlign ?? '')) ?? defaults.verticalAlign;
+                return {
+                    'data-office-cell-vertical-align': alignment,
+                    style: `vertical-align: ${alignment}`
+                };
+            }
+        },
+        borderColor: {
+            default: defaults.borderColor,
+            parseHTML: (element)=>normalizeTableColor(element.dataset.officeCellBorderColor || element.style.borderColor) ?? defaults.borderColor,
+            renderHTML: (attributes)=>{
+                const format = formatFromAttributes(attributes, defaults);
+                return {
+                    'data-office-cell-border-color': format.borderColor,
+                    'data-office-cell-border-style': format.borderStyle,
+                    'data-office-cell-border-width': String(format.borderWidth),
+                    style: 'none' === format.borderStyle || 0 === format.borderWidth ? 'border: 0 none transparent' : `border: ${format.borderWidth}px ${format.borderStyle} ${format.borderColor}`
+                };
+            }
+        },
+        borderStyle: {
+            default: defaults.borderStyle,
+            parseHTML: (element)=>normalizeDocumentTableBorderStyle(element.dataset.officeCellBorderStyle || element.style.borderStyle) ?? defaults.borderStyle,
+            renderHTML: ()=>({})
+        },
+        borderWidth: {
+            default: defaults.borderWidth,
+            parseHTML: (element)=>normalizeDocumentTableBorderWidth(element.dataset.officeCellBorderWidth || element.style.borderWidth) ?? defaults.borderWidth,
+            renderHTML: ()=>({})
+        }
+    };
+}
+function setSelectedCellFormat({ dispatch, state }, patch) {
+    const normalized = normalizeFormatPatch(patch);
+    if (!normalized) return false;
+    const positions = selectedTableCellPositions(state.selection);
+    if (!positions.length) return false;
+    const transaction = state.tr;
+    for (const position of positions){
+        const cell = transaction.doc.nodeAt(position);
+        if (cell && isTableCell(cell)) transaction.setNodeMarkup(position, void 0, {
+            ...cell.attrs,
+            ...normalized
+        });
+    }
+    if (dispatch && transaction.docChanged) dispatch(transaction.scrollIntoView());
+    return true;
+}
+function setSelectedCellAlignment({ dispatch, state }, alignment) {
+    if ('left' !== alignment && 'center' !== alignment && 'right' !== alignment) return false;
+    const positions = selectedTableCellPositions(state.selection);
+    if (!positions.length) return false;
+    const transaction = state.tr;
+    for (const position of positions){
+        const cell = transaction.doc.nodeAt(position);
+        if (cell && isTableCell(cell)) cell.descendants((node, offset)=>{
+            if ('paragraph' !== node.type.name && 'heading' !== node.type.name) return true;
+            transaction.setNodeMarkup(position + 1 + offset, void 0, {
+                ...node.attrs,
+                textAlign: alignment
+            });
+            return false;
+        });
+    }
+    if (dispatch && transaction.docChanged) dispatch(transaction.scrollIntoView());
+    return true;
+}
+function applyTableStyle({ dispatch, state }, styleId) {
+    const style = DOCUMENT_TABLE_STYLE_OPTIONS.find((candidate)=>candidate.id === styleId);
+    const context = selectedTable(state.selection);
+    if (!style || !context) return false;
+    const transaction = state.tr;
+    context.node.forEach((row, rowOffset, rowIndex)=>{
+        row.forEach((cell, cellOffset)=>{
+            const position = context.position + 2 + rowOffset + cellOffset;
+            transaction.setNodeMarkup(position, void 0, {
+                ...cell.attrs,
+                ...tableStyleCellFormat(style, cell, rowIndex)
+            });
+        });
+    });
+    if (dispatch && transaction.docChanged) dispatch(transaction.scrollIntoView());
+    return true;
+}
+function selectedTableCellPositions(selection) {
+    if (selection instanceof CellSelection) {
+        const positions = [];
+        selection.forEachCell((_node, position)=>positions.push(position));
+        return positions;
+    }
+    if (selection instanceof NodeSelection && 'table' === selection.node.type.spec.tableRole) {
+        const positions = [];
+        selection.node.forEach((row, rowOffset)=>{
+            row.forEach((_cell, cellOffset)=>{
+                positions.push(selection.from + 2 + rowOffset + cellOffset);
+            });
+        });
+        return positions;
+    }
+    const position = ancestorPosition(selection.$from, isTableCell);
+    return null === position ? [] : [
+        position
+    ];
+}
+function selectedTable(selection) {
+    if (selection instanceof NodeSelection && 'table' === selection.node.type.spec.tableRole) return {
+        node: selection.node,
+        position: selection.from
+    };
+    for(let depth = selection.$from.depth; depth > 0; depth -= 1){
+        const node = selection.$from.node(depth);
+        if ('table' === node.type.spec.tableRole) return {
+            node,
+            position: selection.$from.before(depth)
+        };
+    }
+    return null;
+}
+function ancestorPosition(position, predicate) {
+    for(let depth = position.depth; depth > 0; depth -= 1)if (predicate(position.node(depth))) return position.before(depth);
+    return null;
+}
+function isTableCell(node) {
+    return 'cell' === node.type.spec.tableRole || 'header_cell' === node.type.spec.tableRole;
+}
+function tableStyleCellFormat(style, cell, rowIndex) {
+    return {
+        backgroundColor: 'header_cell' === cell.type.spec.tableRole ? style.headerColor : rowIndex % 2 === 1 ? style.alternateColor : style.bodyColor,
+        borderColor: style.borderColor,
+        borderStyle: style.borderStyle,
+        borderWidth: style.borderWidth
+    };
+}
+function normalizeFormatPatch(patch) {
+    const normalized = {};
+    if (void 0 !== patch.backgroundColor) {
+        const color = normalizeTableColor(patch.backgroundColor);
+        if (!color) return null;
+        normalized.backgroundColor = color;
+    }
+    if (void 0 !== patch.verticalAlign) {
+        const alignment = normalizeDocumentTableVerticalAlign(patch.verticalAlign);
+        if (!alignment) return null;
+        normalized.verticalAlign = alignment;
+    }
+    if (void 0 !== patch.borderColor) {
+        const color = normalizeTableColor(patch.borderColor);
+        if (!color) return null;
+        normalized.borderColor = color;
+    }
+    if (void 0 !== patch.borderStyle) {
+        const style = normalizeDocumentTableBorderStyle(patch.borderStyle);
+        if (!style) return null;
+        normalized.borderStyle = style;
+    }
+    if (void 0 !== patch.borderWidth) {
+        const width = normalizeDocumentTableBorderWidth(patch.borderWidth);
+        if (null === width) return null;
+        normalized.borderWidth = width;
+    }
+    return normalized;
+}
+function formatFromAttributes(attributes, defaults = DEFAULT_DOCUMENT_TABLE_CELL_FORMAT) {
+    return {
+        backgroundColor: normalizeTableColor(String(attributes.backgroundColor ?? '')) ?? defaults.backgroundColor,
+        verticalAlign: normalizeDocumentTableVerticalAlign(String(attributes.verticalAlign ?? '')) ?? defaults.verticalAlign,
+        borderColor: normalizeTableColor(String(attributes.borderColor ?? '')) ?? defaults.borderColor,
+        borderStyle: normalizeDocumentTableBorderStyle(String(attributes.borderStyle ?? '')) ?? defaults.borderStyle,
+        borderWidth: normalizeDocumentTableBorderWidth(attributes.borderWidth) ?? defaults.borderWidth
+    };
+}
+function normalizeTableColor(value) {
+    const trimmed = value?.trim().toLowerCase();
+    if (!trimmed) return null;
+    if (/^#[0-9a-f]{3}$/.test(trimmed)) return `#${trimmed.slice(1).split('').map((part)=>`${part}${part}`).join('')}`;
+    if (/^#[0-9a-f]{6}$/.test(trimmed)) return trimmed;
+    const rgb = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(trimmed);
+    if (!rgb) return null;
+    const channels = rgb.slice(1, 4).map(Number);
+    if (channels.some((channel)=>channel < 0 || channel > 255)) return null;
+    return `#${channels.map((channel)=>channel.toString(16).padStart(2, '0')).join('')}`;
+}
+function normalizeDocumentTableVerticalAlign(value) {
+    if ('top' === value || 'middle' === value || 'bottom' === value) return value;
+    if ('center' === value) return 'middle';
+    return null;
+}
+function normalizeDocumentTableBorderStyle(value) {
+    if ('solid' === value || 'dashed' === value || 'dotted' === value || 'double' === value || 'none' === value) return value;
+    return null;
+}
+function normalizeDocumentTableBorderWidth(value) {
+    const width = 'number' == typeof value ? value : Number.parseFloat(String(value ?? '').replace(/px$/i, ''));
+    if (!Number.isFinite(width) || width < 0 || width > 6) return null;
+    return Math.round(2 * width) / 2;
+}
+const DocumentTableRow = TableRow.extend({
+    addAttributes () {
+        return {
+            ...this.parent?.() ?? {},
+            cantSplit: booleanRowAttribute('cantSplit', 'officeCantSplit', 'data-office-cant-split'),
+            repeatHeader: booleanRowAttribute('repeatHeader', 'officeRepeatHeader', 'data-office-repeat-header'),
+            rowHeight: {
+                default: null,
+                parseHTML: (element)=>normalizeDocumentTableRowHeight(element.dataset.officeRowHeight || element.style.height),
+                renderHTML: (attributes)=>{
+                    const height = normalizeDocumentTableRowHeight(attributes.rowHeight);
+                    return null === height ? {} : {
+                        'data-office-row-height': String(height),
+                        style: `height: ${height}px`
+                    };
+                }
+            },
+            rowHeightRule: {
+                default: null,
+                parseHTML: (element)=>normalizeDocumentTableRowHeightRule(element.dataset.officeRowHeightRule),
+                renderHTML: (attributes)=>{
+                    const rule = normalizeDocumentTableRowHeightRule(attributes.rowHeightRule);
+                    return null === rule ? {} : {
+                        'data-office-row-height-rule': rule
+                    };
+                }
+            }
+        };
+    },
+    addCommands () {
+        return {
+            ...this.parent?.() ?? {},
+            setDocumentTableRowOptions: (options, commandOptions = {})=>({ chain, editor })=>{
+                    if (!editor.isActive('table')) return false;
+                    let commandChain = chain();
+                    if (false !== commandOptions.restoreFocus) commandChain = commandChain.focus();
+                    return commandChain.updateAttributes('tableRow', {
+                        cantSplit: Boolean(options.cantSplit),
+                        repeatHeader: Boolean(options.repeatHeader)
+                    }).run();
+                }
+        };
+    }
+});
+function documentTableRowOptions(editor) {
+    const attributes = editor.getAttributes('tableRow');
+    return {
+        cantSplit: directBoolean(attributes.cantSplit) ?? false,
+        repeatHeader: directBoolean(attributes.repeatHeader) ?? editor.isActive('tableHeader')
+    };
+}
+function canSetDocumentTableRowRepeatHeader(editor) {
+    const resolved = editor.state.selection.$from;
+    for(let depth = resolved.depth; depth > 0; depth -= 1){
+        if ('tableRow' !== resolved.node(depth).type.name) continue;
+        const tableDepth = depth - 1;
+        const table = resolved.node(tableDepth);
+        if ('table' !== table.type.name) break;
+        let leadingHeaderCount = 0;
+        for(let index = 0; index < table.childCount; index += 1){
+            if (!documentTableRowRepeats(table.child(index))) break;
+            leadingHeaderCount += 1;
+        }
+        return resolved.index(tableDepth) <= leadingHeaderCount;
+    }
+    return false;
+}
+function documentTableRowRepeats(node) {
+    const explicit = directBoolean(node.attrs.repeatHeader);
+    if (null !== explicit) return explicit;
+    if (0 === node.childCount) return false;
+    for(let index = 0; index < node.childCount; index += 1)if ('tableHeader' !== node.child(index).type.name) return false;
+    return true;
+}
+function documentTableRowCantSplit(node) {
+    return directBoolean(node.attrs.cantSplit) ?? false;
+}
+function documentTableRowHeight(attributes) {
+    const height = normalizeDocumentTableRowHeight(attributes.rowHeight);
+    return {
+        height,
+        rule: null === height ? null : normalizeDocumentTableRowHeightRule(attributes.rowHeightRule) ?? 'atLeast'
+    };
+}
+function normalizeDocumentTableRowHeight(value) {
+    const height = Number.parseFloat(String(value ?? '').replace(/px$/i, ''));
+    return Number.isFinite(height) && height > 0 ? Math.round(100 * height) / 100 : null;
+}
+function normalizeDocumentTableRowHeightRule(value) {
+    return 'exact' === value || 'atLeast' === value ? value : null;
+}
+function booleanRowAttribute(modelKey, datasetKey, htmlName) {
+    return {
+        default: null,
+        parseHTML: (element)=>directBoolean(element.dataset[datasetKey]),
+        renderHTML: (attributes)=>{
+            const value = directBoolean(attributes[modelKey]);
+            return null === value ? {} : {
+                [htmlName]: String(value)
+            };
+        }
+    };
+}
+function directBoolean(value) {
+    if (true === value || 'true' === value || '1' === value) return true;
+    if (false === value || 'false' === value || '0' === value) return false;
+    return null;
+}
+const DEFAULT_COLUMN_WIDTH = 120;
+const DEFAULT_ROW_HEIGHT = 36;
+const MIN_COLUMN_WIDTH = 25;
+const MIN_ROW_HEIGHT = 12;
+const MAX_TABLE_DIMENSION = 4000;
+class WorkDocumentTableView extends TableView {
+    constructor(node, cellMinWidth, view){
+        super(node, cellMinWidth, view);
+        this.syncLayout(node);
+    }
+    update(node) {
+        const updated = super.update(node);
+        if (updated) this.syncLayout(node);
+        return updated;
+    }
+    syncLayout(node) {
+        const mode = normalizeDocumentTableLayoutMode(node.attrs.layoutMode);
+        this.table.dataset.officeTableLayout = mode;
+        if ('window' === mode) {
+            this.clearStaleColumnWidths();
+            this.table.style.width = '100%';
+        } else if ('contents' === mode) {
+            this.clearStaleColumnWidths();
+            this.table.style.width = '';
+        }
+    }
+    clearStaleColumnWidths() {
+        for (const column of Array.from(this.colgroup.children))if (column instanceof HTMLElement) {
+            column.style.removeProperty('width');
+            column.style.setProperty('min-width', `${this.cellMinWidth}px`);
+        }
+    }
+}
+const DocumentTable = Table.extend({
+    addAttributes () {
+        return {
+            ...this.parent?.() ?? {},
+            layoutMode: {
+                default: 'window',
+                parseHTML: (element)=>normalizeDocumentTableLayoutMode(element.dataset.officeTableLayout),
+                renderHTML: (attributes)=>({
+                        'data-office-table-layout': normalizeDocumentTableLayoutMode(attributes.layoutMode)
+                    })
+            }
+        };
+    }
+}).configure({
+    resizable: true,
+    allowTableNodeSelection: true,
+    View: WorkDocumentTableView
+});
+const DocumentTableSizing = Extension.create({
+    name: 'documentTableSizing',
+    addCommands () {
+        return {
+            setDocumentTableColumnWidth: (width, renderedColumnWidths)=>(props)=>setSelectedColumnWidth(props, width, renderedColumnWidths),
+            setDocumentTableRowHeight: (height, rule = 'atLeast')=>(props)=>setSelectedRowHeight(props, height, rule),
+            setDocumentTableLayoutMode: (mode, renderedTableWidth)=>(props)=>setTableLayoutMode(props, mode, renderedTableWidth),
+            distributeDocumentTableColumns: (renderedSelectionWidth)=>(props)=>distributeColumns(props, renderedSelectionWidth),
+            distributeDocumentTableRows: (renderedSelectionHeight)=>(props)=>distributeRows(props, renderedSelectionHeight)
+        };
+    },
+    addProseMirrorPlugins () {
+        return [
+            new Plugin({
+                appendTransaction: (transactions, _oldState, newState)=>{
+                    if (!transactions.some((transaction)=>transaction.docChanged)) return null;
+                    const transaction = newState.tr;
+                    newState.doc.descendants((node, position)=>{
+                        if ('table' !== node.type.spec.tableRole) return true;
+                        if ('window' === normalizeDocumentTableLayoutMode(node.attrs.layoutMode) && tableHasExplicitColumnWidths(node)) transaction.setNodeMarkup(position, void 0, {
+                            ...node.attrs,
+                            layoutMode: 'fixed'
+                        });
+                        return false;
+                    });
+                    return transaction.docChanged ? transaction : null;
+                }
+            })
+        ];
+    }
+});
+function documentTableSizing(state) {
+    const context = tableSizingContext(state);
+    if (!context) return null;
+    const columns = numberRange(context.left, context.right);
+    const rows = numberRange(context.top, context.bottom);
+    const widths = tableColumnWidths(context.table, context.map).filter((_width, index)=>columns.includes(index));
+    const rowSizes = tableRowSizes(context.table).filter((_size, index)=>rows.includes(index));
+    return {
+        columnWidth: commonPositiveValue(widths),
+        rowHeight: commonNullableValue(rowSizes.map(({ height })=>height)),
+        rowHeightRule: commonNullableValue(rowSizes.map(({ rule })=>rule)),
+        layoutMode: normalizeDocumentTableLayoutMode(context.table.attrs.layoutMode),
+        selectedColumnCount: columns.length,
+        selectedRowCount: rows.length
+    };
+}
+function normalizeDocumentTableLayoutMode(value) {
+    return 'contents' === value || 'fixed' === value ? value : 'window';
+}
+function setSelectedColumnWidth({ dispatch, state }, width, renderedColumnWidths) {
+    const normalized = normalizedDimension(width, MIN_COLUMN_WIDTH, MAX_TABLE_DIMENSION);
+    const context = tableSizingContext(state);
+    if (!context || null === normalized) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    const preservedWidths = normalizeRenderedDimensions(renderedColumnWidths, context.map.width, MIN_COLUMN_WIDTH);
+    if (preservedWidths) {
+        for(let column = context.left; column < context.right; column += 1)preservedWidths[column] = normalized;
+        setPhysicalColumnWidths(transaction, context, preservedWidths, 0);
+    } else setPhysicalColumnWidths(transaction, context, numberRange(context.left, context.right).map(()=>normalized), context.left);
+    setTableLayoutAttribute(transaction, context, 'fixed');
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setSelectedRowHeight({ dispatch, state }, height, rule) {
+    const normalized = null === height ? null : normalizedDimension(height, MIN_ROW_HEIGHT, MAX_TABLE_DIMENSION);
+    const context = tableSizingContext(state);
+    if (!context || null !== height && null === normalized) return false;
+    if ('atLeast' !== rule && 'exact' !== rule) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    setPhysicalRowHeights(transaction, context, numberRange(context.top, context.bottom), normalized, rule);
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setTableLayoutMode({ dispatch, state }, requestedMode, renderedTableWidth) {
+    if ('window' !== requestedMode && 'contents' !== requestedMode && 'fixed' !== requestedMode) return false;
+    const context = tableSizingContext(state);
+    if (!context) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    setTableLayoutAttribute(transaction, context, requestedMode);
+    if ('fixed' === requestedMode) {
+        const existing = tableColumnWidths(context.table, context.map);
+        const total = distributionTotal(existing, renderedTableWidth, DEFAULT_COLUMN_WIDTH);
+        setPhysicalColumnWidths(transaction, context, equalDimensions(total, context.map.width, MIN_COLUMN_WIDTH), 0);
+    } else clearPhysicalColumnWidths(transaction, context);
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function distributeColumns({ dispatch, state }, renderedSelectionWidth) {
+    const context = tableSizingContext(state);
+    if (!context) return false;
+    const selected = numberRange(context.left, context.right);
+    const columns = selected.length > 1 ? selected : numberRange(0, context.map.width);
+    if (columns.length < 2) return false;
+    if (!dispatch) return true;
+    const allWidths = tableColumnWidths(context.table, context.map);
+    const existing = columns.map((column)=>allWidths[column] ?? null);
+    const total = distributionTotal(existing, renderedSelectionWidth, DEFAULT_COLUMN_WIDTH);
+    const transaction = state.tr;
+    setPhysicalColumnWidths(transaction, context, equalDimensions(total, columns.length, MIN_COLUMN_WIDTH), columns[0] ?? 0);
+    setTableLayoutAttribute(transaction, context, 'fixed');
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function distributeRows({ dispatch, state }, renderedSelectionHeight) {
+    const context = tableSizingContext(state);
+    if (!context) return false;
+    const selected = numberRange(context.top, context.bottom);
+    const rows = selected.length > 1 ? selected : numberRange(0, context.map.height);
+    if (rows.length < 2) return false;
+    if (!dispatch) return true;
+    const allSizes = tableRowSizes(context.table);
+    const existing = rows.map((row)=>allSizes[row]?.height ?? null);
+    const total = distributionTotal(existing, renderedSelectionHeight, DEFAULT_ROW_HEIGHT);
+    const [height] = equalDimensions(total, rows.length, MIN_ROW_HEIGHT);
+    const transaction = state.tr;
+    setPhysicalRowHeights(transaction, context, rows, height ?? DEFAULT_ROW_HEIGHT, 'atLeast');
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function tableSizingContext(state) {
+    if (state.selection instanceof NodeSelection && 'table' === state.selection.node.type.spec.tableRole) {
+        const table = state.selection.node;
+        const map = TableMap.get(table);
+        return {
+            table,
+            tableStart: state.selection.from + 1,
+            map,
+            left: 0,
+            right: map.width,
+            top: 0,
+            bottom: map.height
+        };
+    }
+    if (!isInTable(state)) return null;
+    const rectangle = selectedRect(state);
+    return {
+        table: rectangle.table,
+        tableStart: rectangle.tableStart,
+        map: rectangle.map,
+        left: rectangle.left,
+        right: rectangle.right,
+        top: rectangle.top,
+        bottom: rectangle.bottom
+    };
+}
+function dispatchTableSizingTransaction(dispatch, transaction, context, state) {
+    if (!transaction.docChanged) return;
+    if (state.selection instanceof NodeSelection && 'table' === state.selection.node.type.spec.tableRole) {
+        const tablePosition = context.tableStart - 1;
+        if (transaction.doc.nodeAt(tablePosition)?.type.spec.tableRole === 'table') transaction.setSelection(NodeSelection.create(transaction.doc, tablePosition));
+    }
+    dispatch(transaction.scrollIntoView());
+}
+function setPhysicalColumnWidths(transaction, context, widths, startColumn) {
+    const touched = new Set();
+    widths.forEach((width, widthIndex)=>{
+        const column = startColumn + widthIndex;
+        if (column < 0 || column >= context.map.width) return;
+        for(let row = 0; row < context.map.height; row += 1){
+            const relativePosition = context.map.map[row * context.map.width + column];
+            if (void 0 === relativePosition) continue;
+            const cell = context.table.nodeAt(relativePosition);
+            if (!cell) continue;
+            const widthIndexInCell = column - context.map.colCount(relativePosition);
+            const key = `${relativePosition}:${widthIndexInCell}`;
+            if (touched.has(key)) continue;
+            touched.add(key);
+            const documentPosition = context.tableStart + relativePosition;
+            const current = transaction.doc.nodeAt(documentPosition);
+            if (!current) continue;
+            const colwidth = Array.isArray(current.attrs.colwidth) ? [
+                ...current.attrs.colwidth
+            ] : Array.from({
+                length: Number(current.attrs.colspan ?? 1)
+            }, ()=>0);
+            colwidth[widthIndexInCell] = width;
+            transaction.setNodeMarkup(documentPosition, void 0, {
+                ...current.attrs,
+                colwidth
+            });
+        }
+    });
+}
+function clearPhysicalColumnWidths(transaction, context) {
+    context.table.descendants((node, offset)=>{
+        if (!work_document_table_sizing_isTableCell(node)) return true;
+        const position = context.tableStart + offset;
+        const current = transaction.doc.nodeAt(position);
+        if (current?.attrs.colwidth) transaction.setNodeMarkup(position, void 0, {
+            ...current.attrs,
+            colwidth: null
+        });
+        return false;
+    });
+}
+function setPhysicalRowHeights(transaction, context, rows, height, rule) {
+    const selectedRows = new Set(rows);
+    context.table.forEach((_row, offset, index)=>{
+        if (!selectedRows.has(index)) return;
+        const position = context.tableStart + offset;
+        const current = transaction.doc.nodeAt(position);
+        if (!current) return;
+        transaction.setNodeMarkup(position, void 0, {
+            ...current.attrs,
+            rowHeight: height,
+            rowHeightRule: null === height ? null : rule
+        });
+    });
+}
+function setTableLayoutAttribute(transaction, context, layoutMode) {
+    const position = context.tableStart - 1;
+    const table = transaction.doc.nodeAt(position);
+    if (!table) return;
+    transaction.setNodeMarkup(position, void 0, {
+        ...table.attrs,
+        layoutMode
+    });
+}
+function tableColumnWidths(table, map) {
+    return Array.from({
+        length: map.width
+    }, (_unused, column)=>{
+        for(let row = 0; row < map.height; row += 1){
+            const position = map.map[row * map.width + column];
+            if (void 0 === position) continue;
+            const cell = table.nodeAt(position);
+            const index = column - map.colCount(position);
+            const value = Array.isArray(cell?.attrs.colwidth) ? Number(cell.attrs.colwidth[index]) : 0;
+            if (Number.isFinite(value) && value > 0) return value;
+        }
+        return null;
+    });
+}
+function tableRowSizes(table) {
+    const sizes = [];
+    table.forEach((row)=>{
+        sizes.push(documentTableRowHeight(row.attrs));
+    });
+    return sizes;
+}
+function tableHasExplicitColumnWidths(table) {
+    let found = false;
+    table.descendants((node)=>{
+        if (!work_document_table_sizing_isTableCell(node)) return true;
+        if (Array.isArray(node.attrs.colwidth) && node.attrs.colwidth.some((width)=>Number(width) > 0)) found = true;
+        return !found;
+    });
+    return found;
+}
+function work_document_table_sizing_isTableCell(node) {
+    return 'cell' === node.type.spec.tableRole || 'header_cell' === node.type.spec.tableRole;
+}
+function normalizedDimension(value, minimum, maximum) {
+    if (!Number.isFinite(value) || value < minimum || value > maximum) return null;
+    return Math.round(100 * value) / 100;
+}
+function normalizeRenderedDimensions(values, expectedCount, minimum) {
+    if (!values || values.length !== expectedCount) return null;
+    const normalized = values.map((value)=>normalizedDimension(value, minimum, MAX_TABLE_DIMENSION));
+    return normalized.every((value)=>null !== value) ? normalized : null;
+}
+function numberRange(start, end) {
+    return Array.from({
+        length: Math.max(0, end - start)
+    }, (_unused, index)=>start + index);
+}
+function distributionTotal(existing, rendered, fallback) {
+    if (Number.isFinite(rendered) && Number(rendered) > 0) return Number(rendered);
+    if (existing.every((value)=>null !== value && value > 0)) return existing.reduce((sum, value)=>sum + Number(value), 0);
+    return fallback * existing.length;
+}
+function equalDimensions(total, count, minimum) {
+    const size = Math.max(minimum, Math.round(total / count * 100) / 100);
+    return Array.from({
+        length: count
+    }, ()=>size);
+}
+function commonPositiveValue(values) {
+    if (!values.length || values.some((value)=>null === value || value <= 0)) return null;
+    return values.every((value)=>value === values[0]) ? values[0] : null;
+}
+function commonNullableValue(values) {
+    if (!values.length || values.some((value)=>null === value)) return null;
+    return values.every((value)=>value === values[0]) ? values[0] : null;
+}
+export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentTable, DocumentTableCell, DocumentTableFormatting, DocumentTableHeader, DocumentTableRow, DocumentTableSizing, activeDocumentTableStyle, canSetDocumentTableRowRepeatHeader, documentTableCellFormat, documentTableHorizontalAlignment, documentTableRowCantSplit, documentTableRowOptions, documentTableRowRepeats, documentTableSizing, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableLayoutMode, normalizeDocumentTableRowHeightRule, normalizeDocumentTableVerticalAlign, normalizeTableColor };