@vervedoc/docx-editor-view 1.0.4

package/dist/index.d.ts

@@ -0,0 +1,1509 @@
+import { Command } from '@vervedoc/docx-editor-transform';
+import { ControlState } from '@vervedoc/docx-editor-schema';
+import { DeepPartial } from '@vervedoc/docx-editor-schema';
+import { DeepRequired } from '@vervedoc/docx-editor-schema';
+import { EditorMode } from '@vervedoc/docx-editor-schema';
+import { EditorZone } from '@vervedoc/docx-editor-schema';
+import { EventBus } from '@vervedoc/docx-editor-state';
+import { EventBusMap } from '@vervedoc/docx-editor-schema';
+import { IAppendElementListOption } from '@vervedoc/docx-editor-schema';
+import { IAreaBadge } from '@vervedoc/docx-editor-schema';
+import { IAreaInfo } from '@vervedoc/docx-editor-schema';
+import { IBadge } from '@vervedoc/docx-editor-schema';
+import { IChartRenderer } from '@vervedoc/docx-editor-schema';
+import { IComputePageRowPositionPayload } from '@vervedoc/docx-editor-schema';
+import { IComputePageRowPositionResult } from '@vervedoc/docx-editor-schema';
+import { IComputeRowListPayload } from '@vervedoc/docx-editor-schema';
+import { IComputeRowPositionPayload } from '@vervedoc/docx-editor-schema';
+import { IControl } from '@vervedoc/docx-editor-schema';
+import { IControlChangeOption } from '@vervedoc/docx-editor-schema';
+import { IControlContext } from '@vervedoc/docx-editor-schema';
+import { IControlHighlight } from '@vervedoc/docx-editor-schema';
+import { IControlHighlightRule } from '@vervedoc/docx-editor-schema';
+import { IControlInitOption } from '@vervedoc/docx-editor-schema';
+import { IControlInstance } from '@vervedoc/docx-editor-schema';
+import { IControlRuleOption } from '@vervedoc/docx-editor-schema';
+import { ICopyOption } from '@vervedoc/docx-editor-schema';
+import { ICurrentPosition } from '@vervedoc/docx-editor-schema';
+import { ICursorOption } from '@vervedoc/docx-editor-schema';
+import { IDestroyControlOption } from '@vervedoc/docx-editor-schema';
+import { IDrawOption } from '@vervedoc/docx-editor-schema';
+import { IDrawRowPayload } from '@vervedoc/docx-editor-schema';
+import { IEditorData } from '@vervedoc/docx-editor-schema';
+import { IEditorOption } from '@vervedoc/docx-editor-schema';
+import { IEditorResult } from '@vervedoc/docx-editor-schema';
+import { IElement } from '@vervedoc/docx-editor-schema';
+import { IElementFillRect } from '@vervedoc/docx-editor-schema';
+import { IElementPosition } from '@vervedoc/docx-editor-schema';
+import { IElementStyle } from '@vervedoc/docx-editor-schema';
+import { IFloatPosition } from '@vervedoc/docx-editor-schema';
+import { IGetAreaValueOption } from '@vervedoc/docx-editor-schema';
+import { IGetAreaValueResult } from '@vervedoc/docx-editor-schema';
+import { IGetControlValueOption } from '@vervedoc/docx-editor-schema';
+import { IGetControlValueResult } from '@vervedoc/docx-editor-schema';
+import { IGetFloatPositionByXYPayload } from '@vervedoc/docx-editor-schema';
+import { IGetImageOption } from '@vervedoc/docx-editor-schema';
+import { IGetOriginValueOption } from '@vervedoc/docx-editor-schema';
+import { IGetPositionByXYPayload } from '@vervedoc/docx-editor-schema';
+import { IGetValueOption } from '@vervedoc/docx-editor-schema';
+import { IInitNextControlOption } from '@vervedoc/docx-editor-schema';
+import { IInsertAreaOption } from '@vervedoc/docx-editor-schema';
+import { IInsertElementListOption } from '@vervedoc/docx-editor-schema';
+import { ILang } from '@vervedoc/docx-editor-schema';
+import { ILocationAreaOption } from '@vervedoc/docx-editor-schema';
+import { IMargin } from '@vervedoc/docx-editor-schema';
+import { INextControlContext } from '@vervedoc/docx-editor-schema';
+import { IPadding } from '@vervedoc/docx-editor-schema';
+import { IPainterOption } from '@vervedoc/docx-editor-schema';
+import { IPasteOption } from '@vervedoc/docx-editor-schema';
+import { IPlaceholder } from '@vervedoc/docx-editor-schema';
+import { IPositionContext } from '@vervedoc/docx-editor-schema';
+import { IPreviewerDrawOption } from '@vervedoc/docx-editor-schema';
+import { IRange } from '@vervedoc/docx-editor-schema';
+import { IRangeElementStyle } from '@vervedoc/docx-editor-schema';
+import { IRegisterShortcut } from '@vervedoc/docx-editor-schema';
+import { IRepaintControlOption } from '@vervedoc/docx-editor-schema';
+import { IReplaceOption } from '@vervedoc/docx-editor-schema';
+import { IRow } from '@vervedoc/docx-editor-schema';
+import { IRowElement } from '@vervedoc/docx-editor-schema';
+import { ISearchResult } from '@vervedoc/docx-editor-schema';
+import { ISetAreaPropertiesOption } from '@vervedoc/docx-editor-schema';
+import { ISetControlExtensionOption } from '@vervedoc/docx-editor-schema';
+import { ISetControlProperties } from '@vervedoc/docx-editor-schema';
+import { ISetControlRowFlexOption } from '@vervedoc/docx-editor-schema';
+import { ISetControlValueOption } from '@vervedoc/docx-editor-schema';
+import { ISetSurroundPositionPayload } from '@vervedoc/docx-editor-schema';
+import { ISetValueOption } from '@vervedoc/docx-editor-schema';
+import { ISpliceElementListOption } from '@vervedoc/docx-editor-schema';
+import { ITd } from '@vervedoc/docx-editor-schema';
+import { ITextMetrics } from '@vervedoc/docx-editor-schema';
+import { ITr } from '@vervedoc/docx-editor-schema';
+import { Listener } from '@vervedoc/docx-editor-state';
+import { ListStyle } from '@vervedoc/docx-editor-schema';
+import { ListType } from '@vervedoc/docx-editor-schema';
+import { MoveDirection } from '@vervedoc/docx-editor-schema';
+import { NumberType } from '@vervedoc/docx-editor-schema';
+import { PageMode } from '@vervedoc/docx-editor-schema';
+import { PaperDirection } from '@vervedoc/docx-editor-schema';
+import { PluginFunction } from '@vervedoc/docx-editor-schema';
+import { RangeManager } from '@vervedoc/docx-editor-state';
+import { TableBorder } from '@vervedoc/docx-editor-schema';
+import { TdBorder } from '@vervedoc/docx-editor-schema';
+import { TdSlash } from '@vervedoc/docx-editor-schema';
+import { TextDecorationStyle } from '@vervedoc/docx-editor-schema';
+import { VerticalAlign } from '@vervedoc/docx-editor-schema';
+
+export declare abstract class AbstractRichText {
+    protected fillRect: IElementFillRect;
+    protected fillColor?: string;
+    protected fillDecorationStyle?: TextDecorationStyle;
+    constructor();
+    clearFillInfo(): IElementFillRect;
+    recordFillInfo(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height?: number, color?: string, decorationStyle?: TextDecorationStyle): void;
+    abstract render(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare class Actuator {
+    constructor(..._: any[]);
+}
+
+export declare class Area {
+    private draw;
+    private zone;
+    private range;
+    private position;
+    private areaInfoMap;
+    constructor(draw: Draw);
+    getAreaInfo(): Map<string, IAreaInfo>;
+    getActiveAreaId(): string | null;
+    getActiveAreaInfo(): IAreaInfo | null;
+    isReadonly(): boolean;
+    insertArea(payload: IInsertAreaOption): string | null;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+    compute(): void;
+    getAreaValue(options?: IGetAreaValueOption): IGetAreaValueResult | null;
+    getContextByAreaId(areaId: string, options?: ILocationAreaOption): {
+        range: IRange;
+        elementPosition: IElementPosition;
+    } | null;
+    setAreaProperties(payload: ISetAreaPropertiesOption): void;
+}
+
+export declare class Background {
+    private draw;
+    private options;
+    private imageCache;
+    constructor(draw: Draw);
+    private _renderBackgroundColor;
+    private _drawImage;
+    private _renderBackgroundImage;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare class Badge {
+    private draw;
+    private options;
+    private imageCache;
+    private mainBadge;
+    private areaBadgeMap;
+    constructor(draw: Draw);
+    setMainBadge(payload: IBadge | null): void;
+    setAreaBadgeMap(payload: IAreaBadge[]): void;
+    private _drawImage;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare class BlockParticle {
+    constructor(..._: any[]);
+    render(..._: any[]): void;
+    clear(..._: any[]): void;
+    destroy(..._: any[]): void;
+}
+
+export declare class CanvasEvent {
+    isAllowSelection: boolean;
+    isComposing: boolean;
+    compositionInfo: ICompositionInfo | null;
+    isAllowDrag: boolean;
+    isAllowDrop: boolean;
+    cacheRange: IRange | null;
+    cacheElementList: IElement[] | null;
+    cachePositionList: IElementPosition[] | null;
+    cachePositionContext: IPositionContext | null;
+    mouseDownStartPosition: ICurrentPosition | null;
+    private draw;
+    private pageContainer;
+    private pageList;
+    private range;
+    private position;
+    private _clickHandler;
+    private _mousedownHandler;
+    private _mouseupHandler;
+    private _mouseleaveHandler;
+    private _mousemoveHandler;
+    private _dblclickHandler;
+    private _dragoverHandler;
+    private _dropHandler;
+    private _contextmenuHandler;
+    private _threeClickCleanup;
+    constructor(draw: Draw);
+    getDraw(): Draw;
+    register(): void;
+    removeEvent(): void;
+    setIsAllowSelection(payload: boolean): void;
+    setIsAllowDrag(payload: boolean): void;
+    clearPainterStyle(): void;
+    applyPainterStyle(): void;
+    selectAll(): void;
+    mousemove(evt: MouseEvent): void;
+    mousedown(evt: MouseEvent): void;
+    click(): void;
+    mouseup(evt: MouseEvent): void;
+    mouseleave(evt: MouseEvent): void;
+    keydown(evt: KeyboardEvent): void;
+    dblclick(evt: MouseEvent): void;
+    handleTripleClick(): void;
+    input(data: string): void;
+    cut(): void;
+    copy(options?: ICopyOption): void;
+    compositionstart(): void;
+    compositionend(evt: CompositionEvent): void;
+    drop(evt: DragEvent): void;
+    dragover(evt: DragEvent | MouseEvent): void;
+    private _contextmenu;
+}
+
+export declare class CheckboxControl implements IControlInstance {
+    protected element: IElement;
+    protected control: Control;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getCode(): string | null;
+    getValue(): IElement[];
+    setValue(): number;
+    setSelect(codes: string[], context?: IControlContext, options?: IControlRuleOption): void;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+}
+
+export declare class CheckboxParticle {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    setSelect(element: IElement): void;
+    render(payload: ICheckboxRenderOption): void;
+}
+
+export declare class Control {
+    private controlBorder;
+    private draw;
+    private range;
+    private listener;
+    private eventBus;
+    private controlSearch;
+    private options;
+    private controlOptions;
+    private activeControl;
+    private activeControlValue;
+    private preElement;
+    constructor(draw: Draw);
+    setHighlightList(payload: IControlHighlight[]): void;
+    computeHighlightList(): void;
+    renderHighlightList(ctx: CanvasRenderingContext2D, pageNo: number): void;
+    getDraw(): Draw;
+    filterAssistElement(elementList: IElement[]): IElement[];
+    getIsRangeCanCaptureEvent(): boolean;
+    getIsRangeInPostfix(): boolean;
+    getIsRangeWithinControl(): boolean;
+    getIsElementListContainFullControl(elementList: IElement[]): boolean;
+    getIsDisabledControl(context?: IControlContext): boolean;
+    getIsDisabledPasteControl(context?: IControlContext): boolean;
+    getIsExistValueByElementListIndex(elementList: IElement[], index: number): boolean;
+    getControlHighlight(elementList: IElement[], index: number): string;
+    getContainer(): HTMLDivElement;
+    getElementList(): IElement[];
+    getPosition(): IElementPosition | null;
+    getPreY(): number;
+    getRange(): IRange;
+    shrinkBoundary(context?: IControlContext): void;
+    getActiveControl(): IControlInstance | null;
+    getControlElementList(context?: IControlContext): IElement[];
+    updateActiveControlValue(): void;
+    emitControlChange(state: ControlState): void;
+    initControl(): void;
+    destroyControl(options?: IDestroyControlOption): void;
+    repaintControl(options?: IRepaintControlOption): void;
+    emitControlContentChange(options?: IControlChangeOption): void;
+    reAwakeControl(): void;
+    moveCursor(position: IControlInitOption): IMoveCursorResult;
+    removeControl(startIndex: number, context?: IControlContext): number | null;
+    removePlaceholder(startIndex: number, context?: IControlContext): void;
+    addPlaceholder(startIndex: number, context?: IControlContext): void;
+    setValue(data: IElement[]): number;
+    setControlProperties(properties: Partial<IControl>, context?: IControlContext): void;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+    getValueById(payload: IGetControlValueOption): IGetControlValueResult;
+    setValueListById(payload: ISetControlValueOption[]): void;
+    setExtensionListById(payload: ISetControlExtensionOption[]): void;
+    setPropertiesListById(payload: ISetControlProperties[]): void;
+    getList(): IElement[];
+    recordBorderInfo(x: number, y: number, width: number, height: number): void;
+    drawBorder(ctx: CanvasRenderingContext2D): void;
+    getPreControlContext(): INextControlContext | null;
+    getNextControlContext(): INextControlContext | null;
+    initNextControl(option?: IInitNextControlOption): void;
+    setMinWidthControlInfo(option: ISetControlRowFlexOption): void;
+}
+
+export declare class ControlBorder {
+    protected borderRect: IElementFillRect;
+    private options;
+    constructor(draw: Draw);
+    clearBorderInfo(): IElementFillRect;
+    recordBorderInfo(x: number, y: number, width: number, height: number): void;
+    render(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare class ControlSearch {
+    private draw;
+    private control;
+    private options;
+    private highlightList;
+    private highlightMatchResult;
+    constructor(control: Control);
+    getControlHighlight(elementList: IElement[], index: number): string;
+    getHighlightMatchResult(): IHighlightMatchResult;
+    getHighlightList(): IControlHighlight[];
+    setHighlightList(payload: IControlHighlight[]): void;
+    computeHighlightList(): void;
+    renderHighlightList(ctx: CanvasRenderingContext2D, pageIndex: number): void;
+}
+
+declare class Cursor {
+    private readonly ANIMATION_CLASS;
+    private draw;
+    private container;
+    private options;
+    private position;
+    private cursorDom;
+    private cursorAgent;
+    private blinkTimeout;
+    private hitLineStartIndex;
+    constructor(draw: Draw, canvasEvent: CanvasEvent);
+    getCursorDom(): HTMLDivElement;
+    getAgentDom(): HTMLTextAreaElement;
+    getAgentIsActive(): boolean;
+    getAgentDomValue(): string;
+    clearAgentDomValue(): void;
+    getHitLineStartIndex(): number | undefined;
+    private _blinkStart;
+    private _blinkStop;
+    private _setBlinkTimeout;
+    private _clearBlinkTimeout;
+    focus(): void;
+    drawCursor(payload?: IDrawCursorOption): void;
+    recoveryCursor(): void;
+    moveCursorToVisible(payload: IMoveCursorToVisibleOption): void;
+}
+export { Cursor }
+export { Cursor as TextCursor }
+
+export declare class CursorAgent {
+    private draw;
+    private container;
+    private agentCursorDom;
+    private canvasEvent;
+    private eventBus;
+    constructor(draw: Draw, canvasEvent: CanvasEvent);
+    getAgentCursorDom(): HTMLTextAreaElement;
+    private _keyDown;
+    private _input;
+    private _paste;
+    private _compositionstart;
+    private _compositionend;
+}
+
+export declare class DateControl implements IControlInstance {
+    private draw;
+    private element;
+    private control;
+    private isPopup;
+    private datePicker;
+    private options;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getIsPopup(): boolean;
+    getValueRange(context?: IControlContext): [number, number] | null;
+    getValue(context?: IControlContext): IElement[];
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    clearSelect(context?: IControlContext, options?: IControlRuleOption): number;
+    setSelect(date: string, context?: IControlContext, options?: IControlRuleOption): void;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+    awake(): void;
+    destroy(): void;
+    private _setDate;
+}
+
+export declare class DateParticle {
+    constructor(..._: any[]);
+    render(..._: any[]): void;
+    renderDatePicker(..._: any[]): void;
+    clearDatePicker(..._: any[]): void;
+    destroy(..._: any[]): void;
+}
+
+export declare class DatePicker {
+    constructor(..._: any[]);
+    render(..._: any[]): void;
+    destroy(..._: any[]): void;
+}
+
+declare class Draw {
+    private container;
+    private pageContainer;
+    private pageList;
+    private ctxList;
+    private pageNo;
+    private renderCount;
+    private pagePixelRatio;
+    private mode;
+    private options;
+    private position;
+    private zone;
+    private elementList;
+    private listener;
+    private eventBus;
+    private override;
+    private i18n;
+    private canvasEvent;
+    private globalEvent;
+    private cursor;
+    private range;
+    private margin;
+    private background;
+    private badge;
+    private search;
+    private group;
+    private area;
+    private underline;
+    private strikeout;
+    private highlight;
+    private paragraphColor;
+    private historyManager;
+    private previewer;
+    private imageParticle;
+    private laTexParticle;
+    private textParticle;
+    private tableParticle;
+    private tableTool;
+    private tableOperate;
+    private pageNumber;
+    private lineNumber;
+    private waterMark;
+    private placeholder;
+    private header;
+    private footer;
+    private hyperlinkParticle;
+    private dateParticle;
+    private separatorParticle;
+    private pageBreakParticle;
+    private superscriptParticle;
+    private subscriptParticle;
+    private checkboxParticle;
+    private radioParticle;
+    private blockParticle;
+    private listParticle;
+    private lineBreakParticle;
+    private control;
+    private pageBorder;
+    private revisionOverlay;
+    private commentOverlay;
+    private workerManager;
+    private scrollObserver;
+    private selectionObserver;
+    private imageObserver;
+    private mouseObserver;
+    private LETTER_REG;
+    private WORD_LIKE_REG;
+    private rowList;
+    private pageRowList;
+    private painterStyle;
+    private painterOptions;
+    private visiblePageNoList;
+    private intersectionPageNo;
+    private lazyRenderIntersectionObserver;
+    private printModeData;
+    private _register;
+    private readonly HEADER_DEFAULT_SIZE;
+    constructor(rootContainer: HTMLElement, options: DeepRequired<IEditorOption>, data: IEditorData, listener: Listener, eventBus: EventBus<EventBusMap>, override: Override);
+    setPrintData(): void;
+    clearPrintData(): void;
+    getLetterReg(): RegExp;
+    getMode(): EditorMode;
+    setRegister(register: any): void;
+    getRegister(): any | null;
+    setMode(payload: EditorMode): void;
+    isReadonly(): boolean;
+    isDisabled(): boolean;
+    isDesignMode(): boolean;
+    isPrintMode(): boolean;
+    getOriginalWidth(): number;
+    getOriginalHeight(): number;
+    getWidth(): number;
+    getHeight(): number;
+    getMainHeight(): number;
+    getMainOuterHeight(): number;
+    getCanvasWidth(pageNo?: number): number;
+    getCanvasHeight(pageNo?: number): number;
+    getInnerWidth(): number;
+    getOriginalInnerWidth(): number;
+    getContextInnerWidth(): number;
+    getMargins(): IMargin;
+    getOriginalMargins(): number[];
+    getPageGap(): number;
+    getOriginalPageGap(): number;
+    getPageNumberBottom(): number;
+    getMarginIndicatorSize(): number;
+    getDefaultBasicRowMarginHeight(): number;
+    getHighlightMarginHeight(): number;
+    getTdPadding(): IPadding;
+    getContainer(): HTMLDivElement;
+    getPageContainer(): HTMLDivElement;
+    getVisiblePageNoList(): number[];
+    setVisiblePageNoList(payload: number[]): void;
+    getIntersectionPageNo(): number;
+    setIntersectionPageNo(payload: number): void;
+    getPageNo(): number;
+    setPageNo(payload: number): void;
+    getRenderCount(): number;
+    getPage(pageNo?: number): HTMLCanvasElement;
+    getPageList(): HTMLCanvasElement[];
+    getPageCount(): number;
+    getTableRowList(sourceElementList: IElement[]): IRow[];
+    getOriginalRowList(): IRow[];
+    getRowList(): IRow[];
+    getPageRowList(): IRow[][];
+    getCtx(): CanvasRenderingContext2D;
+    getOptions(): DeepRequired<IEditorOption>;
+    getSearch(): Search;
+    getGroup(): Group;
+    getArea(): Area;
+    getBadge(): Badge;
+    getHistoryManager(): HistoryManager;
+    setHistoryManager(historyManager: HistoryManager): void;
+    getPosition(): Position;
+    getZone(): Zone;
+    getRange(): RangeManager;
+    getLineBreakParticle(): LineBreakParticle;
+    getTextParticle(): TextParticle;
+    getHeaderElementList(): IElement[];
+    getTableElementList(sourceElementList: IElement[]): IElement[];
+    getElementList(): IElement[];
+    getMainElementList(): IElement[];
+    getOriginalElementList(): IElement[];
+    getOriginalMainElementList(): IElement[];
+    getFooterElementList(): IElement[];
+    getTd(): ITd | null;
+    insertElementList(payload: IElement[], options?: IInsertElementListOption): void;
+    appendElementList(elementList: IElement[], options?: IAppendElementListOption): void;
+    spliceElementList(elementList: IElement[], start: number, deleteCount: number, items?: IElement[], options?: ISpliceElementListOption): void;
+    getCanvasEvent(): CanvasEvent;
+    getGlobalEvent(): GlobalEvent;
+    getListener(): Listener;
+    getEventBus(): EventBus<EventBusMap>;
+    getOverride(): Override;
+    initRevisionOverlay(_callbacks?: {
+        onAccept?: (id: string) => void;
+        onReject?: (id: string) => void;
+    }): void;
+    setRevisionOverlay(overlay: any): void;
+    setCommentOverlay(overlay: any): void;
+    destroyRevisionOverlay(): void;
+    getRevisionOverlay(): any | null;
+    getCursor(): Cursor;
+    getPreviewer(): Previewer;
+    getImageParticle(): ImageParticle;
+    getLaTexParticle(): LaTexParticle;
+    setLaTexParticle(laTexParticle: LaTexParticle): void;
+    getBlockParticle(): BlockParticle;
+    setBlockParticle(blockParticle: BlockParticle): void;
+    getTableTool(): TableTool;
+    getTableOperate(): TableOperate;
+    getTableParticle(): TableParticle;
+    getHeader(): Header;
+    getFooter(): Footer;
+    getHyperlinkParticle(): HyperlinkParticle;
+    getDateParticle(): DateParticle;
+    setDateParticle(dateParticle: DateParticle): void;
+    getListParticle(): ListParticle;
+    getCheckboxParticle(): CheckboxParticle;
+    getRadioParticle(): RadioParticle;
+    getControl(): Control;
+    setControl(control: Control): void;
+    getWorkerManager(): WorkerManager;
+    setWorkerManager(workerManager: WorkerManager): void;
+    getImageObserver(): ImageObserver;
+    getI18n(): I18n;
+    getRowCount(): number;
+    getDataURL(payload?: IGetImageOption): Promise<string[]>;
+    getPainterStyle(): IElementStyle | null;
+    getPainterOptions(): IPainterOption | null;
+    setPainterStyle(payload: IElementStyle | null, options?: IPainterOption): void;
+    setDefaultRange(): void;
+    getIsPagingMode(): boolean;
+    setPageMode(payload: PageMode): void;
+    setPageScale(payload: number): void;
+    getPagePixelRatio(): number;
+    setPagePixelRatio(payload: number | null): void;
+    setPageDevicePixel(): void;
+    setPaperSize(width: number, height: number): void;
+    setPaperDirection(payload: PaperDirection): void;
+    setPaperMargin(payload: IMargin): void;
+    getOriginValue(options?: IGetOriginValueOption): Required<IEditorData>;
+    getValue(options?: IGetValueOption): IEditorResult;
+    setValue(payload: Partial<IEditorData>, options?: ISetValueOption): void;
+    setEditorData(payload: Partial<IEditorData>): void;
+    private _normalizeHeaderElementList;
+    private _wrapContainer;
+    private _formatContainer;
+    private _createPageContainer;
+    private _createPage;
+    private _initPageContext;
+    getElementFont(el: IElement, scale?: number): string;
+    getElementSize(el: IElement): number;
+    getElementRowMargin(el: IElement): number;
+    private isPageBreakElement;
+    private shouldForceWrapRow;
+    private normalizeSpecialRow;
+    private shouldDrawLineBreakForRow;
+    computeRowList(payload: IComputeRowListPayload): IRow[];
+    private _computePageList;
+    private _drawParagraphColor;
+    private _drawHighlight;
+    drawRow(ctx: CanvasRenderingContext2D, payload: IDrawRowPayload): void;
+    private _drawFloat;
+    private _clearPage;
+    private _drawPage;
+    private _disconnectLazyRender;
+    private _renderVisiblePages;
+    private _lazyRender;
+    private _immediateRender;
+    render(payload?: IDrawOption): void;
+    setCursor(curIndex: number | undefined): number | undefined;
+    submitHistory(curIndex: number | undefined): void;
+    destroy(): void;
+    clearSideEffect(): void;
+}
+export { Draw as DocumentRenderer }
+export { Draw }
+
+export declare type Editor = any;
+
+export declare class FloatingBar {
+    private draw;
+    private command;
+    private range;
+    private options;
+    private container;
+    private textToolbar;
+    private imageToolbar;
+    private lastMousePosition;
+    private currentImageElement;
+    constructor(draw: Draw, command: Command);
+    private _createToolbars;
+    private _bindToolbarEvents;
+    private _createFontOptionsHtml;
+    private _createSizeOptionsHtml;
+    private _resolveFontValue;
+    private _resolveSizeValue;
+    private _executeTextAction;
+    private _executeImageAction;
+    private _rotateImage;
+    private _replaceImage;
+    private _updateImageToolbarState;
+    private _addEvents;
+    private _handleMouseUp;
+    private _handleClickOutside;
+    private _handleContextMenu;
+    private _getContext;
+    private _showTextToolbar;
+    private _hideTextToolbar;
+    private _showImageToolbar;
+    private _hideImageToolbar;
+    private _positionToolbar;
+    removeEvent(): void;
+    dispose(): void;
+    destroy(): void;
+}
+
+export declare class Footer {
+    private draw;
+    private position;
+    private zone;
+    private options;
+    private elementList;
+    private rowList;
+    private positionList;
+    constructor(draw: Draw, data?: IElement[]);
+    getRowList(): IRow[];
+    setElementList(elementList: IElement[]): void;
+    getElementList(): IElement[];
+    getPositionList(): IElementPosition[];
+    compute(): void;
+    recovery(): void;
+    private _computeRowList;
+    private _computePositionList;
+    getFooterBottom(): number;
+    getMaxHeight(): number;
+    getHeight(): number;
+    getRowHeight(): number;
+    getExtraHeight(): number;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare function getClipboardData(): IClipboardData | null;
+
+export declare function getIsClipboardContainFile(clipboardData: DataTransfer): boolean;
+
+export declare class GlobalEvent {
+    private draw;
+    private options;
+    private cursor;
+    private canvasEvent;
+    private range;
+    private previewer;
+    private tableTool;
+    private hyperlinkParticle;
+    private control;
+    private dateParticle;
+    private imageParticle;
+    private dprMediaQueryList;
+    constructor(draw: Draw, canvasEvent: CanvasEvent);
+    register(): void;
+    private addEvent;
+    removeEvent(): void;
+    clearSideEffect: (evt: Event) => void;
+    setCanvasEventAbility: () => void;
+    watchCursorActive(): void;
+    setPageScale: (evt: WheelEvent) => void;
+    private _handleVisibilityChange;
+    private _handleDprChange;
+}
+
+export declare class Group {
+    private draw;
+    private options;
+    private range;
+    private fillRectMap;
+    private groupIndexMap;
+    constructor(draw: Draw);
+    setGroup(): string | null;
+    getElementListByGroupId(elementList: IElement[], groupId: string): IElement[];
+    deleteGroup(groupId: string): void;
+    getContextByGroupId(elementList: IElement[], groupId: string): (IRange & IPositionContext) | null;
+    clearFillInfo(): void;
+    recordFillInfo(element: IElement, x: number, y: number, width: number, height: number): void;
+    render(ctx: CanvasRenderingContext2D): void;
+    getCommentIndex(groupId: string): number;
+    getAllGroupIds(): string[];
+}
+
+export declare class Header {
+    private draw;
+    private position;
+    private zone;
+    private options;
+    private elementList;
+    private rowList;
+    private positionList;
+    constructor(draw: Draw, data?: IElement[]);
+    getRowList(): IRow[];
+    setElementList(elementList: IElement[]): void;
+    getElementList(): IElement[];
+    getPositionList(): IElementPosition[];
+    compute(): void;
+    recovery(): void;
+    private _computeRowList;
+    private _computePositionList;
+    getHeaderTop(): number;
+    getMaxHeight(): number;
+    getHeight(): number;
+    getRowHeight(): number;
+    getExtraHeight(): number;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+declare class Highlight_2 extends AbstractRichText {
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D): void;
+}
+export { Highlight_2 as Highlight }
+
+export declare class HistoryManager {
+    constructor(..._: any[]);
+    undo(..._: any[]): void;
+    redo(..._: any[]): void;
+    recovery(..._: any[]): void;
+    clear(..._: any[]): void;
+    popUndo(..._: any[]): any;
+    isStackEmpty(..._: any[]): boolean;
+    isCanUndo(..._: any[]): boolean;
+    isCanRedo(..._: any[]): boolean;
+    execute(..._: any[]): void;
+    destroy(..._: any[]): void;
+}
+
+export declare class HyperlinkParticle {
+    private draw;
+    private options;
+    private container;
+    private hyperlinkPopupContainer;
+    private hyperlinkDom;
+    constructor(draw: Draw);
+    private _createHyperlinkPopupDom;
+    private _isSafeUrl;
+    drawHyperlinkPopup(element: IElement, position: IElementPosition): void;
+    clearHyperlinkPopup(): void;
+    openHyperlink(element: IElement): void;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}
+
+export declare class I18n {
+    constructor(..._: any[]);
+    t(key: string, ..._args: any[]): string;
+    registerLangMap(..._: any[]): void;
+    destroy(..._: any[]): void;
+}
+
+declare interface ICheckboxRenderOption {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    row: IRow;
+    index: number;
+}
+
+declare interface IClipboardData {
+    text: string;
+    elementList: IElement[];
+}
+
+declare interface ICompositionInfo {
+    elementList: IElement[];
+    startIndex: number;
+    endIndex: number;
+    value: string;
+    defaultStyle: IRangeElementStyle | null;
+}
+
+export declare interface IControlProvider {
+    activate(control: any): void;
+    deactivate(): void;
+    getActiveControl(): any;
+    nextControl(): void;
+    preControl(): void;
+    destroy(): void;
+}
+
+declare type IDrawCursorOption = ICursorOption & {
+    isShow?: boolean;
+    isBlink?: boolean;
+    isFocus?: boolean;
+    hitLineStartIndex?: number;
+};
+
+declare interface IElementVisibleInfo {
+    intersectionHeight: number;
+}
+
+declare type IHighlightMatchResult = (ISearchResult & IControlHighlightRule)[];
+
+export declare interface IHistoryProvider {
+    undo(): void;
+    redo(): void;
+    pushSnapshot(): void;
+    hasUndo(): boolean;
+    hasRedo(): boolean;
+    recovery(): void;
+    destroy(): void;
+}
+
+export declare class ImageObserver {
+    private promiseList;
+    constructor();
+    add(payload: Promise<unknown>): void;
+    clearAll(): void;
+    allSettled(): Promise<PromiseSettledResult<unknown>[]>;
+}
+
+export declare class ImageParticle {
+    private draw;
+    protected options: Required<IEditorOption>;
+    protected imageCache: Map<string, HTMLImageElement>;
+    private container;
+    private floatImageContainer;
+    private floatImage;
+    constructor(draw: Draw);
+    getOriginalMainImageList(): IElement[];
+    createFloatImage(element: IElement): void;
+    dragFloatImage(movementX: number, movementY: number): void;
+    destroyFloatImage(): void;
+    protected addImageObserver(promise: Promise<unknown>): void;
+    protected getFallbackImage(width: number, height: number): HTMLImageElement;
+    render(ctx: CanvasRenderingContext2D, element: IElement, x: number, y: number): void;
+}
+
+declare interface IMeasureWordResult {
+    width: number;
+    endElement: IElement;
+}
+
+declare interface IMoveCursorResult {
+    newIndex: number;
+    newElement: IElement;
+}
+
+declare interface IMoveCursorToVisibleOption {
+    direction: MoveDirection;
+    cursorPosition: IElementPosition;
+}
+
+export declare interface INavigateInfo {
+    index: number;
+    count: number;
+}
+
+declare interface IOverrideResult {
+    preventDefault?: boolean;
+}
+
+declare interface IPageVisibleInfo {
+    intersectionPageNo: number;
+    visiblePageNoList: number[];
+}
+
+export declare interface IParticleRegistry {
+    registerParticle(name: string, particle: any): void;
+    getParticle(name: string): any;
+}
+
+declare interface IPlaceholderRenderOption {
+    placeholder: Required<IPlaceholder>;
+    startY?: number;
+}
+
+declare interface IRadioRenderOption {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    row: IRow;
+    index: number;
+}
+
+declare interface IRegisterPayload {
+    shortcut: Shortcut;
+    i18n: I18n;
+}
+
+export declare interface ISearchProvider {
+    search(keyword: string): void;
+    navigate(index: number): void;
+    replace(replacement: string): void;
+    replaceAll(replacement: string): void;
+    close(): void;
+    getMatchResult(): any;
+}
+
+export declare class LaTexParticle {
+    constructor(..._: any[]);
+    render(..._: any[]): void;
+}
+
+export declare class LineBreakParticle {
+    private options;
+    static readonly WIDTH = 12;
+    static readonly HEIGHT = 9;
+    static readonly GAP = 3;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}
+
+export declare class LineNumber {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare class ListParticle {
+    private draw;
+    private range;
+    private options;
+    private symbolDrawer;
+    private readonly MEASURE_BASE_TEXT;
+    private readonly LIST_GAP;
+    constructor(draw: Draw);
+    setList(listType: ListType | null, listStyle?: ListStyle): void;
+    unsetList(): void;
+    computeListStyle(ctx: CanvasRenderingContext2D, elementList: IElement[]): Map<string, number>;
+    getListStyleWidth(ctx: CanvasRenderingContext2D, listElementList: IElement[]): number;
+    drawListStyle(ctx: CanvasRenderingContext2D, row: IRow, position: IElementPosition): void;
+    private getOlValue;
+    private chineseFromNumber;
+    private circleFromNumber;
+    private alphaFromNumber;
+}
+
+export declare class Margin {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare class MouseObserver {
+    private draw;
+    private eventBus;
+    private pageContainer;
+    private _mousemoveHandler;
+    private _mouseenterHandler;
+    private _mouseleaveHandler;
+    private _mousedownHandler;
+    private _mouseupHandler;
+    private _clickHandler;
+    constructor(draw: Draw);
+    removeEvent(): void;
+    private _mousemove;
+    private _mouseenter;
+    private _mouseleave;
+    private _mousedown;
+    private _mouseup;
+    private _click;
+}
+
+export declare class NumberControl extends TextControl {
+}
+
+export declare class Override {
+    paste: ((evt?: ClipboardEvent) => unknown | IOverrideResult) | undefined;
+    copy: (() => unknown | IOverrideResult) | undefined;
+    drop: ((evt: DragEvent) => unknown | IOverrideResult) | undefined;
+}
+
+export declare class PageBorder {
+    private draw;
+    private header;
+    private footer;
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare class PageBreakParticle {
+    private draw;
+    private options;
+    private i18n;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}
+
+export declare class PageNumber {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    static formatNumberPlaceholder(text: string, pageNo: number, replaceReg: RegExp, numberType: NumberType): string;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare class ParagraphColor extends AbstractRichText {
+    render(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare function pasteByApi(host: CanvasEvent, options?: IPasteOption): Promise<void>;
+
+export declare class Placeholder {
+    private draw;
+    private position;
+    private options;
+    private elementList;
+    private rowList;
+    private positionList;
+    constructor(draw: Draw);
+    private _recovery;
+    _compute(options?: IPlaceholderRenderOption): void;
+    private _computeRowList;
+    private _computePositionList;
+    render(ctx: CanvasRenderingContext2D, options?: IPlaceholderRenderOption): void;
+}
+
+declare class Plugin_2 {
+    private editor;
+    constructor(editor: Editor);
+    use<Options>(pluginFunction: PluginFunction<Options>, options?: Options): void;
+}
+export { Plugin_2 as Plugin }
+
+declare class Position {
+    private cursorPosition;
+    private positionContext;
+    private positionList;
+    private floatPositionList;
+    private draw;
+    private eventBus;
+    private options;
+    constructor(draw: Draw);
+    getFloatPositionList(): IFloatPosition[];
+    getTablePositionList(sourceElementList: IElement[]): IElementPosition[];
+    getPositionList(): IElementPosition[];
+    getMainPositionList(): IElementPosition[];
+    getOriginalPositionList(): IElementPosition[];
+    getOriginalMainPositionList(): IElementPosition[];
+    getSelectionPositionList(): IElementPosition[] | null;
+    setPositionList(payload: IElementPosition[]): void;
+    setFloatPositionList(payload: IFloatPosition[]): void;
+    computePageRowPosition(payload: IComputePageRowPositionPayload): IComputePageRowPositionResult;
+    computePositionList(): void;
+    computeRowPosition(payload: IComputeRowPositionPayload): IElementPosition[];
+    setCursorPosition(position: IElementPosition | null): void;
+    getCursorPosition(): IElementPosition | null;
+    getPositionContext(): IPositionContext;
+    setPositionContext(payload: IPositionContext): void;
+    getPositionByXY(payload: IGetPositionByXYPayload): ICurrentPosition;
+    getFloatPositionByXY(payload: IGetFloatPositionByXYPayload): ICurrentPosition | void;
+    adjustPositionContext(payload: IGetPositionByXYPayload): ICurrentPosition | null;
+    setSurroundPosition(payload: ISetSurroundPositionPayload): {
+        x: number;
+        rowIncreaseWidth: number;
+    };
+}
+export { Position }
+export { Position as PositionCalculator }
+
+export declare class Previewer {
+    private container;
+    private canvas;
+    private draw;
+    private options;
+    private curElement;
+    private curElementSrc;
+    private previewerDrawOption;
+    private curPosition;
+    private eventBus;
+    private imageList;
+    private curShowElement;
+    private imageCount;
+    private imagePre;
+    private imageNext;
+    private resizerSelection;
+    private resizerHandleList;
+    private resizerImageContainer;
+    private resizerImage;
+    private resizerSize;
+    private width;
+    private height;
+    private mousedownX;
+    private mousedownY;
+    private curHandleIndex;
+    private previewerContainer;
+    private previewerImage;
+    constructor(draw: Draw);
+    private _getElementPosition;
+    private _createResizerDom;
+    private _keydown;
+    private _mousedown;
+    private _mousemove;
+    private _drawPreviewer;
+    private _updateImageNavigate;
+    _setPreviewerTransform(scale: number, rotate: number, x: number, y: number): void;
+    private _clearPreviewer;
+    _updateResizerRect(width: number, height: number): void;
+    _updateResizerSizeView(width: number, height: number): void;
+    render(): void;
+    drawResizer(element: IElement, position?: IElementPosition | null, options?: IPreviewerDrawOption): void;
+    updateResizer(element: IElement, position?: IElementPosition | null): void;
+    clearResizer(): void;
+}
+
+export declare class RadioControl extends CheckboxControl {
+    setSelect(codes: string[], context?: IControlContext, options?: IControlRuleOption): void;
+}
+
+export declare class RadioParticle {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    setSelect(element: IElement): void;
+    render(payload: IRadioRenderOption): void;
+}
+
+export declare class Register {
+    shortcutList: (payload: IRegisterShortcut[]) => void;
+    langMap: (locale: string, lang: DeepPartial<ILang>) => void;
+    private chartRenderer;
+    constructor(payload: IRegisterPayload);
+    /**
+     * 注册图表渲染器
+     * @param renderer 图表渲染器实例
+     */
+    registerChartRenderer(renderer: IChartRenderer): void;
+    /**
+     * 获取图表渲染器
+     * @returns 图表渲染器实例或 null
+     */
+    getChartRenderer(): IChartRenderer | null;
+    /**
+     * 检查是否已注册图表渲染器
+     * @returns 是否已注册
+     */
+    hasChartRenderer(): boolean;
+}
+
+export declare function removeClipboardData(): void;
+
+export declare class ScrollObserver {
+    private draw;
+    private options;
+    private scrollContainer;
+    constructor(draw: Draw);
+    getScrollContainer(): Element | Document;
+    private _addEvent;
+    removeEvent(): void;
+    getElementVisibleInfo(element: Element): IElementVisibleInfo;
+    getPageVisibleInfo(): IPageVisibleInfo;
+    private _observer;
+}
+
+export declare class Search {
+    private draw;
+    private options;
+    private position;
+    private searchKeyword;
+    private searchNavigateIndex;
+    private searchMatchList;
+    constructor(draw: Draw);
+    getSearchKeyword(): string | null;
+    setSearchKeyword(payload: string | null): void;
+    searchNavigatePre(): number | null;
+    searchNavigateNext(): number | null;
+    searchNavigateScrollIntoView(position: IElementPosition): void;
+    getSearchNavigateIndexList(): any[];
+    getSearchMatchList(): ISearchResult[];
+    getSearchNavigateInfo(): null | INavigateInfo;
+    getMatchList(payload: string, originalElementList: IElement[]): ISearchResult[];
+    compute(payload: string): void;
+    render(ctx: CanvasRenderingContext2D, pageIndex: number): void;
+    replace(payload: string, option?: IReplaceOption): void;
+}
+
+export declare class SelectControl implements IControlInstance {
+    private element;
+    private control;
+    private isPopup;
+    private selectDom;
+    private options;
+    private VALUE_DELIMITER;
+    private DEFAULT_MULTI_SELECT_DELIMITER;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getIsPopup(): boolean;
+    getCodes(): string[];
+    getText(codes: string[]): string | null;
+    getValue(context?: IControlContext): IElement[];
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+    clearSelect(context?: IControlContext, options?: IControlRuleOption): number;
+    setSelect(code: string, context?: IControlContext, options?: IControlRuleOption): void;
+    private _createSelectPopupDom;
+    awake(): void;
+    destroy(): void;
+}
+
+export declare class SelectionObserver {
+    private readonly step;
+    private readonly thresholdPoints;
+    private selectionContainer;
+    private rangeManager;
+    private requestAnimationFrameId;
+    private isMousedown;
+    private isMoving;
+    private clientWidth;
+    private clientHeight;
+    private containerRect;
+    constructor(draw: Draw);
+    private _addEvent;
+    removeEvent(): void;
+    private _mousedown;
+    private _mouseup;
+    private _mousemove;
+    private _move;
+    private _startMove;
+    private _stopMove;
+}
+
+export declare class SeparatorParticle {
+    private options;
+    constructor(draw: Draw);
+    private withAlpha;
+    private scaleDashArray;
+    private drawStraightLine;
+    private drawWavyLine;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}
+
+declare class Shortcut {
+    constructor(..._: any[]);
+    registerShortcutList(..._: any[]): void;
+    removeEvent(): void;
+}
+
+export declare class Strikeout extends AbstractRichText {
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare class SubscriptParticle {
+    getOffsetY(element: IRowElement): number;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}
+
+export declare class SuperscriptParticle {
+    getOffsetY(element: IRowElement): number;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}
+
+export declare class TableOperate {
+    private draw;
+    private range;
+    private position;
+    private tableTool;
+    private tableParticle;
+    private options;
+    constructor(draw: Draw);
+    insertTable(row: number, col: number): void;
+    insertTableTopRow(): void;
+    insertTableBottomRow(): void;
+    adjustColWidth(element: IElement): void;
+    insertTableLeftCol(): void;
+    insertTableRightCol(): void;
+    deleteTableRow(): void;
+    deleteTableCol(): void;
+    deleteTable(): void;
+    mergeTableCell(): void;
+    cancelMergeTableCell(): void;
+    splitVerticalTableCell(): void;
+    splitHorizontalTableCell(): void;
+    tableTdVerticalAlign(payload: VerticalAlign): void;
+    tableBorderType(payload: TableBorder): void;
+    tableBorderColor(payload: string): void;
+    tableBorderWidth(payload: number): void;
+    tableBorderExternalWidth(payload: number): void;
+    tableTdBorderType(payload: TdBorder): void;
+    tableTdSlashType(payload: TdSlash): void;
+    tableTdBackgroundColor(payload: string): void;
+    tableSelectAll(): void;
+}
+
+export declare class TableParticle {
+    private draw;
+    private range;
+    private options;
+    constructor(draw: Draw);
+    getTrListGroupByCol(payload: ITr[]): ITr[];
+    getRangeRowCol(): ITd[][] | null;
+    private _drawSlash;
+    private _drawBorder;
+    private _drawBackgroundColor;
+    getTableWidth(element: IElement): number;
+    getTableHeight(element: IElement): number;
+    getRowCountByColIndex(trList: ITr[], colIndex: number): number;
+    getTdListByColIndex(trList: ITr[], colIndex: number): ITd[];
+    getTdListByRowIndex(trList: ITr[], rowIndex: number): ITd[];
+    computeRowColInfo(element: IElement): void;
+    drawRange(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number): void;
+    render(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number): void;
+}
+
+export declare class TableTool {
+    private readonly MIN_TD_WIDTH;
+    private readonly ROW_COL_OFFSET;
+    private readonly ROW_COL_QUICK_WIDTH;
+    private readonly ROW_COL_QUICK_OFFSET;
+    private readonly ROW_COL_QUICK_POSITION;
+    private readonly BORDER_VALUE;
+    private readonly TABLE_SELECT_OFFSET;
+    private draw;
+    private canvas;
+    private options;
+    private position;
+    private range;
+    private container;
+    private toolRowContainer;
+    private toolRowAddBtn;
+    private toolColAddBtn;
+    private toolTableSelectBtn;
+    private toolColContainer;
+    private toolBorderContainer;
+    private anchorLine;
+    private mousedownX;
+    private mousedownY;
+    constructor(draw: Draw);
+    dispose(): void;
+    render(): void;
+    private _setAnchorActive;
+    private _mousedown;
+    private _mousemove;
+}
+
+export declare class TextControl implements IControlInstance {
+    private element;
+    private control;
+    private options;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getValue(context?: IControlContext): IElement[];
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    clearValue(context?: IControlContext, options?: IControlRuleOption): number;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+}
+
+export declare class TextParticle {
+    private draw;
+    private options;
+    private ctx;
+    private curX;
+    private curY;
+    private text;
+    private curStyle;
+    private curColor?;
+    private curCharacterScale;
+    cacheMeasureText: Map<string, TextMetrics>;
+    constructor(draw: Draw);
+    static getCharacterScaleRatio(characterScale?: number): number;
+    static fillScaledText(ctx: CanvasRenderingContext2D, text: string, x: number, y: number, characterScale?: number): void;
+    measureBasisWord(ctx: CanvasRenderingContext2D, font: string): ITextMetrics;
+    measureWord(ctx: CanvasRenderingContext2D, elementList: IElement[], curIndex: number): IMeasureWordResult;
+    measurePunctuationWidth(ctx: CanvasRenderingContext2D, element: IElement): number;
+    measureText(ctx: CanvasRenderingContext2D, element: IElement): ITextMetrics;
+    complete(): void;
+    record(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    private _setCurXY;
+    private _render;
+}
+
+export declare class Underline extends AbstractRichText {
+    private options;
+    constructor(draw: Draw);
+    private _drawLine;
+    private _drawDouble;
+    private _drawWave;
+    render(ctx: CanvasRenderingContext2D): void;
+}
+
+export declare const version: string;
+
+export declare class Watermark {
+    private draw;
+    private options;
+    private imageCache;
+    constructor(draw: Draw);
+    renderText(ctx: CanvasRenderingContext2D, pageNo: number): void;
+    renderImage(ctx: CanvasRenderingContext2D): void;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}
+
+export declare class WorkerManager {
+    constructor(..._: any[]);
+    destroy(..._: any[]): void;
+}
+
+export declare class Zone {
+    private readonly INDICATOR_PADDING;
+    private draw;
+    private options;
+    private i18n;
+    private container;
+    private currentZone;
+    private indicatorContainer;
+    private pageNumberMenu;
+    constructor(draw: Draw);
+    isHeaderActive(): boolean;
+    isMainActive(): boolean;
+    isFooterActive(): boolean;
+    getZone(): EditorZone;
+    setZone(payload: EditorZone): void;
+    getZoneByY(y: number): EditorZone;
+    drawZoneIndicator(): void;
+    private _showPageNumberMenu;
+    private _hidePageNumberMenu;
+    private _insertPageNumber;
+    private _getZoneName;
+    private _clearZoneIndicator;
+}
+
+export declare class ZoneTip {
+    private draw;
+    private zone;
+    private i18n;
+    private container;
+    private pageContainer;
+    private isDisableMouseMove;
+    private tipContainer;
+    private tipContent;
+    private currentMoveZone;
+    constructor(draw: Draw, zone: Zone);
+    private _watchMouseMoveZoneChange;
+    private _drawZoneTip;
+    private _updateZoneTip;
+}
+
+export { }