ados-rcm 1.1.512 → 1.1.514

package/dist/AModule/AComponents/AEditor/modules/tableUp/formats/table-row-format.d.ts

@@ -0,0 +1,25 @@
+import { Parchment as TypeParchment } from 'quill';
+import { TableCellValue, TableRowValue } from '../utils';
+import { ContainerFormat } from './container-format';
+import { TableCellFormat } from './table-cell-format';
+import { TableCellInnerFormat } from './table-cell-inner-format';
+export type SkipRowCount = number[] & {
+    skipRowNum?: number;
+};
+export declare class TableRowFormat extends ContainerFormat {
+    static blotName: "table-up-row";
+    static tagName: string;
+    static className: string;
+    static create(value: TableRowValue): HTMLElement;
+    children: TypeParchment.LinkedList<TableCellFormat>;
+    get rowId(): string;
+    get tableId(): string;
+    setHeight(value: string): void;
+    getCellByColId(colId: string, direction: 'next' | 'prev'): TableCellFormat | null;
+    insertCell(targetIndex: number, value: TableCellValue): SkipRowCount;
+    getCellByColumIndex(stopIndex: number): [null | TableCellFormat, number, number[]];
+    removeCell(targetIndex: number): SkipRowCount;
+    foreachCellInner(func: (tableCell: TableCellInnerFormat, index: number) => boolean | void): void;
+    checkMerge(): boolean;
+    optimize(context: Record<string, any>): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/formats/table-wrapper-format.d.ts

@@ -0,0 +1,14 @@
+import { ContainerFormat } from './container-format';
+export declare class TableWrapperFormat extends ContainerFormat {
+    scroll: any;
+    static blotName: "table-up";
+    static tagName: string;
+    static className: string;
+    static create(value: string): HTMLElement;
+    constructor(scroll: any, node: Node, _value: string);
+    get tableId(): string;
+    checkMerge(): boolean;
+    deleteAt(index: number, length: number): void;
+    remove(): void;
+    insertLineAround: () => void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/formats/utils.d.ts

@@ -0,0 +1 @@
+export declare const getValidCellspan: (value: any) => any;

package/dist/AModule/AComponents/AEditor/modules/tableUp/index.d.ts

@@ -0,0 +1,7 @@
+import { TableUp } from './table-up';
+export default TableUp;
+export * from './formats';
+export * from './modules';
+export * from './table-up';
+export { blotName, createColorPicker, createSelectBox, createTooltip, findParentBlot, findParentBlots, randomId, tableUpEvent, tableUpInternal, tableUpSize, } from './utils';
+export * from './utils/types';

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/index.d.ts

@@ -0,0 +1,6 @@
+export * from './table-align';
+export * from './table-clipboard';
+export * from './table-menu';
+export * from './table-resize';
+export * from './table-scrollbar';
+export * from './table-selection';

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-align.d.ts

@@ -0,0 +1,31 @@
+import { TableMainFormat, TableWrapperFormat } from '../formats';
+import { TableUp } from '../table-up';
+import { default as Quill } from 'quill';
+export declare class TableAlign {
+    tableModule: TableUp;
+    table: HTMLElement;
+    quill: Quill;
+    tableBlot: TableMainFormat;
+    tableWrapperBlot: TableWrapperFormat;
+    alignBox?: HTMLElement;
+    cleanup?: () => void;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    resizeObserver: ResizeObserver;
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill);
+    updateWhenTextChange: () => void;
+    buildTool(): HTMLElement;
+    setTableAlign(tableBlot: TableMainFormat, align: string): void;
+    show(): void;
+    hide(): void;
+    update(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-clipboard.d.ts

@@ -0,0 +1,42 @@
+import { Parchment as TypeParchment, default as Quill } from 'quill';
+import { Delta as TypeDelta } from 'quill/core';
+import { default as TypeClipboard } from 'quill/modules/clipboard';
+declare const Clipboard: typeof TypeClipboard;
+export type Selector = string | Node['TEXT_NODE'] | Node['ELEMENT_NODE'];
+export type Matcher = (node: Node, delta: TypeDelta, scroll: TypeParchment.ScrollBlot) => TypeDelta;
+export interface ClipboardOptions {
+    matchers: [Selector, Matcher][];
+}
+export declare class TableClipboard extends Clipboard {
+    quill: Quill;
+    tableId: string;
+    rowId: string;
+    colIds: string[];
+    rowspanCount: {
+        colspan: number;
+        rowspan: number;
+    }[];
+    cellCount: number;
+    colCount: number;
+    constructor(quill: Quill, options: Partial<ClipboardOptions>);
+    matchTable(node: Node, delta: TypeDelta): TypeDelta;
+    matchColgroup(node: Node, delta: TypeDelta): TypeDelta;
+    matchCol(node: Node): TypeDelta;
+    matchTr(node: Node, delta: TypeDelta): TypeDelta;
+    matchTd(node: Node, delta: TypeDelta): TypeDelta;
+    private handleBorderNoneStyles;
+    convert({ html, text }: {
+        html?: string;
+        text?: string;
+    }, formats?: Record<string, unknown>): TypeDelta;
+    private readonly STYLE_PROPERTIES;
+    private parseStyleWithFilter;
+    private mergeClassStylesToInline;
+    matchCaption(node: Node, delta: TypeDelta): TypeDelta;
+    private preprocessTableHtml;
+    private cleanupTableStyles;
+    private applyRowspanHeights;
+    private fixRowspanCells;
+    private processEmptyRows;
+}
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-menu/constants.d.ts

@@ -0,0 +1,12 @@
+import { Tool } from '../../utils';
+export declare const menuColorSelectClassName = "color-selector";
+export declare const tableMenuTools: Record<string, Tool>;
+export declare const maxSaveColorCount = 10;
+export declare const colorClassName: {
+    selectWrapper: string;
+    used: string;
+    item: string;
+    btn: string;
+    map: string;
+    mapRow: string;
+};

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-menu/index.d.ts

@@ -0,0 +1,4 @@
+export { tableMenuTools } from './constants';
+export * from './table-menu-common';
+export * from './table-menu-contextmenu';
+export * from './table-menu-select';

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-menu/table-menu-common.d.ts

@@ -0,0 +1,43 @@
+import { default as Quill } from 'quill';
+import { TableUp } from '../../table-up';
+import { TableMenuOptions, ToolOption, TooltipInstance, ToolTipOptions } from '../../utils';
+export type TableMenuOptionsInput = Partial<Omit<TableMenuOptions, 'texts'>>;
+export interface MenuTooltipInstance extends TooltipInstance {
+    isColorPick?: boolean;
+}
+export declare class TableMenuCommon {
+    tableModule: TableUp;
+    quill: Quill;
+    usedColors: Set<string>;
+    options: TableMenuOptions;
+    menu: HTMLElement | null;
+    isMenuDisplay: boolean;
+    isColorPicking: boolean;
+    updateUsedColor: (this: any, color?: string) => void;
+    tooltipItem: MenuTooltipInstance[];
+    activeTooltip: MenuTooltipInstance | null;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    colorItemClass: string;
+    colorChooseTooltipOption: ToolTipOptions;
+    constructor(tableModule: TableUp, quill: Quill, options: TableMenuOptionsInput);
+    updateWhenTextChange: () => void;
+    resolveOptions(options: TableMenuOptionsInput): TableMenuOptions;
+    buildTools(): HTMLElement;
+    createColorChoose(item: HTMLElement, { handle, key }: ToolOption): MenuTooltipInstance;
+    setActiveTooltip(tooltip: MenuTooltipInstance | null): void;
+    getSelectedTds(): import('../..').TableCellInnerFormat[];
+    createTipText(item: HTMLElement, text: string): void;
+    show(): void;
+    update(): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-menu/table-menu-contextmenu.d.ts

@@ -0,0 +1,21 @@
+import { default as Quill } from 'quill';
+import { TableUp } from '../../table-up';
+import { TableMenuOptions, ToolTipOptions } from '../../utils';
+import { TableMenuCommon } from './table-menu-common';
+type TableMenuOptionsInput = Partial<Omit<TableMenuOptions, 'texts'>>;
+export declare class TableMenuContextmenu extends TableMenuCommon {
+    tableModule: TableUp;
+    quill: Quill;
+    colorChooseTooltipOption: ToolTipOptions;
+    constructor(tableModule: TableUp, quill: Quill, options: TableMenuOptionsInput);
+    listenContextmenu: (e: MouseEvent) => void;
+    buildTools(): HTMLElement;
+    createTipText(item: HTMLElement, text: string): void;
+    show(): void;
+    update(position?: {
+        x: number;
+        y: number;
+    }): void;
+    destroy(): void;
+}
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-menu/table-menu-select.d.ts

@@ -0,0 +1,9 @@
+import { default as Quill } from 'quill';
+import { TableUp } from '../../table-up';
+import { TableMenuOptionsInput, TableMenuCommon } from './table-menu-common';
+export declare class TableMenuSelect extends TableMenuCommon {
+    tableModule: TableUp;
+    quill: Quill;
+    constructor(tableModule: TableUp, quill: Quill, options: TableMenuOptionsInput);
+    update(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/index.d.ts

@@ -0,0 +1,5 @@
+export * from './table-resize-box';
+export * from './table-resize-common';
+export * from './table-resize-line';
+export * from './table-resize-scale';
+export * from './utils';

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/table-resize-box.d.ts

@@ -0,0 +1,56 @@
+import { Parchment as TypeParchment, default as Quill } from 'quill';
+import { TableColFormat, TableMainFormat, TableRowFormat } from '../../formats';
+import { TableUp } from '../../table-up';
+import { sizeChangeValue, TableResizeCommon } from './table-resize-common';
+export declare class TableResizeBox extends TableResizeCommon {
+    tableModule: TableUp;
+    table: HTMLElement;
+    root: HTMLElement;
+    tableMain: TableMainFormat;
+    tableWrapper: TypeParchment.Parent;
+    resizeObserver: ResizeObserver;
+    tableCols: TableColFormat[];
+    tableRows: TableRowFormat[];
+    rowHeadWrapper: HTMLElement | null;
+    colHeadWrapper: HTMLElement | null;
+    corner: HTMLElement | null;
+    scrollHandler: [HTMLElement, (e: Event) => void][];
+    lastHeaderSelect: {
+        index: number;
+        isX: boolean;
+    } | null;
+    size: number;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill);
+    updateWhenTextChange: () => void;
+    handleResizerHeader(isX: boolean, index: number, e: MouseEvent): void;
+    findCurrentColIndex(e: MouseEvent): number;
+    colWidthChange(i: number, w: sizeChangeValue, isFull: boolean): void;
+    handleColMouseDownFunc: (e: MouseEvent) => {
+        height: number;
+        left: number;
+        top: number;
+    } | undefined;
+    bindColEvents(): void;
+    findCurrentRowIndex(e: MouseEvent): number;
+    rowHeightChange(i: number, h: number): void;
+    handleRowMouseDownFunc: (e: MouseEvent) => {
+        left: number;
+        top: number;
+        width: number;
+    } | undefined;
+    bindRowEvents(): void;
+    update(): void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/table-resize-common.d.ts

@@ -0,0 +1,79 @@
+import { default as Quill } from 'quill';
+import { TableUp } from '../../table-up';
+import { TableMainFormat } from '../../formats';
+export interface sizeChangeValue {
+    pre: number;
+    px: number;
+}
+export declare class TableResizeCommon {
+    tableModule: TableUp;
+    quill: Quill;
+    colIndex: number;
+    tableMain?: TableMainFormat;
+    dragging: boolean;
+    dragColBreak: HTMLElement | null;
+    handleColMouseUpFunc: () => Promise<void>;
+    handleColMouseMoveFunc: (e: MouseEvent) => {
+        left: number;
+        width: number;
+    } | undefined;
+    handleColMouseDownFunc: (e: MouseEvent) => {
+        height: number;
+        left: number;
+        top: number;
+    } | undefined;
+    rowIndex: number;
+    dragRowBreak: HTMLElement | null;
+    handleRowMouseUpFunc: () => void;
+    handleRowMouseMoveFunc: (e: MouseEvent) => {
+        height: number;
+        top: number;
+    } | undefined;
+    handleRowMouseDownFunc: (e: MouseEvent) => {
+        left: number;
+        top: number;
+        width: number;
+    } | undefined;
+    dragBEM: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    constructor(tableModule: TableUp, quill: Quill);
+    findCurrentColIndex(_e: MouseEvent): number;
+    colWidthChange(_i: number, _w: sizeChangeValue, _isFull: boolean): void;
+    createConfirmDialog({ message, confirm, cancel }: {
+        cancel: string;
+        confirm: string;
+        message: string;
+    }): Promise<boolean>;
+    handleColMouseUp(): Promise<void>;
+    handleColMouseMove(e: MouseEvent): {
+        left: number;
+        width: number;
+    } | undefined;
+    handleColMouseDown(e: MouseEvent): {
+        height: number;
+        left: number;
+        top: number;
+    } | undefined;
+    findCurrentRowIndex(_e: MouseEvent): number;
+    rowHeightChange(_i: number, _h: number): void;
+    handleRowMouseUp(): void;
+    handleRowMouseMove(e: MouseEvent): {
+        height: number;
+        top: number;
+    } | undefined;
+    handleRowMouseDown(e: MouseEvent): {
+        left: number;
+        top: number;
+        width: number;
+    } | undefined;
+    update(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/table-resize-line.d.ts

@@ -0,0 +1,39 @@
+import { TableUp } from '../../table-up';
+import { default as Quill } from 'quill';
+import { TableCellFormat } from '../../formats';
+import { TableResizeCommon } from './table-resize-common';
+export declare class TableResizeLine extends TableResizeCommon {
+    tableModule: TableUp;
+    table: HTMLElement;
+    colResizer: HTMLElement;
+    rowResizer: HTMLElement;
+    currentTableCell?: HTMLElement;
+    dragging: boolean;
+    curColIndex: number;
+    curRowIndex: number;
+    tableCellBlot?: TableCellFormat;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill);
+    mousemoveHandler: (e: MouseEvent) => void;
+    hideWhenTextChange: () => void;
+    findTableCell(e: MouseEvent): HTMLElement | null;
+    findCurrentColIndex(): number;
+    handleColMouseUpFunc: () => Promise<void>;
+    updateColResizer(): void;
+    findCurrentRowIndex(): number;
+    handleRowMouseUpFunc: () => void;
+    updateRowResizer(): void;
+    show(): void;
+    hide(): void;
+    update(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/table-resize-scale.d.ts

@@ -0,0 +1,40 @@
+import { TableUp } from '../../table-up';
+import { TableResizeScaleOptions } from '../../utils';
+import { default as Quill } from 'quill';
+import { TableMainFormat, TableWrapperFormat } from '../../formats';
+export declare class TableResizeScale {
+    tableModule: TableUp;
+    table: HTMLElement;
+    quill: Quill;
+    scrollHandler: [HTMLElement, (e: Event) => void][];
+    tableMainBlot: TableMainFormat | null;
+    tableWrapperBlot: TableWrapperFormat | null;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    startX: number;
+    startY: number;
+    offset: number;
+    options: TableResizeScaleOptions;
+    root?: HTMLElement;
+    block?: HTMLElement;
+    resizeobserver: ResizeObserver;
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill, options: Partial<TableResizeScaleOptions>);
+    updateWhenTextChange: () => void;
+    resolveOptions(options: Partial<TableResizeScaleOptions>): {
+        blockSize: number;
+    } & Partial<TableResizeScaleOptions>;
+    buildResizer(): void;
+    isTableOutofEditor(): boolean;
+    update(): void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/utils.d.ts

@@ -0,0 +1,2 @@
+import { TableMainFormat } from '../../formats';
+export declare const isTableAlignRight: (tableMainBlot: TableMainFormat) => boolean;

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-scrollbar.d.ts

@@ -0,0 +1,89 @@
+import { default as Quill } from 'quill';
+import { TableMainFormat } from '../formats';
+import { TableUp } from '../table-up';
+export declare class Scrollbar {
+    quill: Quill;
+    isVertical: boolean;
+    table: HTMLElement;
+    scrollbarContainer: HTMLElement;
+    minSize: number;
+    gap: number;
+    move: number;
+    cursorDown: boolean;
+    cursorLeave: boolean;
+    ratioY: number;
+    ratioX: number;
+    sizeWidth: string;
+    sizeHeight: string;
+    size: string;
+    thumbState: {
+        X: number;
+        Y: number;
+    };
+    ob: ResizeObserver;
+    container: HTMLElement;
+    scrollbar: HTMLElement;
+    thumb: HTMLElement;
+    scrollHandler: [HTMLElement, (e: Event) => void][];
+    propertyMap: {
+        readonly axis: 'Y';
+        readonly client: 'clientY';
+        readonly direction: 'top';
+        readonly offset: 'offsetHeight';
+        readonly scrollDirection: 'scrollTop';
+        readonly scrollSize: 'scrollHeight';
+        readonly size: 'height';
+    } | {
+        readonly axis: 'X';
+        readonly client: 'clientX';
+        readonly direction: 'left';
+        readonly offset: 'offsetWidth';
+        readonly scrollDirection: 'scrollLeft';
+        readonly scrollSize: 'scrollWidth';
+        readonly size: 'width';
+    };
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    tableMainBlot: TableMainFormat;
+    constructor(quill: Quill, isVertical: boolean, table: HTMLElement, scrollbarContainer: HTMLElement);
+    update(): void;
+    setScrollbarPosition(): void;
+    calculateSize(): void;
+    createScrollbar(): HTMLDivElement;
+    containerScrollHandler(wrap: HTMLElement): void;
+    showScrollbar: (this: any) => void;
+    hideScrollbar: (this: any) => void;
+    hideScrollbarTransitionend: () => void;
+    destroy(): void;
+}
+export declare class TableVirtualScrollbar {
+    tableModule: TableUp;
+    table: HTMLElement;
+    quill: Quill;
+    scrollbarContainer: HTMLElement;
+    scrollbar: Scrollbar[];
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill);
+    updateWhenTextChange: () => void;
+    hide(): void;
+    show(): void;
+    update(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-selection.d.ts

@@ -0,0 +1,87 @@
+import { EmitterSource, Range as TypeRange, default as Quill } from 'quill';
+import { TableUp } from '../table-up';
+import { InternalTableMenuModule, RelactiveRect, TableSelectionOptions } from '../utils';
+import { TableCellInnerFormat } from '../formats';
+export interface SelectionData {
+    anchorNode: Node | null;
+    anchorOffset: number;
+    focusNode: Node | null;
+    focusOffset: number;
+}
+export declare class TableSelection {
+    tableModule: TableUp;
+    quill: Quill;
+    options: TableSelectionOptions;
+    boundary: RelactiveRect | null;
+    startScrollX: number;
+    startScrollY: number;
+    selectedTableScrollX: number;
+    selectedTableScrollY: number;
+    selectedEditorScrollX: number;
+    selectedEditorScrollY: number;
+    selectedTds: TableCellInnerFormat[];
+    cellSelectWrap: HTMLElement;
+    cellSelect: HTMLElement;
+    dragging: boolean;
+    scrollHandler: [HTMLElement, (...args: any[]) => void][];
+    tableMenu?: InternalTableMenuModule;
+    resizeObserver: ResizeObserver;
+    table?: HTMLTableElement;
+    isDisplaySelection: boolean;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    lastSelection: SelectionData;
+    constructor(tableModule: TableUp, quill: Quill, options?: Partial<TableSelectionOptions>);
+    updateAfterEvent: () => void;
+    getFirstTextNode(dom: HTMLElement | Node): Node;
+    getLastTextNode(dom: HTMLElement | Node): Node;
+    getNodeTailOffset(node: Node): number;
+    quillSelectionChangeHandler: (range: TypeRange | null, _oldRange: TypeRange | null, source: EmitterSource) => void;
+    setSelectionData(selection: Selection, selectionData: SelectionData): void;
+    selectionDirectionUp(selection: SelectionData): boolean;
+    findWrapSelection(points: {
+        node: Node | null;
+        offset: number;
+    }[]): {
+        startNode: Node | null;
+        startOffset: number;
+        endNode: Node | null;
+        endOffset: number;
+    };
+    resolveOptions(options: Partial<TableSelectionOptions>): TableSelectionOptions;
+    selectionChangeHandler: () => void;
+    helpLinesInitial(): HTMLDivElement;
+    computeSelectedTds(startPoint: {
+        x: number;
+        y: number;
+    }, endPoint: {
+        x: number;
+        y: number;
+    }): TableCellInnerFormat[];
+    mouseDownHandler: (mousedownEvent: MouseEvent) => void;
+    updateWithSelectedTds(): void;
+    update(): void;
+    getQuillViewScroll(): {
+        x: number;
+        y: number;
+    };
+    getTableViewScroll(): {
+        x: number;
+        y: number;
+    };
+    setSelectionTable(table: HTMLTableElement | undefined): void;
+    removeCell: (e: KeyboardEvent) => void;
+    showDisplay(): void;
+    show(): void;
+    hideDisplay(): void;
+    hide(): void;
+    destroy(): void;
+}