@a3s-lab/office 0.1.0

package/dist/internal/features/work/work-document-pagination-dom.d.ts

@@ -0,0 +1,35 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { OfficeKernelLayoutBlock } from '../../kernel/office-kernel-protocol';
+import type { MeasuredDocumentLayoutBlock } from './work-document-pagination-types';
+import type { WorkDocumentSectionLayout } from './work-types';
+export declare function reusableDocumentLayoutBlocks(previous: readonly MeasuredDocumentLayoutBlock[], blockId: string, element: HTMLElement, nodeTo: number, dirtyFrom: number): MeasuredDocumentLayoutBlock[];
+export declare function isDocumentListNode(node: ProseMirrorNode): boolean;
+export declare function documentListChildId(listId: string, itemIndex: number, node: ProseMirrorNode, childIndex: number, nestedList?: boolean): string;
+export declare function verticalBlockStart(style: CSSStyleDeclaration): number;
+export declare function verticalBlockEnd(style: CSSStyleDeclaration): number;
+export declare function documentInlineOffsets(editor: Editor, element: HTMLElement): {
+    inlineOffsetLeft: number;
+    inlineOffsetRight: number;
+};
+export interface DocumentNodeParagraphPagination {
+    keepLines: boolean;
+    keepWithNext: boolean;
+    pageBreakBefore: boolean;
+    widowControl: boolean;
+}
+export declare function documentNodeParagraphPagination(node: ProseMirrorNode): DocumentNodeParagraphPagination;
+export declare function measuredDocumentBlock({ block, element, from, to, }: {
+    block: OfficeKernelLayoutBlock;
+    element: HTMLElement;
+    from: number;
+    to: number;
+}): MeasuredDocumentLayoutBlock;
+export declare function shouldKeepDocumentBlockTogether(node: ProseMirrorNode): boolean;
+export declare function documentPaginationLayoutKey(layout: WorkDocumentSectionLayout): string;
+export declare function documentBlockId(sectionPosition: number, index: number, position: number): string;
+export declare function outerHeight(element: HTMLElement | null): number;
+export declare function nonNegativePixels(value: string): number;
+export declare function positivePixels(value: string): number;
+export declare function finitePixels(value: string): number;
+export declare function elementForNode(editor: Editor, position: number): HTMLElement | null;

package/dist/internal/features/work/work-document-pagination-measurement.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from '@tiptap/core';
+import type { OfficeKernelPageMetrics, OfficeKernelTextLayoutParagraphResult } from '../../kernel/office-kernel-protocol';
+import type { DocumentPaginationSnapshot } from './work-document-pagination-types';
+import type { WorkDocumentSectionLayout } from './work-types';
+export declare function measureDocumentLayoutBlocks(editor: Editor, previous?: DocumentPaginationSnapshot | null, dirtyFrom?: number, textLayouts?: ReadonlyMap<string, OfficeKernelTextLayoutParagraphResult>, maximumFragmentedTableRowHeight?: number): DocumentPaginationSnapshot;
+export declare function documentPageMetrics(layout: WorkDocumentSectionLayout): OfficeKernelPageMetrics;
+export declare function documentPageBodyHeight(page: OfficeKernelPageMetrics): number;
+export declare function documentPaginationSurfaceHeight(pageCount: number, page: OfficeKernelPageMetrics): number;
+export declare function documentPageChromeHeights(editor: Editor): Pick<OfficeKernelPageMetrics, 'headerHeight' | 'footerHeight'>;

package/dist/internal/features/work/work-document-pagination-types.d.ts

@@ -0,0 +1,88 @@
+import type { OfficeKernelLayoutBlock, OfficeKernelLayoutBreak, OfficeKernelPageMetrics, OfficeKernelTextLayoutParagraph } from '../../kernel/office-kernel-protocol';
+import type { WorkDocumentSectionLayout } from './work-types';
+export interface DocumentPaginationVisualBreak extends OfficeKernelLayoutBreak {
+    position: number;
+    page: OfficeKernelPageMetrics;
+    inlineOffsetLeft: number;
+    inlineOffsetRight: number;
+    previousPageChrome?: DocumentPaginationVisualPageChrome;
+    nextPageChrome?: DocumentPaginationVisualPageChrome;
+    tableBreak?: DocumentTablePaginationBreak;
+}
+export interface DocumentPaginationVisualPageChrome {
+    variant: 'default' | 'even' | 'first';
+    headerHtml: string;
+    footerHtml: string;
+    showPageNumber: boolean;
+    pageNumber: number;
+}
+export interface DocumentPaginationSection {
+    id: string;
+    index: number;
+    position: number;
+    layout: WorkDocumentSectionLayout;
+}
+export interface DocumentTablePaginationBreak {
+    tableId: string;
+    columnCount: number;
+    colgroupHtml: string;
+    repeatedHeaderRowsHtml: string[];
+    repeatedHeaderOverlayHtml: string;
+    repeatHeaderHeight: number;
+    tableWidth: number;
+    leadingCellOffsetLeft: number;
+    cellBreaks?: DocumentTableCellPageBreak[];
+}
+export interface DocumentTableCellBoundary {
+    position: number;
+    y: number;
+}
+export interface DocumentTableCellFragmentMeasurement {
+    cellIndex: number;
+    from: number;
+    to: number;
+    boundaries: DocumentTableCellBoundary[];
+    tableOffsetLeft?: number;
+    outerWidth?: number;
+    contentOffsetLeft?: number;
+}
+export interface DocumentTableCellPageBreak {
+    cellIndex: number;
+    position: number;
+    alignmentOffset: number;
+    tableOffsetLeft?: number;
+    outerWidth?: number;
+    contentOffsetLeft?: number;
+}
+export interface DocumentTableRowFragmentPlan {
+    height: number;
+    cellRanges: Array<{
+        from: number;
+        to: number;
+    }>;
+    cellBreaks?: DocumentTableCellPageBreak[];
+}
+export interface MeasuredDocumentLayoutBlock {
+    block: OfficeKernelLayoutBlock;
+    element: HTMLElement;
+    from: number;
+    to: number;
+    inlineOffsetLeft: number;
+    inlineOffsetRight: number;
+    observeResize: boolean;
+    section?: DocumentPaginationSection;
+    tableBreak?: DocumentTablePaginationBreak;
+    selectionRanges?: Array<{
+        from: number;
+        to: number;
+    }>;
+}
+export interface DocumentPaginationSnapshot {
+    blocks: MeasuredDocumentLayoutBlock[];
+    measuredBlockCount: number;
+    reusedBlockCount: number;
+    unsupportedLayout: boolean;
+}
+export interface DocumentTextLayoutCollection {
+    paragraphs: OfficeKernelTextLayoutParagraph[];
+}

package/dist/internal/features/work/work-document-pagination.d.ts

@@ -0,0 +1,17 @@
+import { Extension } from '@tiptap/core';
+import type { DocumentPaginationVisualBreak } from './work-document-pagination-types';
+export { createDocumentLineFragments, createShapedDocumentLineFragments, findDocumentLineStartOffset, } from './work-document-line-measurement';
+export { reusableDocumentLayoutBlocks } from './work-document-pagination-dom';
+export { documentPageBodyHeight, documentPageChromeHeights, documentPageMetrics, documentPaginationSurfaceHeight, measureDocumentLayoutBlocks, } from './work-document-pagination-measurement';
+export type { DocumentPaginationSection, DocumentPaginationSnapshot, DocumentPaginationVisualBreak, DocumentPaginationVisualPageChrome, DocumentTableCellBoundary, DocumentTableCellFragmentMeasurement, DocumentTableCellPageBreak, DocumentTablePaginationBreak, DocumentTableRowFragmentPlan, DocumentTextLayoutCollection, MeasuredDocumentLayoutBlock, } from './work-document-pagination-types';
+export { createDocumentTableRowFragmentPlan } from './work-document-table-pagination';
+export { collectDocumentTextLayoutParagraphs, collectDocumentTextLayoutRuns, } from './work-document-text-layout';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentPagination: {
+            applyDocumentPagination: (revision: number, breaks: DocumentPaginationVisualBreak[]) => ReturnType;
+            clearDocumentPagination: (revision: number) => ReturnType;
+        };
+    }
+}
+export declare const DocumentPagination: Extension<any, any>;

package/dist/internal/features/work/work-document-paragraph-formatting.d.ts

@@ -0,0 +1,61 @@
+import { Extension, type Editor } from '@tiptap/core';
+export declare const DOCUMENT_INDENT_STEP_PX = 24;
+export declare const MAX_DOCUMENT_INDENT_LEVEL = 8;
+export declare const DOCUMENT_RULER_INDENT_STEP_PX = 6;
+export declare const MAX_DOCUMENT_INDENT_PX: number;
+export interface DocumentParagraphIndent {
+    left: number;
+    right: number;
+    firstLine: number;
+}
+export interface DocumentParagraphPagination {
+    keepLines: boolean;
+    keepWithNext: boolean;
+    pageBreakBefore: boolean;
+    widowControl: boolean;
+}
+export type DocumentParagraphPaginationUpdate = Partial<DocumentParagraphPagination>;
+export type DocumentParagraphDirection = 'ltr' | 'rtl';
+export type DocumentParagraphLineRule = 'auto' | 'exact' | 'atLeast';
+export interface DocumentParagraphSpacing {
+    before: number | null;
+    after: number | null;
+    lineHeight: string | null;
+    lineRule: DocumentParagraphLineRule | null;
+}
+export interface DocumentFormattingCommandOptions {
+    restoreFocus?: boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentParagraphFormatting: {
+            changeDocumentIndent: (direction: -1 | 1) => ReturnType;
+            clearDocumentParagraphPagination: (options?: DocumentFormattingCommandOptions) => ReturnType;
+            clearDocumentFormatting: () => ReturnType;
+            setDocumentIndentLevel: (indentLevel: number, options?: DocumentFormattingCommandOptions) => ReturnType;
+            setDocumentLineHeight: (lineHeight: string | null) => ReturnType;
+            setDocumentParagraphDirection: (direction: DocumentParagraphDirection, options?: DocumentFormattingCommandOptions) => ReturnType;
+            setDocumentParagraphIndent: (indent: DocumentParagraphIndent, options?: DocumentFormattingCommandOptions) => ReturnType;
+            setDocumentParagraphPagination: (pagination: DocumentParagraphPaginationUpdate, options?: DocumentFormattingCommandOptions) => ReturnType;
+            setDocumentParagraphSpacing: (spacing: DocumentParagraphSpacing, options?: DocumentFormattingCommandOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentParagraphFormatting: Extension<any, any>;
+export declare function setDocumentLineHeight(editor: Editor, lineHeight: string | null): boolean;
+export declare function changeDocumentIndent(editor: Editor, direction: -1 | 1): boolean;
+export declare function canChangeDocumentIndent(editor: Editor, direction: -1 | 1): boolean;
+export declare function documentIndentLevel(editor: Editor): number;
+export declare function documentParagraphIndent(editor: Editor): DocumentParagraphIndent;
+export declare function setDocumentIndentLevel(editor: Editor, indentLevel: number, options?: DocumentFormattingCommandOptions): boolean;
+export declare function setDocumentParagraphIndent(editor: Editor, indent: DocumentParagraphIndent, options?: DocumentFormattingCommandOptions): boolean;
+export declare function documentParagraphPagination(editor: Editor): DocumentParagraphPagination;
+export declare function documentParagraphDirection(editor: Editor): DocumentParagraphDirection;
+export declare function setDocumentParagraphDirection(editor: Editor, direction: DocumentParagraphDirection, options?: DocumentFormattingCommandOptions): boolean;
+export declare function setDocumentParagraphPagination(editor: Editor, pagination: DocumentParagraphPaginationUpdate, options?: DocumentFormattingCommandOptions): boolean;
+export declare function clearDocumentParagraphPagination(editor: Editor, options?: DocumentFormattingCommandOptions): boolean;
+export declare function documentParagraphSpacing(editor: Editor): DocumentParagraphSpacing;
+export declare function setDocumentParagraphSpacing(editor: Editor, spacing: DocumentParagraphSpacing, options?: DocumentFormattingCommandOptions): boolean;
+export declare function normalizeDocumentParagraphIndent(indent: DocumentParagraphIndent): DocumentParagraphIndent;
+export declare function normalizeDocumentParagraphDirection(value: unknown): DocumentParagraphDirection | null;
+export declare function clearDocumentFormatting(editor: Editor): boolean;

package/dist/internal/features/work/work-document-search.d.ts

@@ -0,0 +1,11 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+export interface DocumentTextMatch {
+    from: number;
+    to: number;
+    before: string;
+    matchedText: string;
+    after: string;
+    truncatedBefore: boolean;
+    truncatedAfter: boolean;
+}
+export declare function documentTextMatches(document: ProseMirrorNode, rawQuery: string): DocumentTextMatch[];

package/dist/internal/features/work/work-document-section-editor.d.ts

@@ -0,0 +1,20 @@
+import type { CommandProps, Editor } from '@tiptap/core';
+import { type Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { WorkDocumentSectionBreakType, WorkDocumentSectionLayout } from './work-types';
+export interface ActiveDocumentSection {
+    id: string;
+    index: number;
+    count: number;
+    position: number;
+    node: ProseMirrorNode;
+    layout: WorkDocumentSectionLayout;
+}
+type DocumentSectionCommandContext = Pick<CommandProps, 'state' | 'tr'>;
+export declare function activeDocumentSection(editor: Editor): ActiveDocumentSection | null;
+export declare function activeDocumentSectionFromState(state: Editor['state']): ActiveDocumentSection | null;
+export declare function updateActiveDocumentSection(layout: WorkDocumentSectionLayout, commandContext: DocumentSectionCommandContext): boolean;
+export declare function documentSectionById(editor: Editor, sectionId: string): ActiveDocumentSection | null;
+export declare function updateDocumentSection(sectionId: string, layout: WorkDocumentSectionLayout, commandContext: DocumentSectionCommandContext): boolean;
+export declare function insertDocumentSection(editor: Editor, breakAfter: WorkDocumentSectionBreakType, commandContext: DocumentSectionCommandContext): boolean;
+export declare function mergeDocumentSectionWithPrevious(_editor: Editor, commandContext: DocumentSectionCommandContext): boolean;
+export {};

package/dist/internal/features/work/work-document-section-node.d.ts

@@ -0,0 +1,13 @@
+import { Node } from '@tiptap/core';
+import type { WorkDocumentSectionBreakType, WorkDocumentSectionLayout } from './work-types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentSection: {
+            insertDocumentSection: (breakAfter?: WorkDocumentSectionBreakType) => ReturnType;
+            mergeDocumentSectionWithPrevious: () => ReturnType;
+            updateActiveDocumentSection: (layout: WorkDocumentSectionLayout) => ReturnType;
+            updateDocumentSection: (sectionId: string, layout: WorkDocumentSectionLayout) => ReturnType;
+        };
+    }
+}
+export declare const DocumentSection: Node<any, any>;

package/dist/internal/features/work/work-document-section.d.ts

@@ -0,0 +1,34 @@
+import type { WorkDocumentContent, WorkDocumentSectionBreakType, WorkDocumentSectionLayout } from './work-types';
+export interface WorkDocumentSection {
+    id: string;
+    layout: WorkDocumentSectionLayout;
+    html: string;
+}
+export interface DocumentSectionNodeAttributes {
+    id: string;
+    pageSize: WorkDocumentSectionLayout['pageSize'];
+    orientation: WorkDocumentSectionLayout['orientation'];
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+    marginLeft: number;
+    columnCount: number;
+    columnSpacing: number;
+    columnSeparator: boolean;
+    columnLayout: string;
+    breakAfter: WorkDocumentSectionBreakType;
+    headerText: string;
+    footerText: string;
+    showPageNumbers: boolean;
+    pageNumberStart: number | null;
+    pageChrome: string;
+}
+export declare function documentInitialSectionLayout(content: WorkDocumentContent): WorkDocumentSectionLayout;
+export declare function normalizeDocumentHtml(content: WorkDocumentContent): string;
+export declare function documentSections(content: WorkDocumentContent): WorkDocumentSection[];
+export declare function documentSectionNodeAttributes(layout: WorkDocumentSectionLayout, id: string): DocumentSectionNodeAttributes;
+export declare function documentSectionLayoutFromNodeAttributes(attributes: Partial<DocumentSectionNodeAttributes>, fallback?: WorkDocumentSectionLayout): WorkDocumentSectionLayout;
+export declare function documentSectionDomAttributes(layout: WorkDocumentSectionLayout, id: string): Record<string, string>;
+export declare function documentSectionLayoutFromElement(element: HTMLElement, fallback: WorkDocumentSectionLayout): WorkDocumentSectionLayout;
+export declare function syncDocumentContentFromHtml(content: WorkDocumentContent, html: string): WorkDocumentContent;
+export declare function documentContentLayoutProperties(layout: WorkDocumentSectionLayout): Omit<WorkDocumentContent, 'type' | 'html'>;

package/dist/internal/features/work/work-document-selection-menu.d.ts

@@ -0,0 +1,54 @@
+import type { Editor } from '@tiptap/core';
+import type { WorkDocumentContent, WorkDocumentNode } from './work-types';
+export type WorkDocumentSelectionMenuIcon = 'copy' | 'language' | 'message' | 'quote' | 'sparkles' | 'wand';
+export interface WorkDocumentSelectionSnapshot {
+    selection: {
+        from: number;
+        to: number;
+        text: string;
+        rawText: string;
+        beforeText: string;
+        afterText: string;
+        model: WorkDocumentNode;
+    };
+    document: {
+        content: WorkDocumentContent;
+        html: string;
+        text: string;
+    };
+}
+export type WorkDocumentSelectionCommandFailure = 'command-rejected' | 'editor-unavailable' | 'invalid-text' | 'read-only' | 'stale-selection';
+export type WorkDocumentSelectionCommandResult = {
+    applied: true;
+} | {
+    applied: false;
+    reason: WorkDocumentSelectionCommandFailure;
+};
+export interface WorkDocumentSelectionCommands {
+    copyText(): Promise<boolean>;
+    insertAfter(text: string): WorkDocumentSelectionCommandResult;
+    insertBefore(text: string): WorkDocumentSelectionCommandResult;
+    replaceText(text: string): WorkDocumentSelectionCommandResult;
+}
+export interface WorkDocumentSelectionContext extends WorkDocumentSelectionSnapshot {
+    commands: WorkDocumentSelectionCommands;
+}
+export interface WorkDocumentSelectionMenuItem {
+    id: string;
+    label: string;
+    icon?: WorkDocumentSelectionMenuIcon;
+    shortcut?: string;
+    ariaKeyShortcut?: string;
+    danger?: boolean;
+    disabled?: boolean;
+    separatorBefore?: boolean;
+    onSelect(context: WorkDocumentSelectionContext): void | Promise<void>;
+}
+export type WorkGetDocumentSelectionMenuItems = (context: WorkDocumentSelectionSnapshot) => readonly WorkDocumentSelectionMenuItem[];
+export interface WorkDocumentSelectionAction {
+    context: WorkDocumentSelectionContext;
+    dispose(): void;
+}
+export declare function createWorkDocumentSelectionSnapshot(editor: Editor, content: WorkDocumentContent): WorkDocumentSelectionSnapshot | null;
+export declare function createWorkDocumentSelectionAction(editor: Editor, snapshot: WorkDocumentSelectionSnapshot, getTrackChanges: () => boolean): WorkDocumentSelectionAction;
+export declare function documentPlainTextAsHtml(value: string): string;

package/dist/internal/features/work/work-document-tab-node.d.ts

@@ -0,0 +1,6 @@
+import { Node as TiptapNode } from '@tiptap/core';
+import { type DocumentTabLeader, type DocumentTabStop } from './work-document-tab-stops';
+export declare const DocumentTab: TiptapNode<any, any>;
+export declare function layoutDocumentTabs(root: HTMLElement): void;
+export declare function nextDocumentTabStop(tabStops: readonly DocumentTabStop[], currentPosition: number): DocumentTabStop;
+export declare function documentTabLeaderLabel(leader: DocumentTabLeader): string;

package/dist/internal/features/work/work-document-tab-stops.d.ts

@@ -0,0 +1,29 @@
+import { Extension, type Editor } from '@tiptap/core';
+export declare const DEFAULT_DOCUMENT_TAB_INTERVAL_PX = 48;
+export declare const DOCUMENT_TAB_RULER_STEP_PX = 6;
+export declare const MAX_DOCUMENT_TAB_POSITION_PX = 4096;
+export declare const MAX_DOCUMENT_TAB_STOPS = 64;
+export type DocumentTabAlignment = 'left' | 'center' | 'right' | 'decimal';
+export type DocumentTabLeader = 'none' | 'dot' | 'hyphen' | 'underscore' | 'middleDot';
+export interface DocumentTabStop {
+    position: number;
+    alignment: DocumentTabAlignment;
+    leader: DocumentTabLeader;
+}
+export interface DocumentTabStopCommandOptions {
+    restoreFocus?: boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentParagraphTabStops: {
+            setDocumentParagraphTabStops: (tabStops: readonly DocumentTabStop[], options?: DocumentTabStopCommandOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentParagraphTabStops: Extension<any, any>;
+export declare function documentParagraphTabStops(editor: Editor): DocumentTabStop[];
+export declare function setDocumentParagraphTabStops(editor: Editor, tabStops: readonly DocumentTabStop[], options?: DocumentTabStopCommandOptions): boolean;
+export declare function normalizeDocumentTabStops(value: unknown): DocumentTabStop[];
+export declare function serializeDocumentTabStops(value: readonly DocumentTabStop[]): string;
+export declare function normalizedTabPosition(value: number): number;
+export declare function nextDocumentTabAlignment(alignment: DocumentTabAlignment): DocumentTabAlignment;

package/dist/internal/features/work/work-document-table-cell-formatting.d.ts

@@ -0,0 +1,46 @@
+import { Extension } from '@tiptap/core';
+import { type EditorState } from '@tiptap/pm/state';
+export type DocumentTableVerticalAlign = 'top' | 'middle' | 'bottom';
+export type DocumentTableHorizontalAlign = 'left' | 'center' | 'right';
+export type DocumentTableBorderStyle = 'solid' | 'dashed' | 'dotted' | 'double' | 'none';
+export interface DocumentTableCellFormat {
+    backgroundColor: string;
+    verticalAlign: DocumentTableVerticalAlign;
+    borderColor: string;
+    borderStyle: DocumentTableBorderStyle;
+    borderWidth: number;
+}
+export type DocumentTableCellFormatPatch = Partial<DocumentTableCellFormat>;
+export type DocumentTableStyleId = 'grid' | 'blueStripe' | 'greenStripe' | 'grayStripe' | 'clean';
+export interface DocumentTableStyleOption {
+    id: DocumentTableStyleId;
+    label: string;
+    headerColor: string;
+    bodyColor: string;
+    alternateColor: string;
+    borderColor: string;
+    borderStyle: DocumentTableBorderStyle;
+    borderWidth: number;
+}
+export declare const DOCUMENT_TABLE_STYLE_OPTIONS: readonly DocumentTableStyleOption[];
+export declare const DEFAULT_DOCUMENT_TABLE_CELL_FORMAT: DocumentTableCellFormat;
+export declare const DEFAULT_DOCUMENT_TABLE_HEADER_FORMAT: DocumentTableCellFormat;
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentTableFormatting: {
+            setDocumentTableCellFormat: (format: DocumentTableCellFormatPatch) => ReturnType;
+            setDocumentTableHorizontalAlignment: (alignment: DocumentTableHorizontalAlign) => ReturnType;
+            applyDocumentTableStyle: (style: DocumentTableStyleId) => ReturnType;
+        };
+    }
+}
+export declare const DocumentTableCell: import("@tiptap/core").Node<import("@tiptap/extension-table").TableCellOptions, any>;
+export declare const DocumentTableHeader: import("@tiptap/core").Node<import("@tiptap/extension-table").TableHeaderOptions, any>;
+export declare const DocumentTableFormatting: Extension<any, any>;
+export declare function documentTableCellFormat(state: EditorState): DocumentTableCellFormat | null;
+export declare function documentTableHorizontalAlignment(state: EditorState): DocumentTableHorizontalAlign;
+export declare function activeDocumentTableStyle(state: EditorState): DocumentTableStyleId | null;
+export declare function normalizeTableColor(value: string | null | undefined): string | null;
+export declare function normalizeDocumentTableVerticalAlign(value: string | null | undefined): DocumentTableVerticalAlign | null;
+export declare function normalizeDocumentTableBorderStyle(value: string | null | undefined): DocumentTableBorderStyle | null;
+export declare function normalizeDocumentTableBorderWidth(value: unknown): number | null;

package/dist/internal/features/work/work-document-table-commands.d.ts

@@ -0,0 +1,17 @@
+import { Extension } from '@tiptap/core';
+export interface DocumentTableDimensions {
+    rows: number;
+    columns: number;
+}
+export interface InsertDocumentTableOptions {
+    headerRow?: boolean;
+    restoreFocus?: boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentTableCommands: {
+            insertDocumentTable: (dimensions: DocumentTableDimensions, options?: InsertDocumentTableOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentTableCommands: Extension<any, any>;

package/dist/internal/features/work/work-document-table-pagination.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { DocumentTableCellFragmentMeasurement, DocumentTableRowFragmentPlan, MeasuredDocumentLayoutBlock } from './work-document-pagination-types';
+export declare function createDocumentTableRowFragmentPlan(cells: readonly DocumentTableCellFragmentMeasurement[], rowHeight: number, maximumFragmentedRowHeight: number): DocumentTableRowFragmentPlan[];
+export declare function measureDocumentTableRows(editor: Editor, tableNode: ProseMirrorNode, tableElement: HTMLElement, tableId: string, tableFrom: number, maximumFragmentedRowHeight: number): MeasuredDocumentLayoutBlock[];

package/dist/internal/features/work/work-document-table-row.d.ts

@@ -0,0 +1,37 @@
+import type { Editor } from '@tiptap/core';
+export interface DocumentTableRowOptions {
+    cantSplit: boolean;
+    repeatHeader: boolean;
+}
+export type DocumentTableRowHeightRule = 'atLeast' | 'exact';
+export interface SetDocumentTableRowCommandOptions {
+    restoreFocus?: boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentTableRow: {
+            setDocumentTableRowOptions: (options: DocumentTableRowOptions, commandOptions?: SetDocumentTableRowCommandOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentTableRow: import("@tiptap/core").Node<import("@tiptap/extension-table").TableRowOptions, any>;
+export declare function documentTableRowOptions(editor: Editor): DocumentTableRowOptions;
+export declare function canSetDocumentTableRowRepeatHeader(editor: Editor): boolean;
+export declare function documentTableRowRepeats(node: {
+    attrs: Record<string, unknown>;
+    childCount: number;
+    child(index: number): {
+        type: {
+            name: string;
+        };
+    };
+}): boolean;
+export declare function documentTableRowCantSplit(node: {
+    attrs: Record<string, unknown>;
+}): boolean;
+export declare function documentTableRowHeight(attributes: Record<string, unknown>): {
+    height: number | null;
+    rule: DocumentTableRowHeightRule | null;
+};
+export declare function normalizeDocumentTableRowHeight(value: unknown): number | null;
+export declare function normalizeDocumentTableRowHeightRule(value: unknown): DocumentTableRowHeightRule | null;

package/dist/internal/features/work/work-document-table-sizing.d.ts

@@ -0,0 +1,27 @@
+import { Extension } from '@tiptap/core';
+import { type EditorState } from '@tiptap/pm/state';
+import { type DocumentTableRowHeightRule } from './work-document-table-row';
+export type DocumentTableLayoutMode = 'window' | 'contents' | 'fixed';
+export interface DocumentTableSizingState {
+    columnWidth: number | null;
+    rowHeight: number | null;
+    rowHeightRule: DocumentTableRowHeightRule | null;
+    layoutMode: DocumentTableLayoutMode;
+    selectedColumnCount: number;
+    selectedRowCount: number;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentTableSizing: {
+            setDocumentTableColumnWidth: (width: number, renderedColumnWidths?: readonly number[]) => ReturnType;
+            setDocumentTableRowHeight: (height: number | null, rule?: DocumentTableRowHeightRule) => ReturnType;
+            setDocumentTableLayoutMode: (mode: DocumentTableLayoutMode, renderedTableWidth?: number) => ReturnType;
+            distributeDocumentTableColumns: (renderedSelectionWidth?: number) => ReturnType;
+            distributeDocumentTableRows: (renderedSelectionHeight?: number) => ReturnType;
+        };
+    }
+}
+export declare const DocumentTable: import("@tiptap/core").Node<import("@tiptap/extension-table").TableOptions, any>;
+export declare const DocumentTableSizing: Extension<any, any>;
+export declare function documentTableSizing(state: EditorState): DocumentTableSizingState | null;
+export declare function normalizeDocumentTableLayoutMode(value: unknown): DocumentTableLayoutMode;

package/dist/internal/features/work/work-document-text-layout.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { OfficeKernelTextLayoutRun } from '../../kernel/office-kernel-protocol';
+import type { WorkDocumentLayoutFont } from './work-document-fonts';
+import type { DocumentPaginationSnapshot, DocumentTextLayoutCollection } from './work-document-pagination-types';
+export declare function collectDocumentTextLayoutParagraphs(editor: Editor, fonts: readonly WorkDocumentLayoutFont[], loadedFontIds: ReadonlySet<string>, previous?: DocumentPaginationSnapshot | null, dirtyFrom?: number): DocumentTextLayoutCollection;
+export declare function isDocumentLineFragmentNode(node: ProseMirrorNode): boolean;
+export declare function documentTextLayoutContent(node: ProseMirrorNode): string | null;
+interface DocumentTextParagraphStyle {
+    direction: 'ltr' | 'rtl';
+    whiteSpace: 'breakSpaces' | 'normal';
+}
+export declare function collectDocumentTextLayoutRuns(element: HTMLElement, expectedText: string, fonts: readonly WorkDocumentLayoutFont[], loadedFontIds: ReadonlySet<string>, paragraphStyle?: DocumentTextParagraphStyle | null): OfficeKernelTextLayoutRun[] | null;
+export {};

package/dist/internal/features/work/work-docx-bibliography.d.ts

@@ -0,0 +1,12 @@
+import { type OoxmlPackage } from './work-ooxml-package';
+import type { WorkDocumentBibliography } from './work-types';
+export interface DocxBibliographyReadResult {
+    bibliography?: WorkDocumentBibliography;
+    sourcePartCount: number;
+    unreadablePartCount: number;
+    duplicateTags: string[];
+    uncommonSourceTypes: string[];
+    uncommonStyle?: string;
+}
+export declare function readDocxBibliography(archive: OoxmlPackage): Promise<DocxBibliographyReadResult>;
+export declare function patchDocxBibliography(buffer: ArrayBuffer, bibliography: WorkDocumentBibliography | undefined): Promise<ArrayBuffer>;

package/dist/internal/features/work/work-docx-caption-diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { WorkCompatibilityIssue } from './work-types';
+export interface DocxCaptionDiagnostics {
+    issues: WorkCompatibilityIssue[];
+    hasUnsupportedFields: boolean;
+}
+export declare function diagnoseDocxCaptions(document: Document): DocxCaptionDiagnostics;

package/dist/internal/features/work/work-docx-caption-export.d.ts

@@ -0,0 +1,4 @@
+import type { ParagraphChild } from 'docx';
+export declare function docxCaptionParagraph(element: HTMLElement, titleChildren: ParagraphChild[], docx: typeof import('docx'), bidirectional?: boolean): InstanceType<typeof docx.Paragraph>;
+export declare function docxCrossReferenceRuns(element: HTMLElement, docx: typeof import('docx')): ParagraphChild[];
+export declare function docxCaptionBookmarkId(source: string): string;

package/dist/internal/features/work/work-docx-caption-fields.d.ts

@@ -0,0 +1,5 @@
+import type { WorkDocumentCaptionKind } from './work-document-captions';
+import type { DocxFieldOccurrence } from './work-docx-field-instructions';
+export declare function docxCaptionSequenceKind(instruction: string): WorkDocumentCaptionKind | null;
+export declare function docxCaptionReferenceTarget(instruction: string): string | null;
+export declare function docxCaptionBookmark(paragraph: Element, field: DocxFieldOccurrence): Element | undefined;

package/dist/internal/features/work/work-docx-caption-import.d.ts

@@ -0,0 +1,20 @@
+import { type WorkDocumentCaptionKind } from './work-document-captions';
+export interface ImportedDocxCaptionMarkers {
+    captions: ImportedCaptionMarker[];
+    references: ImportedReferenceMarker[];
+}
+interface ImportedCaptionMarker {
+    start: string;
+    end: string;
+    id: string;
+    kind: WorkDocumentCaptionKind;
+}
+interface ImportedReferenceMarker {
+    start: string;
+    end: string;
+    targetId: string;
+}
+export declare function markDocxCaptionFields(document: Document): ImportedDocxCaptionMarkers;
+export declare function applyImportedDocxCaptionMarkers(document: Document, markers: ImportedDocxCaptionMarkers): void;
+export declare function hasImportedDocxCaptionMarkers(markers: ImportedDocxCaptionMarkers): boolean;
+export {};

package/dist/internal/features/work/work-docx-change-import.d.ts

@@ -0,0 +1,12 @@
+import type { WorkDocumentChangeIdentity, WorkDocumentChangeKind } from './work-document-changes';
+export interface ImportedDocxChangeMarker extends WorkDocumentChangeIdentity {
+    kind: WorkDocumentChangeKind;
+    start: string;
+    end: string;
+}
+export interface ImportedDocxChangeMarkers {
+    changes: ImportedDocxChangeMarker[];
+}
+export declare function markDocxTextChanges(document: Document): ImportedDocxChangeMarkers;
+export declare function applyImportedDocxChangeMarkers(document: Document, markers: ImportedDocxChangeMarkers): void;
+export declare function hasImportedDocxChangeMarkers(markers: ImportedDocxChangeMarkers): boolean;

package/dist/internal/features/work/work-docx-citation-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxCitations(archive: OoxmlPackage, document: Document): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-citation-export.d.ts

@@ -0,0 +1,3 @@
+import type { ParagraphChild } from 'docx';
+export declare function docxCitationRun(element: HTMLElement, docx: typeof import('docx')): ParagraphChild;
+export declare function docxBibliographyParagraph(element: HTMLElement, docx: typeof import('docx'), bidirectional?: boolean): InstanceType<typeof docx.Paragraph>;