@a3s-lab/office 0.1.0 → 0.2.1

package/README.md

@@ -91,8 +91,12 @@ The images below are committed visual-regression baselines from the real
 - **Product-native UI** — Complete Office-style surfaces with no required
   backend, account system, or storage model.
 - **Accessible responsive shell** — Compact sidebars, slide navigation, AI
-  panes, dialogs, menus, and popovers share bounded keyboard navigation,
-  background isolation, topmost Escape handling, and focus restoration.
+  panes, responsive chart inspectors, dialogs, menus, and popovers share
+  bounded keyboard navigation, background isolation, topmost Escape handling,
+  and focus restoration.
+  Persistent desktop navigation and the temporary phone drawer keep separate
+  open states, so live breakpoint changes never turn a desktop sidebar into an
+  unexpected blocking modal or steal focus from the workspace.
   Shared color palettes expand to an eight-column touch layout on phones while
   preserving spatial arrow-key navigation.
 - **Editor-scoped zoom** — Status controls and Ctrl/Cmd + mouse-wheel gestures
@@ -246,20 +250,76 @@ interaction model.
 
 - **Document** — Pagination, sections, focused page-setup tabs, clean page
   margins with on-demand header/footer editing, outline navigation with
-  contextual full-text results, styles,
+  contextual full-text results, keyboard-operated live physical-page raster
+  thumbnails with viewport-bounded capture, and shared virtualized
+  long-document windows for page buttons, heading rows, full-text results, and
+  tracked-revision and anchored-comment review that preserve native scroll
+  distance, sparse current/selection/draft pins, and Home/End reachability;
+  paragraph styles and phone-sized paragraph-spacing and pagination controls
+  with touch targets and exact invoker-focus restoration; stable compact-ribbon
+  edge paging and viewport-bounded list galleries with touch-sized numbering
+  actions, selection-preserving bullet and numbering commands, and explicit
+  Escape-to-invoker focus restoration;
   grouped bundled, common system, monospace, imported, and host-provided font
-  choices with live typeface previews, precision table sizing and autofit,
-  viewport-safe comment drafting,
-  focus-preserving comment review and citation drafts, tracked changes, notes,
+  choices with live typeface previews, independent table layout algorithms,
+  auto, percentage, or pixel preferred widths, left/center/right placement,
+  indentation, table-level cell margins, cell-level margin overrides, and
+  rendered column measurements for autofit tables. One Table Properties dialog
+  presents table, row, column, and cell tabs. It combines preferred width,
+  placement, and indent with selected-row height and pagination, current-column
+  width, and selected-cell vertical alignment and margins. The complete draft
+  commits in one TipTap transaction and one undo record while untouched imported
+  measurements and partial margin inheritance retain their exact source values.
+  Cancel and Escape discard the draft and restore the exact ribbon invoker;
+  compact layouts keep tabs, numeric steppers, and footer actions touch-sized. A
+  contextual Picture Properties workflow combines centimeter width and height,
+  a per-image aspect-ratio lock, inline/square/top-and-bottom wrapping,
+  alignment, text distance, and alternative text. It commits only changed
+  fields in one TipTap history entry, preserves untouched imported dimensions
+  exactly, and retains the image selection and invoker focus after apply,
+  cancel, or Escape on desktop and phone layouts. A
+  reusable table-border pen with all, outside, inside, and individual-edge
+  targets, per-edge DOCX border preservation, and bounded `basedOn` table-style
+  inheritance with whole-table, banded row or column, first/last row or column,
+  and corner-cell formatting. Conditional fills, borders, bold, italic,
+  underline, strikethrough, fonts, and text colors are materialized before
+  direct table, cell, paragraph, and run formatting. Conditional paragraph
+  alignment, direction, indents, spacing and line rules, pagination rules, and
+  tab stops use the same precedence chain. Theme tint and shade values resolve
+  for table borders and cell fills across edit, preview, and RGB-stable export.
+  Splittable table rows that exceed a full physical page
+  continue at paragraph boundaries with repeated heading rows on every page,
+  viewport-safe comment drafting and focus-preserving citation drafts, tracked
+  changes, notes,
   pointer- and Shift+F10-accessible host-defined selection menus, and shared
   edit/preview/PDF typography and page-chrome placement. Editing, read-only
-  preview, and browser PDF export share one live pagination result.
+  preview, and browser PDF export share one live pagination result. Tail edits
+  reuse the stable physical-page prefix, including resolved first/odd/even
+  headers, footers, page numbers, and navigation descriptors.
+  Real DOCX fixtures provide deterministic A3S Test evidence for inherited
+  table styling across edit and preview, a centered 62.5% table with table and
+  cell margin overrides, all four Table Properties tabs at 390 px, exact
+  preservation of untouched cell-margin edges, a complete 390 px Picture
+  Properties flow, and a 120-paragraph row across three physical pages through
+  the final table content and following paragraph.
+  A direct-formatting A4 fixture also runs through a real WPS Writer PDF export
+  and a page-only browser comparison. Its automatic line spacing, paragraph
+  gaps, centered fixed table, row heights, borders, fills, and cell margins
+  stay within the checked one-pixel layout-landmark budget while preserving
+  the original OOXML line multiples for DOCX export.
+  Separate 30-row common-font, 36-row CJK-font, and 18-row document-grid
+  matrices now gate text-band positions against WPS. The browser keeps the
+  measured per-font automatic-line advance, while DOCX round trips retain the
+  section `docGrid` type and line pitch and each run's `snapToGrid` override.
   _DOCX import/export; PDF export._
 - **Markdown** — GFM source, visual editing, synchronized and resizable split
   preview, source-native undo/redo with typing coalescing and selection restore,
   source-aware ribbon formatting and shortcuts, empty-source guidance, task
-  lists, tables, links, images, code, and keyboard-accessible host-defined
-  selection menus across both editing surfaces. _Markdown import/export._
+  lists, tables, links, images, code, a flat reading surface with a comfortable
+  line length, and keyboard-accessible host-defined selection menus across both
+  editing surfaces. At phone widths, Source and Preview each use the complete
+  workspace instead of being compressed into two stacked panes. _Markdown
+  import/export._
 - **Spreadsheet** — Multiple sheets, formulas, dependency-aware recalculation,
   live selection statistics, an A3S-owned worksheet bar with lifecycle and
   color controls, safe deletion confirmation, in-place rename validation, a
@@ -269,11 +329,15 @@ interaction model.
   PageUp/PageDown, row, column, and all-cells selection shortcuts, Cmd/Ctrl
   formatting through root-scoped capture before vendor grid listeners, an
   editor-owned Cmd/Ctrl+F search bar that finds displayed values, raw values,
-  formulas, and sparse cells without opening browser Find,
+  formulas, and sparse cells without opening browser Find, with a viewport-safe
+  phone layout, touch-sized controls, and exact grid-focus restoration,
+  desktop workbook task panes that become focus-contained phone dialogs with
+  an inert workbook background and exact ribbon-invoker restoration,
   Shift+F11 creation, Ctrl/Cmd+PageUp/PageDown switching in edit and read-only
   preview,
   one shared cell/worksheet context-menu surface with executable shortcut
-  hints, keyboard-operated cells and sheet tabs, direct type-to-edit,
+  hints that becomes a touch-sized, scrollable bottom action sheet on phones,
+  keyboard-operated cells and sheet tabs, direct type-to-edit,
   permission-resilient multi-cell cut/copy/paste, clear, F2 editing, and
   focus-safe Escape behavior, direct
   font-family, vertical-alignment, text-wrap, number/percent, and decimal
@@ -283,9 +347,13 @@ interaction model.
   transforms, keyboard-accessible table-size insertion, Shift+F10-accessible
   native slide and object context actions, guides, comments, transitions,
   editor-scoped formatting and clipboard shortcuts that restore the selected
-  object, a dismissible phone slide navigator, a top-aligned phone canvas with
-  a priority-aware status bar, one-step slideshow from the beginning or current
-  slide, keyboard-complete playback, and a responsive presenter view with one
+  object, a docked desktop chart inspector that becomes a focus-contained modal
+  surface whenever it overlays the canvas, docked desktop comment review that
+  becomes a readable, touch-sized, focus-contained full-editor modal on phones
+  with dirty-draft cancellation and exact invoker restoration, a dismissible
+  phone slide navigator, a top-aligned phone canvas with a priority-aware status
+  bar, one-step slideshow from the beginning or current slide,
+  keyboard-complete playback, and a responsive presenter view with one
   navigation strip, current/next context, speaker notes, and a session timer.
   _PPTX import/export; PDF export._
 - **PDF** — PDFium rendering, navigation, search, form filling, annotations,
@@ -389,8 +457,8 @@ CLI, MCP, the typed Rust API, and the packaged Office Skill share the same
 bounded contracts. They inspect and modify files without launching desktop
 Office or scraping editor UI.
 
-Read the [native engine design](docs/native-office-engine.md), the complete
-[CLI reference](docs/cli-reference.md), or the published
+Read the [native engine design](docs/latest/en/native-office-engine.md), the
+complete [CLI reference](docs/latest/en/cli-reference.md), or the published
 [CLI and Skill guide](https://a3s-lab.github.io/Office/docs/automation/).
 
 ## Architecture
@@ -408,7 +476,8 @@ PDFium provider for read-only PDF page evidence. Both planes expose typed
 contracts; neither requires an A3S backend.
 
 For engine ownership, Worker/WASM boundaries, delivery stages, and performance
-gates, see [Browser editor architecture](docs/browser-editor-architecture.md).
+gates, see
+[Browser editor architecture](docs/latest/en/browser-editor-architecture.md).
 
 ## Project status
 
@@ -420,7 +489,7 @@ The project targets predictable browser editing and file preservation, not
 pixel parity with every Microsoft Office or WPS feature. Unsupported OOXML
 semantics and fidelity gaps remain explicit compatibility boundaries instead
 of being silently approximated. Track product depth and release evidence in
-the [editor quality roadmap](docs/editor-quality-roadmap.md).
+the [editor quality roadmap](docs/latest/en/editor-quality-roadmap.md).
 
 ## Development
 
@@ -442,18 +511,23 @@ committed visual contracts; see [CONTRIBUTING.md](CONTRIBUTING.md).
 ## Documentation
 
 The published website keeps the interactive Playground at its root and builds
-the searchable Rspress documentation center under `/docs/`. Both surfaces use
-the same deployment base, so preview, Pages, and fork deployments keep working
+the searchable Rspress documentation center under `/docs/`. Simplified Chinese
+is the stable default, English remains available from the language menu, and
+the version menu switches between `latest` and frozen release documentation.
+Search is scoped to the active language and version. Both surfaces use the
+same deployment base, so preview, Pages, and fork deployments keep working
 without hard-coded return URLs.
 
 - [Live Playground](https://a3s-lab.github.io/Office/)
 - [Documentation center](https://a3s-lab.github.io/Office/docs/)
+- [A3S Office 0.2.0 documentation](https://a3s-lab.github.io/Office/docs/0.2.0/)
+- [A3S Office 0.1.0 documentation](https://a3s-lab.github.io/Office/docs/0.1.0/)
 - [React, Vue, and Web Component integration](https://a3s-lab.github.io/Office/docs/components/)
 - [Office CLI and coding-agent Skill](https://a3s-lab.github.io/Office/docs/automation/)
-- [Browser editor architecture](docs/browser-editor-architecture.md)
-- [Native Office engine](docs/native-office-engine.md)
-- [CLI reference](docs/cli-reference.md)
-- [Editor quality roadmap](docs/editor-quality-roadmap.md)
+- [Browser editor architecture](docs/latest/en/browser-editor-architecture.md)
+- [Native Office engine](docs/latest/en/native-office-engine.md)
+- [CLI reference](docs/latest/en/cli-reference.md)
+- [Editor quality roadmap](docs/latest/en/editor-quality-roadmap.md)
 - [Changelog](CHANGELOG.md)
 
 ## Community and security

package/dist/0~2582.js

@@ -0,0 +1,485 @@
+import { Extension } from "@tiptap/core";
+import { TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
+import { NodeSelection } from "@tiptap/pm/state";
+import { CellSelection } from "@tiptap/pm/tables";
+import { renderDocumentTableBorders, setSelectedDocumentTableBorders, normalizeTableColor, uniformDocumentTableBorder, documentTableBordersFromElement, normalizeDocumentTableBorderWidth, normalizeDocumentTableBorderStyle, documentTableBordersFromAttributes, normalizeDocumentTableCellMarginOverrides, renderDocumentTableCellMarginOverrides, documentTableCellMarginOverridesFromElement, uniformDocumentTableBorders } from "./0~4750.js";
+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,
+    borders: uniformDocumentTableBorders({
+        color: '#cfd5df',
+        style: 'solid',
+        width: 1
+    }),
+    margins: null
+};
+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),
+            setDocumentTableBorders: (target, border)=>(props)=>setSelectedDocumentTableBorders(props, target, border)
+        };
+    }
+});
+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);
+                const expectedBorder = {
+                    color: style.borderColor,
+                    style: style.borderStyle,
+                    width: style.borderWidth
+                };
+                const actualBorder = uniformDocumentTableBorder(actual.borders);
+                if (expected.backgroundColor !== actual.backgroundColor || !actualBorder || actualBorder.color !== expectedBorder.color || actualBorder.style !== expectedBorder.style || actualBorder.width !== expectedBorder.width) 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: ()=>({})
+        },
+        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: ()=>({})
+        },
+        borders: {
+            default: defaults.borders,
+            parseHTML: (element)=>documentTableBordersFromElement(element, {
+                    color: defaults.borderColor,
+                    style: defaults.borderStyle,
+                    width: defaults.borderWidth
+                }),
+            renderHTML: (attributes)=>renderDocumentTableBorders(formatFromAttributes(attributes, defaults).borders)
+        },
+        margins: {
+            default: defaults.margins,
+            parseHTML: (element)=>documentTableCellMarginOverridesFromElement(element),
+            renderHTML: (attributes)=>renderDocumentTableCellMarginOverrides(attributes.margins)
+        }
+    };
+}
+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)) continue;
+        const current = formatFromAttributes(cell.attrs);
+        const changesBorder = void 0 !== normalized.borderColor || void 0 !== normalized.borderStyle || void 0 !== normalized.borderWidth;
+        const nextBorder = {
+            color: normalized.borderColor ?? current.borderColor,
+            style: normalized.borderStyle ?? current.borderStyle,
+            width: normalized.borderWidth ?? current.borderWidth
+        };
+        if ('none' === nextBorder.style) nextBorder.width = 0;
+        transaction.setNodeMarkup(position, void 0, {
+            ...cell.attrs,
+            ...normalized,
+            ...changesBorder ? {
+                borderColor: nextBorder.color,
+                borderStyle: nextBorder.style,
+                borderWidth: nextBorder.width,
+                borders: uniformDocumentTableBorders(nextBorder)
+            } : {}
+        });
+    }
+    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;
+            const format = tableStyleCellFormat(style, cell, rowIndex);
+            const border = {
+                color: style.borderColor,
+                style: style.borderStyle,
+                width: style.borderWidth
+            };
+            transaction.setNodeMarkup(position, void 0, {
+                ...cell.attrs,
+                ...format,
+                borders: uniformDocumentTableBorders(border)
+            });
+        });
+    });
+    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;
+    }
+    if (void 0 !== patch.margins) if (null === patch.margins) normalized.margins = null;
+    else {
+        const margins = normalizeDocumentTableCellMarginOverrides(patch.margins);
+        if (!margins) return null;
+        normalized.margins = margins;
+    }
+    return normalized;
+}
+function formatFromAttributes(attributes, defaults = DEFAULT_DOCUMENT_TABLE_CELL_FORMAT) {
+    const fallbackBorder = {
+        color: normalizeTableColor(String(attributes.borderColor ?? '')) ?? defaults.borderColor,
+        style: normalizeDocumentTableBorderStyle(String(attributes.borderStyle ?? '')) ?? defaults.borderStyle,
+        width: normalizeDocumentTableBorderWidth(attributes.borderWidth) ?? defaults.borderWidth
+    };
+    if ('none' === fallbackBorder.style) fallbackBorder.width = 0;
+    const borders = documentTableBordersFromAttributes(attributes, fallbackBorder);
+    const representative = uniformDocumentTableBorder(borders) ?? borders.top;
+    return {
+        backgroundColor: normalizeTableColor(String(attributes.backgroundColor ?? '')) ?? defaults.backgroundColor,
+        verticalAlign: normalizeDocumentTableVerticalAlign(String(attributes.verticalAlign ?? '')) ?? defaults.verticalAlign,
+        borderColor: representative.color,
+        borderStyle: representative.style,
+        borderWidth: representative.width,
+        borders,
+        margins: normalizeDocumentTableCellMarginOverrides(attributes.margins)
+    };
+}
+function normalizeDocumentTableVerticalAlign(value) {
+    if ('top' === value || 'middle' === value || 'bottom' === value) return value;
+    if ('center' === value) return 'middle';
+    return null;
+}
+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;
+}
+export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentTableCell, DocumentTableFormatting, DocumentTableHeader, DocumentTableRow, activeDocumentTableStyle, canSetDocumentTableRowRepeatHeader, documentTableCellFormat, documentTableHorizontalAlignment, documentTableRowCantSplit, documentTableRowHeight, documentTableRowOptions, documentTableRowRepeats, normalizeDocumentTableRowHeightRule, normalizeDocumentTableVerticalAlign };