@a3s-lab/office 0.1.0 → 0.2.2

package/dist/0~work-document-extensions.js

@@ -1,9 +1,7 @@
 import extension_color from "@tiptap/extension-color";
 import extension_highlight from "@tiptap/extension-highlight";
-import { TableKit, createTable } from "@tiptap/extension-table";
+import { Table, TableKit, TableView, createTable } from "@tiptap/extension-table";
 import extension_text_align from "@tiptap/extension-text-align";
-import { TextStyle } from "@tiptap/extension-text-style";
-import font_family from "@tiptap/extension-text-style/font-family";
 import font_size from "@tiptap/extension-text-style/font-size";
 import extension_underline from "@tiptap/extension-underline";
 import starter_kit from "@tiptap/starter-kit";
@@ -14,11 +12,13 @@ import extension_subscript from "@tiptap/extension-subscript";
 import extension_superscript from "@tiptap/extension-superscript";
 import { Decoration, DecorationSet } from "@tiptap/pm/view";
 import { BulletList, OrderedList } from "@tiptap/extension-list";
-import { documentFieldLabel, documentSections, documentCaptionLabel, documentCaptionKind, renameDocumentCitationTagInInstruction, documentNoteReferenceKeys, collectDocumentNotes, documentSectionNodeAttributes, syncDocumentContentFromHtml, documentFieldInstruction, documentCitationTagsFromInstruction, documentCitationInstruction, documentCitationTags, documentFieldKind, documentSectionDomAttributes, documentFieldDisplay, docxDocumentFieldKind, renderDocumentBibliographyHtml, documentSectionLayoutFromNodeAttributes, documentNoteKey, documentCaptionDisplay, resolveDocumentCitation, removeDocumentNoteDefinitions, resolveDocumentFieldsHtml, documentNoteKind } from "./4704.js";
+import { closeHistory } from "@tiptap/pm/history";
+import { TableMap, isInTable, selectedRect } from "@tiptap/pm/tables";
+import { documentFieldLabel, documentSections, documentCaptionLabel, documentCaptionKind, renameDocumentCitationTagInInstruction, documentNoteReferenceKeys, collectDocumentNotes, documentSectionNodeAttributes, syncDocumentContentFromHtml, documentFieldInstruction, documentCitationTagsFromInstruction, documentCitationInstruction, documentCitationTags, documentFieldKind, documentSectionDomAttributes, documentFieldDisplay, docxDocumentFieldKind, renderDocumentBibliographyHtml, documentSectionLayoutFromNodeAttributes, documentNoteKey, documentCaptionDisplay, resolveDocumentCitation, removeDocumentNoteDefinitions, resolveDocumentFieldsHtml, documentNoteKind } from "./2881.js";
 import { createOfficeId as createWorkId } from "./1134.js";
-import { DocumentParagraphTabStops, DocumentImage, normalizeDocumentTabStops } from "./0~8155.js";
-import { DocumentTable, DocumentTableCell, DocumentTableHeader, DocumentTableRow, DocumentTableSizing, DocumentTableFormatting } from "./0~6552.js";
-import { DocumentParagraphFormatting } from "./0~work-document-paragraph-formatting.js";
+import { normalizeDocumentTableProperties, documentTableGeometryForLayoutMode, DocumentImage, renderDocumentTableGeometry, documentTableGeometryFromElement, documentTableLayoutMode, normalizeDocumentTabStops, normalizeDocumentTableCellMarginOverrides, normalizeDocumentTableAlignment, normalizeDocumentTableCellMargins, DocumentParagraphTabStops, normalizeDocumentTableGeometry, applyDocumentTableGeometryToElement } from "./0~4750.js";
+import { DocumentTableCell, DocumentTableHeader, DocumentTableRow, normalizeDocumentTableVerticalAlign, documentTableRowHeight, documentTableRowRepeats, DocumentTableFormatting } from "./0~2582.js";
+import { DocumentTextStyle, DocumentFontFamily, DocumentParagraphFormatting } from "./0~5861.js";
 function activeDocumentSection(editor) {
     return activeDocumentSectionFromState(editor.state);
 }
@@ -2009,7 +2009,9 @@ const DocumentSection = Node.create({
             footerText: work_document_section_node_hiddenAttribute(''),
             showPageNumbers: work_document_section_node_hiddenAttribute(false),
             pageNumberStart: work_document_section_node_hiddenAttribute(null),
-            pageChrome: work_document_section_node_hiddenAttribute('')
+            pageChrome: work_document_section_node_hiddenAttribute(''),
+            documentGridType: work_document_section_node_hiddenAttribute(''),
+            documentGridLinePitch: work_document_section_node_hiddenAttribute(null)
         };
     },
     addCommands () {
@@ -2069,7 +2071,9 @@ const DocumentSection = Node.create({
                         footerText: node.dataset.sectionFooterText ?? '',
                         showPageNumbers: 'true' === node.dataset.sectionShowPageNumbers,
                         pageNumberStart: nullableNumberAttribute(node, 'sectionPageNumberStart'),
-                        pageChrome: node.dataset.sectionPageChrome ?? ''
+                        pageChrome: node.dataset.sectionPageChrome ?? '',
+                        documentGridType: node.dataset.sectionDocumentGridType ?? '',
+                        documentGridLinePitch: nullableNumberAttribute(node, 'sectionDocumentGridLinePitch')
                     };
                 }
             }
@@ -2082,7 +2086,10 @@ const DocumentSection = Node.create({
         const style = [
             `--work-document-column-count:${columns.count}`,
             `--work-document-column-gap:${columns.spacing}mm`,
-            `--work-document-column-rule:${columns.separator ? '1px solid var(--a3s-line-strong)' : 'none'}`
+            `--work-document-column-rule:${columns.separator ? '1px solid var(--a3s-line-strong)' : 'none'}`,
+            ...layout.documentGrid ? [
+                `--work-document-word-grid-line-pitch:${layout.documentGrid.linePitch}pt`
+            ] : []
         ].join(';');
         return [
             'section',
@@ -2366,6 +2373,574 @@ function withRepeatingFirstRow(table) {
     }, firstRow.content, firstRow.marks);
     return table.copy(table.content.replaceChild(0, repeatedRow));
 }
+const MIN_DOCUMENT_TABLE_COLUMN_WIDTH = 25;
+const MIN_DOCUMENT_TABLE_ROW_HEIGHT = 12;
+const MAX_DOCUMENT_TABLE_DIMENSION = 4000;
+function normalizeDocumentTablePropertyChanges(value) {
+    if (!isRecord(value)) return null;
+    const changes = {};
+    if (void 0 !== value.table) {
+        const table = normalizeDocumentTableProperties(value.table);
+        if (!table) return null;
+        changes.table = table;
+    }
+    if (void 0 !== value.row) {
+        const row = value.row;
+        if (!isRecord(row)) return null;
+        if (null !== row.height && 'number' != typeof row.height) return null;
+        const height = null === row.height ? null : normalizeDocumentTableDimension(row.height, MIN_DOCUMENT_TABLE_ROW_HEIGHT);
+        if (null !== row.height && null === height) return null;
+        if ('atLeast' !== row.heightRule && 'exact' !== row.heightRule) return null;
+        if ('boolean' != typeof row.cantSplit) return null;
+        if (void 0 !== row.repeatHeader && 'boolean' != typeof row.repeatHeader) return null;
+        changes.row = {
+            height,
+            heightRule: row.heightRule,
+            cantSplit: row.cantSplit,
+            ...void 0 === row.repeatHeader ? {} : {
+                repeatHeader: row.repeatHeader
+            }
+        };
+    }
+    if (void 0 !== value.column) {
+        const column = value.column;
+        if (!isRecord(column) || 'number' != typeof column.width) return null;
+        const width = normalizeDocumentTableDimension(column.width, MIN_DOCUMENT_TABLE_COLUMN_WIDTH);
+        if (null === width) return null;
+        changes.column = {
+            width,
+            ...Array.isArray(column.renderedColumnWidths) ? {
+                renderedColumnWidths: column.renderedColumnWidths
+            } : {}
+        };
+    }
+    if (void 0 !== value.cell) {
+        const cell = value.cell;
+        if (!isRecord(cell) || 'string' != typeof cell.verticalAlign) return null;
+        const verticalAlign = normalizeDocumentTableVerticalAlign(cell.verticalAlign);
+        const margins = null === cell.margins ? null : normalizeDocumentTableCellMarginOverrides(cell.margins);
+        if (!verticalAlign || null !== cell.margins && !margins) return null;
+        changes.cell = {
+            verticalAlign,
+            margins
+        };
+    }
+    return Object.keys(changes).length ? changes : null;
+}
+function normalizeDocumentTableDimension(value, minimum) {
+    if (!Number.isFinite(value) || value < minimum || value > MAX_DOCUMENT_TABLE_DIMENSION) return null;
+    return Math.round(100 * value) / 100;
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value;
+}
+const DEFAULT_COLUMN_WIDTH = 120;
+const DEFAULT_ROW_HEIGHT = 36;
+class WorkDocumentTableView extends TableView {
+    constructor(node, cellMinWidth, view){
+        super(node, cellMinWidth, view);
+        this.syncGeometry(node);
+    }
+    update(node) {
+        const updated = super.update(node);
+        if (updated) this.syncGeometry(node);
+        return updated;
+    }
+    syncGeometry(node) {
+        const geometry = tableGeometry(node);
+        applyDocumentTableGeometryToElement(this.table, geometry);
+        if (node.attrs.officeImported) this.table.dataset.officeTableImported = 'true';
+        else delete this.table.dataset.officeTableImported;
+        if (!tableHasExplicitColumnWidths(node)) this.clearStaleColumnWidths();
+    }
+    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?.() ?? {},
+            geometry: {
+                default: null,
+                parseHTML: (element)=>documentTableGeometryFromElement(element),
+                renderHTML: (attributes)=>renderDocumentTableGeometry(attributes.geometry, attributes.layoutMode)
+            },
+            layoutMode: {
+                default: null,
+                parseHTML: ()=>null,
+                renderHTML: ()=>({})
+            },
+            officeImported: {
+                default: false,
+                parseHTML: (element)=>'true' === element.dataset.officeTableImported,
+                renderHTML: (attributes)=>attributes.officeImported ? {
+                        'data-office-table-imported': 'true'
+                    } : {}
+            }
+        };
+    }
+}).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),
+            setDocumentTableAlignment: (alignment)=>(props)=>setTableAlignment(props, alignment),
+            setDocumentTableProperties: (properties)=>(props)=>setTableProperties(props, properties),
+            setDocumentTablePropertyChanges: (changes)=>(props)=>setTablePropertyChanges(props, changes),
+            setDocumentTableCellMargins: (margins)=>(props)=>setTableCellMargins(props, margins),
+            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 previousTables = documentTables(oldState.doc);
+                    const currentTables = documentTables(newState.doc);
+                    if (previousTables.length !== currentTables.length) return null;
+                    const transaction = newState.tr;
+                    let tableIndex = 0;
+                    newState.doc.descendants((node, position)=>{
+                        if ('table' !== node.type.spec.tableRole) return true;
+                        const previous = previousTables[tableIndex];
+                        tableIndex += 1;
+                        if (tableColumnWidthSignature(previous) !== tableColumnWidthSignature(node) && tableHasExplicitColumnWidths(node) && 'fixed' !== tableGeometry(node).layout) transaction.setNodeMarkup(position, void 0, {
+                            ...node.attrs,
+                            geometry: fixedGeometryForTable(node),
+                            layoutMode: null
+                        });
+                        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));
+    const geometry = tableGeometry(context.table);
+    return {
+        columnWidth: commonPositiveValue(widths),
+        rowHeight: commonNullableValue(rowSizes.map(({ height })=>height)),
+        rowHeightRule: commonNullableValue(rowSizes.map(({ rule })=>rule)),
+        layoutMode: documentTableLayoutMode(geometry),
+        layoutAlgorithm: geometry.layout,
+        preferredWidthType: geometry.width.type,
+        preferredWidth: geometry.width.value,
+        alignment: geometry.alignment,
+        indent: geometry.indent,
+        cellMargins: geometry.cellMargins,
+        selectedColumnCount: columns.length,
+        selectedRowCount: rows.length
+    };
+}
+function setSelectedColumnWidth({ dispatch, state }, width, renderedColumnWidths) {
+    const normalized = normalizeDocumentTableDimension(width, 25);
+    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, 25);
+    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);
+    setFixedTableGeometryFromColumns(transaction, context);
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setSelectedRowHeight({ dispatch, state }, height, rule) {
+    const normalized = null === height ? null : normalizeDocumentTableDimension(height, 12);
+    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;
+    let preferredWidth = renderedTableWidth;
+    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, 25), 0);
+        preferredWidth = total;
+    } else clearPhysicalColumnWidths(transaction, context);
+    setTableGeometryAttribute(transaction, context, documentTableGeometryForLayoutMode(requestedMode, tableGeometry(context.table), preferredWidth));
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setTableAlignment({ dispatch, state }, requestedAlignment) {
+    const alignment = normalizeDocumentTableAlignment(requestedAlignment);
+    const context = tableSizingContext(state);
+    if (!context || !alignment) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    setTableGeometryAttribute(transaction, context, {
+        ...tableGeometry(context.table),
+        alignment
+    });
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setTableProperties({ dispatch, state }, requestedProperties) {
+    const properties = normalizeDocumentTableProperties(requestedProperties);
+    const context = tableSizingContext(state);
+    if (!context || !properties) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    setTableGeometryAttribute(transaction, context, {
+        ...tableGeometry(context.table),
+        ...properties
+    });
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setTablePropertyChanges({ dispatch, state }, requestedChanges) {
+    const changes = normalizeDocumentTablePropertyChanges(requestedChanges);
+    const context = tableSizingContext(state);
+    if (!context || !changes) return false;
+    if (changes.row?.repeatHeader === true && !canRepeatSelectedTableRows(context)) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    closeHistory(transaction);
+    if (changes.column) {
+        const preservedWidths = normalizeRenderedDimensions(changes.column.renderedColumnWidths, context.map.width, 25);
+        if (preservedWidths) {
+            for(let column = context.left; column < context.right; column += 1)preservedWidths[column] = changes.column.width;
+            setPhysicalColumnWidths(transaction, context, preservedWidths, 0);
+        } else setPhysicalColumnWidths(transaction, context, numberRange(context.left, context.right).map(()=>changes.column?.width ?? DEFAULT_COLUMN_WIDTH), context.left);
+        setFixedTableGeometryFromColumns(transaction, context);
+    }
+    if (changes.table) {
+        const currentTable = transaction.doc.nodeAt(context.tableStart - 1);
+        setTableGeometryAttribute(transaction, context, {
+            ...tableGeometry(currentTable ?? context.table),
+            ...changes.table
+        });
+    }
+    if (changes.row) setPhysicalRowProperties(transaction, context, numberRange(context.top, context.bottom), changes.row);
+    if (changes.cell) setSelectedCellProperties(transaction, context, changes.cell);
+    dispatchTableSizingTransaction(dispatch, transaction, context, state);
+    return true;
+}
+function setTableCellMargins({ dispatch, state }, requestedMargins) {
+    const cellMargins = normalizeDocumentTableCellMargins(requestedMargins);
+    const context = tableSizingContext(state);
+    if (!context || !cellMargins) return false;
+    if (!dispatch) return true;
+    const transaction = state.tr;
+    setTableGeometryAttribute(transaction, context, {
+        ...tableGeometry(context.table),
+        cellMargins
+    });
+    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, 25), columns[0] ?? 0);
+    setFixedTableGeometryFromColumns(transaction, context);
+    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, 12);
+    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 (!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 setPhysicalRowProperties(transaction, context, rows, properties) {
+    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: properties.height,
+            rowHeightRule: null === properties.height ? null : properties.heightRule,
+            cantSplit: properties.cantSplit,
+            ...void 0 === properties.repeatHeader ? {} : {
+                repeatHeader: properties.repeatHeader
+            }
+        });
+    });
+}
+function setSelectedCellProperties(transaction, context, properties) {
+    const positions = context.map.cellsInRect({
+        left: context.left,
+        right: context.right,
+        top: context.top,
+        bottom: context.bottom
+    });
+    for (const relativePosition of positions){
+        const position = context.tableStart + relativePosition;
+        const current = transaction.doc.nodeAt(position);
+        if (current && isTableCell(current)) transaction.setNodeMarkup(position, void 0, {
+            ...current.attrs,
+            verticalAlign: properties.verticalAlign,
+            margins: properties.margins
+        });
+    }
+}
+function canRepeatSelectedTableRows(context) {
+    let leadingRepeatCount = 0;
+    for(let index = 0; index < context.table.childCount; index += 1){
+        if (!documentTableRowRepeats(context.table.child(index))) break;
+        leadingRepeatCount += 1;
+    }
+    return context.top <= leadingRepeatCount;
+}
+function setTableGeometryAttribute(transaction, context, geometry) {
+    const position = context.tableStart - 1;
+    const table = transaction.doc.nodeAt(position);
+    if (!table) return;
+    transaction.setNodeMarkup(position, void 0, {
+        ...table.attrs,
+        geometry: normalizeDocumentTableGeometry(geometry),
+        layoutMode: null
+    });
+}
+function setFixedTableGeometryFromColumns(transaction, context) {
+    const table = transaction.doc.nodeAt(context.tableStart - 1);
+    if (!table || 'table' !== table.type.spec.tableRole) return;
+    setTableGeometryAttribute(transaction, context, fixedGeometryForTable(table));
+}
+function tableGeometry(table) {
+    return normalizeDocumentTableGeometry(table.attrs.geometry, table.attrs.layoutMode);
+}
+function fixedGeometryForTable(table) {
+    const geometry = tableGeometry(table);
+    const widths = tableColumnWidths(table, TableMap.get(table));
+    const total = widths.every((width)=>null !== width && width > 0) ? widths.reduce((sum, width)=>sum + width, 0) : null;
+    return {
+        ...geometry,
+        layout: 'fixed',
+        width: null === total ? geometry.width : {
+            type: 'pixels',
+            value: Math.round(100 * total) / 100
+        }
+    };
+}
+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 (!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 documentTables(document1) {
+    const tables = [];
+    document1.descendants((node)=>{
+        if ('table' !== node.type.spec.tableRole) return true;
+        tables.push(node);
+        return false;
+    });
+    return tables;
+}
+function tableColumnWidthSignature(table) {
+    if (!table) return '';
+    const widths = [];
+    table.descendants((node)=>{
+        if (!isTableCell(node)) return true;
+        widths.push(node.attrs.colwidth ?? null);
+        return false;
+    });
+    return JSON.stringify(widths);
+}
+function isTableCell(node) {
+    return 'cell' === node.type.spec.tableRole || 'header_cell' === node.type.spec.tableRole;
+}
+function normalizeRenderedDimensions(values, expectedCount, minimum) {
+    if (!values || values.length !== expectedCount) return null;
+    const normalized = values.map((value)=>normalizeDocumentTableDimension(value, minimum));
+    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;
+}
 function createWorkDocumentExtensions(options = {}) {
     const changeExtension = DocumentChange.configure({
         ...options.isTracking ? {
@@ -2447,8 +3022,8 @@ function createWorkDocumentExtensions(options = {}) {
         DocumentTableCommands,
         DocumentTableFormatting,
         DocumentTableSizing,
-        TextStyle,
-        font_family,
+        DocumentTextStyle,
+        DocumentFontFamily,
         font_size,
         extension_color,
         extension_highlight.configure({
@@ -2467,4 +3042,4 @@ function createWorkDocumentExtensions(options = {}) {
         changeExtension
     ];
 }
-export { DocumentSubscript, DocumentSuperscript, MAX_DOCUMENT_NUMBERING_START, activeDocumentSection, canInsertDocumentComment, collectDocumentChanges, collectDocumentCommentAnchors, createWorkDocumentExtensions, documentBulletListStyle, documentCitationCount, documentCommentDraftRange, documentCommentViews, documentOrderedListState, documentSectionById, documentTabLeaderLabel, editorDocumentCaptionTargets, retainAnchoredDocumentComments };
+export { DocumentSubscript, DocumentSuperscript, MAX_DOCUMENT_NUMBERING_START, activeDocumentSection, canInsertDocumentComment, collectDocumentChanges, collectDocumentCommentAnchors, createWorkDocumentExtensions, documentBulletListStyle, documentCitationCount, documentCommentDraftRange, documentCommentViews, documentOrderedListState, documentSectionById, documentTabLeaderLabel, documentTableSizing, editorDocumentCaptionTargets, retainAnchoredDocumentComments };

package/dist/0~work-document-model-codec.js

@@ -1,6 +1,6 @@
 import { generateHTML, getSchema } from "@tiptap/core";
 import { DOMParser as model_DOMParser } from "@tiptap/pm/model";
-import { createWorkDocumentModel, syncDocumentContentFromHtml, documentModelForContent, documentHtmlFingerprint } from "./4704.js";
+import { createWorkDocumentModel, syncDocumentContentFromHtml, documentModelForContent, documentHtmlFingerprint } from "./2881.js";
 import { createWorkDocumentExtensions } from "./0~work-document-extensions.js";
 let schema = null;
 let extensions = null;

package/dist/0~work-docx-bibliography.js

@@ -1,6 +1,6 @@
 import jszip from "jszip";
 import { directChild, directChildren, attribute, parseXml } from "./8715.js";
-import { documentCitationStyle, createDocumentBibliography, documentCitationStyleDetails } from "./4704.js";
+import { documentCitationStyle, createDocumentBibliography, documentCitationStyleDetails } from "./2881.js";
 const BIBLIOGRAPHY_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/bibliography';
 const CUSTOM_XML_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/customXml';
 const OFFICE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';