@hufe921/canvas-editor 0.9.136 → 1.0.0

package/dist/src/editor/core/cascade/CascadeManager.d.ts

@@ -0,0 +1,28 @@
+import { Draw } from '../draw/Draw';
+export declare class CascadeManager {
+    private draw;
+    private control;
+    private eventBus;
+    private baselines;
+    private controlBaselines;
+    private valueCache;
+    private isExecuting;
+    private needsRerun;
+    constructor(draw: Draw);
+    private getZoneElementLists;
+    private collectAll;
+    private resolveIdentifier;
+    private resolveIdentifierUncached;
+    private resolveByControlId;
+    private normalizeGetValueResult;
+    private findTitleRangeElements;
+    private recordBaseline;
+    private writeWithBaseline;
+    private restoreBaseline;
+    private recordControlBaseline;
+    private restoreControlBaseline;
+    private applyAction;
+    private applyComputes;
+    executeAll(): void;
+    private executePass;
+}

package/dist/src/editor/core/cascade/expression/evaluator.d.ts

@@ -0,0 +1,14 @@
+import { IAstNode } from './parser';
+export interface IResolvedValue {
+    code?: string | null;
+    codes?: string[];
+    text?: string | null;
+    isDate?: boolean;
+}
+export type ResolveIdentifier = (name: string) => IResolvedValue | undefined;
+export interface IEvalContext {
+    resolve: ResolveIdentifier;
+    resolveSelf?: () => IResolvedValue | undefined;
+}
+export declare function evaluate(node: IAstNode, context: IEvalContext): boolean;
+export declare function evaluateValue(node: IAstNode, context: IEvalContext): string | number | null;

package/dist/src/editor/core/cascade/expression/parser.d.ts

@@ -0,0 +1,36 @@
+import { IToken } from './tokenizer';
+export type IAstNode = {
+    type: 'logical';
+    op: '&&' | '||';
+    left: IAstNode;
+    right: IAstNode;
+} | {
+    type: 'not';
+    argument: IAstNode;
+} | {
+    type: 'compare';
+    op: string;
+    left: IAstNode;
+    right: IAstNode;
+} | {
+    type: 'arithmetic';
+    op: string;
+    left: IAstNode;
+    right: IAstNode;
+} | {
+    type: 'literal';
+    value: unknown;
+} | {
+    type: 'getValue';
+    target: {
+        kind: 'id';
+        value: string;
+    } | {
+        kind: 'self';
+    };
+} | {
+    type: 'call';
+    name: string;
+    args: IAstNode[];
+};
+export declare function parse(tokens: IToken[]): IAstNode;

package/dist/src/editor/core/cascade/expression/tokenizer.d.ts

@@ -0,0 +1,19 @@
+export declare enum TokenType {
+    IDENT = "IDENT",
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    NULL = "NULL",
+    SELF = "SELF",
+    OP = "OP",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    COMMA = "COMMA"
+}
+export interface IToken {
+    type: TokenType;
+    value: string;
+}
+export declare function tokenize(source: string): IToken[];

package/dist/src/editor/core/command/Command.d.ts

@@ -51,6 +51,8 @@ export declare class Command {
     executeTableTdBorderType: CommandAdapt['tableTdBorderType'];
     executeTableTdSlashType: CommandAdapt['tableTdSlashType'];
     executeTableTdBackgroundColor: CommandAdapt['tableTdBackgroundColor'];
+    executeTableAutoFitToContent: CommandAdapt['tableAutoFitToContent'];
+    executeTableAutoFitToPage: CommandAdapt['tableAutoFitToPage'];
     executeTableSelectAll: CommandAdapt['tableSelectAll'];
     executeImage: CommandAdapt['image'];
     executeHyperlink: CommandAdapt['hyperlink'];
@@ -72,6 +74,7 @@ export declare class Command {
     executeSetImageCaption: CommandAdapt['setImageCaption'];
     executeChangeImageDisplay: CommandAdapt['changeImageDisplay'];
     executePageMode: CommandAdapt['pageMode'];
+    executeSetColumns: CommandAdapt['setColumns'];
     executePageScale: CommandAdapt['pageScale'];
     executePageScaleRecovery: CommandAdapt['pageScaleRecovery'];
     executePageScaleMinus: CommandAdapt['pageScaleMinus'];
@@ -88,6 +91,9 @@ export declare class Command {
     executeDeleteArea: CommandAdapt['deleteArea'];
     executeLocationArea: CommandAdapt['locationArea'];
     executeClearGraffiti: CommandAdapt['clearGraffiti'];
+    executeToggleTrace: CommandAdapt['toggleTrace'];
+    executeCompare: CommandAdapt['compare'];
+    executeToggleRuler: CommandAdapt['toggleRuler'];
     executeAppendElementList: CommandAdapt['appendElementList'];
     executeUpdateElementById: CommandAdapt['updateElementById'];
     executeDeleteElementById: CommandAdapt['deleteElementById'];
@@ -109,6 +115,8 @@ export declare class Command {
     executeSetControlProperties: CommandAdapt['setControlProperties'];
     executeSetControlPropertiesList: CommandAdapt['setControlPropertiesList'];
     executeSetControlHighlight: CommandAdapt['setControlHighlight'];
+    executeValidate: CommandAdapt['validate'];
+    executeClearValidate: CommandAdapt['clearValidate'];
     executeLocationControl: CommandAdapt['locationControl'];
     executeInsertControl: CommandAdapt['insertControl'];
     executeJumpControl: CommandAdapt['jumpControl'];
@@ -135,6 +143,7 @@ export declare class Command {
     getKeywordRangeList: CommandAdapt['getKeywordRangeList'];
     getKeywordContext: CommandAdapt['getKeywordContext'];
     getPaperMargin: CommandAdapt['getPaperMargin'];
+    getColumns: CommandAdapt['getColumns'];
     getSearchNavigateInfo: CommandAdapt['getSearchNavigateInfo'];
     getLocale: CommandAdapt['getLocale'];
     getGroupIds: CommandAdapt['getGroupIds'];
@@ -144,5 +153,8 @@ export declare class Command {
     getTitleValue: CommandAdapt['getTitleValue'];
     getPositionContextByEvent: CommandAdapt['getPositionContextByEvent'];
     getElementById: CommandAdapt['getElementById'];
+    private interceptor?;
+    setInterceptor(fn?: (name: string, args: unknown[]) => void): void;
+    private wrap;
     constructor(adapt: CommandAdapt);
 }

package/dist/src/editor/core/command/CommandAdapt.d.ts

@@ -8,9 +8,11 @@ import { TitleLevel } from '../../dataset/enum/Title';
 import { VerticalAlign } from '../../dataset/enum/VerticalAlign';
 import { ICatalog } from '../../interface/Catalog';
 import { DeepRequired } from '../../interface/Common';
-import { IGetControlValueOption, IGetControlValueResult, ILocationControlOption, IRemoveControlOption, ISetControlExtensionOption, ISetControlHighlightOption, ISetControlProperties, ISetControlValueOption } from '../../interface/Control';
+import { IComparePayload } from '../../interface/Compare';
+import { IControlValidateResult, IGetControlValueOption, IGetControlValueResult, ILocationControlOption, IRemoveControlOption, ISetControlExtensionOption, ISetControlHighlightOption, ISetControlProperties, ISetControlValueOption, IValidateOption } from '../../interface/Control';
 import { IAppendElementListOption, IDrawImagePayload, IForceUpdateOption, IGetImageOption, IGetValueOption, IPainterOption } from '../../interface/Draw';
 import { IEditorData, IEditorHTML, IEditorOption, IEditorResult, IEditorText, IFocusOption, ISetValueOption, IUpdateOption } from '../../interface/Editor';
+import { IColumnOption } from '../../interface/Column';
 import { IDeleteElementByIdOption, IElement, IElementPosition, IGetElementByIdOption, IImageCaption, IImageCrop, IInsertElementListOption, IUpdateElementByIdOption } from '../../interface/Element';
 import { ICopyOption, IPasteOption, IPositionContextByEventOption, IPositionContextByEventResult } from '../../interface/Event';
 import { IMargin } from '../../interface/Margin';
@@ -24,6 +26,7 @@ import { INavigateInfo } from '../draw/interactive/Search';
 import { IGetAreaValueOption, IGetAreaValueResult, IInsertAreaOption, ILocationAreaOption, IDeleteAreaOption, ISetAreaPropertiesOption, ISetAreaValueOption } from '../../interface/Area';
 import { IAreaBadge, IBadge } from '../../interface/Badge';
 import { IRichtextOption } from '../../interface/Command';
+import { IPrintOption } from '@/editor/interface/Print';
 export declare class CommandAdapt {
     private draw;
     private range;
@@ -89,6 +92,8 @@ export declare class CommandAdapt {
     tableTdBorderType(payload: TdBorder): void;
     tableTdSlashType(payload: TdSlash): void;
     tableTdBackgroundColor(payload: string): void;
+    tableAutoFitToContent(): void;
+    tableAutoFitToPage(): void;
     tableSelectAll(): void;
     hyperlink(payload: Pick<IElement, 'valueList' | 'hyperlinkId' | 'url'>): void;
     getHyperlinkRange(): [number, number] | null;
@@ -108,7 +113,7 @@ export declare class CommandAdapt {
     searchNavigateNext(): void;
     getSearchNavigateInfo(): null | INavigateInfo;
     replace(payload: string, option?: IReplaceOption): void;
-    print(): Promise<void>;
+    print(option?: IPrintOption): Promise<void>;
     replaceImageElement(payload: string): void;
     saveAsImageElement(): void;
     setImageCrop(crop: IImageCrop): void;
@@ -133,6 +138,8 @@ export declare class CommandAdapt {
     getKeywordRangeList(payload: string): IRange[];
     getKeywordContext(payload: string): ISearchResultContext[] | null;
     pageMode(payload: PageMode): void;
+    setColumns(config: IColumnOption | null): void;
+    getColumns(): IColumnOption | null;
     pageScale(scale: number): void;
     pageScaleRecovery(): void;
     pageScaleMinus(): void;
@@ -169,6 +176,8 @@ export declare class CommandAdapt {
     setControlExtensionList(payload: ISetControlExtensionOption[]): void;
     setControlProperties(payload: ISetControlProperties): void;
     setControlPropertiesList(payload: ISetControlProperties[]): void;
+    validate(payload?: IValidateOption): IControlValidateResult[];
+    clearValidate(): void;
     setControlHighlight(payload: ISetControlHighlightOption): void;
     updateOptions(payload: IUpdateOption): void;
     getControlList(): IElement[];
@@ -188,4 +197,7 @@ export declare class CommandAdapt {
     deleteArea(options?: IDeleteAreaOption): void;
     locationArea(areaId: string, options?: ILocationAreaOption): void;
     clearGraffiti(): void;
+    toggleTrace(payload?: boolean): void;
+    compare(payload: IComparePayload): void;
+    toggleRuler(payload?: boolean): void;
 }

package/dist/src/editor/core/draw/Draw.d.ts

@@ -1,7 +1,10 @@
 import { IAppendElementListOption, IComputeRowListPayload, IDrawOption, IDrawRowPayload, IGetImageOption, IGetOriginValueOption, IGetValueOption, IPainterOption } from '../../interface/Draw';
 import { IEditorData, IEditorOption, IEditorResult, ISetValueOption } from '../../interface/Editor';
 import { IElement, IElementStyle, ISpliceElementListOption, IInsertElementListOption } from '../../interface/Element';
+import { IMarkElementListDeletedOption } from '../../interface/Trace';
 import { IRow } from '../../interface/Row';
+import { IColumnLayout, IColumnOption } from '../../interface/Column';
+import { ColumnManager } from './column/ColumnManager';
 import { Cursor } from '../cursor/Cursor';
 import { CanvasEvent } from '../event/CanvasEvent';
 import { GlobalEvent } from '../event/GlobalEvent';
@@ -10,14 +13,22 @@ import { Listener } from '../listener/Listener';
 import { Position } from '../position/Position';
 import { RangeManager } from '../range/RangeManager';
 import { Search } from './interactive/Search';
+import { Strikeout } from './richtext/Strikeout';
+import { Underline } from './richtext/Underline';
 import { ImageParticle } from './particle/ImageParticle';
 import { TextParticle } from './particle/TextParticle';
 import { TableParticle } from './particle/table/TableParticle';
 import { TableTool } from './particle/table/TableTool';
+import { Ruler } from './ruler/Ruler';
 import { HyperlinkParticle } from './particle/HyperlinkParticle';
+import { TraceParticle } from './particle/TraceParticle';
 import { Header } from './frame/Header';
+import { SuperscriptParticle } from './particle/SuperscriptParticle';
+import { SubscriptParticle } from './particle/SubscriptParticle';
 import { EditorMode, PageMode, PaperDirection } from '../../dataset/enum/Editor';
 import { Control } from './control/Control';
+import { CascadeManager } from '../cascade/CascadeManager';
+import { Validate } from '../validate/Validate';
 import { CheckboxParticle } from './particle/CheckboxParticle';
 import { RadioParticle } from './particle/RadioParticle';
 import { DeepRequired, IPadding } from '../../interface/Common';
@@ -80,6 +91,7 @@ export declare class Draw {
     private laTexParticle;
     private textParticle;
     private tableParticle;
+    private tablePaging;
     private tableTool;
     private tableOperate;
     private pageNumber;
@@ -89,6 +101,7 @@ export declare class Draw {
     private header;
     private footer;
     private hyperlinkParticle;
+    private traceParticle;
     private labelParticle;
     private dateParticle;
     private separatorParticle;
@@ -102,6 +115,8 @@ export declare class Draw {
     private lineBreakParticle;
     private whiteSpaceParticle;
     private control;
+    private cascadeManager;
+    private validate;
     private pageBorder;
     private workerManager;
     private scrollObserver;
@@ -120,6 +135,8 @@ export declare class Draw {
     private lazyRenderIntersectionObserver;
     private printModeData;
     private controlMinWidthPlaceholderElementListSet;
+    private columnManager;
+    private ruler;
     constructor(rootContainer: HTMLElement, options: DeepRequired<IEditorOption>, data: IEditorData, listener: Listener, eventBus: EventBus<EventBusMap>, override: Override);
     setPrintData(): void;
     clearPrintData(): void;
@@ -130,7 +147,12 @@ export declare class Draw {
     isDisabled(): boolean;
     isDesignMode(): boolean;
     isPrintMode(): boolean;
+    isAreaHideDisabled(): boolean;
     isGraffitiMode(): boolean;
+    isTraceMode(): boolean;
+    setTraceEnabled(enabled: boolean): void;
+    setRulerEnabled(enabled: boolean): void;
+    deleteElementList(elementList: IElement[], index: number, count?: number, options?: IMarkElementListDeletedOption): IElement[];
     getOriginalWidth(): number;
     getOriginalHeight(): number;
     getWidth(): number;
@@ -140,6 +162,8 @@ export declare class Draw {
     getCanvasWidth(pageNo?: number): number;
     getCanvasHeight(pageNo?: number): number;
     getInnerWidth(): number;
+    getColumnLayout(): IColumnLayout | null;
+    setColumnConfig(config: IColumnOption | null): void;
     getOriginalInnerWidth(): number;
     getContextInnerWidth(): number;
     getMargins(): IMargin;
@@ -177,9 +201,14 @@ export declare class Draw {
     getHistoryManager(): HistoryManager;
     getPosition(): Position;
     getZone(): Zone;
+    getColumnManager(): ColumnManager;
     getRange(): RangeManager;
     getLineBreakParticle(): LineBreakParticle;
     getTextParticle(): TextParticle;
+    getStrikeout(): Strikeout;
+    getUnderline(): Underline;
+    getSubscriptParticle(): SubscriptParticle;
+    getSuperscriptParticle(): SuperscriptParticle;
     getHeaderElementList(): IElement[];
     getTableElementList(sourceElementList: IElement[]): IElement[];
     getElementList(): IElement[];
@@ -200,17 +229,21 @@ export declare class Draw {
     getPreviewer(): Previewer;
     getImageParticle(): ImageParticle;
     getTableTool(): TableTool;
+    getRuler(): Ruler;
     getTableOperate(): TableOperate;
     getTableParticle(): TableParticle;
     getBlockParticle(): BlockParticle;
     getHeader(): Header;
     getFooter(): Footer;
     getHyperlinkParticle(): HyperlinkParticle;
+    getTraceParticle(): TraceParticle;
     getDateParticle(): DateParticle;
     getListParticle(): ListParticle;
     getCheckboxParticle(): CheckboxParticle;
     getRadioParticle(): RadioParticle;
     getControl(): Control;
+    getCascadeManager(): CascadeManager;
+    getValidate(): Validate;
     getWorkerManager(): WorkerManager;
     getImageObserver(): ImageObserver;
     getI18n(): I18n;

package/dist/src/editor/core/draw/column/ColumnManager.d.ts

@@ -0,0 +1,14 @@
+import { IColumnLayout, IColumnOption } from '../../../interface/Column';
+import { Draw } from '../Draw';
+export declare class ColumnManager {
+    private draw;
+    private options;
+    private layout;
+    constructor(draw: Draw);
+    computeLayout(innerWidth: number, config: IColumnOption | undefined): IColumnLayout | null;
+    compute(): void;
+    getLayout(): IColumnLayout | null;
+    setConfig(config: IColumnOption | null | undefined): void;
+    getOffset(columnIndex: number | undefined): number;
+    drawSeparator(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/control/Control.d.ts

@@ -51,8 +51,11 @@ export declare class Control {
     reAwakeControl(): void;
     selectValue(): boolean;
     moveCursor(position: IControlInitOption): IMoveCursorResult;
+    getControlStartIndex(elementList: IElement[], startIndex: number, controlId: string): number;
+    getControlEndIndex(elementList: IElement[], startIndex: number, controlId: string): number;
     removeControl(startIndex: number, context?: IControlContext): number | null;
     removePlaceholder(startIndex: number, context?: IControlContext): void;
+    removePlaceholderInRange(elementList: IElement[], startIndex: number, count: number): number;
     addPlaceholder(startIndex: number, context?: IControlContext): void;
     setValue(data: IElement[]): number;
     setControlProperties(properties: Partial<IControl>, context?: IControlContext): void;

package/dist/src/editor/core/draw/interactive/Area.d.ts

@@ -17,6 +17,8 @@ export declare class Area {
     insertArea(payload: IInsertAreaOption): string | null;
     render(ctx: CanvasRenderingContext2D, pageNo: number): void;
     compute(): void;
+    private computeAreaInfo;
+    private computeTableAreaInfo;
     getAreaValue(options?: IGetAreaValueOption): IGetAreaValueResult | null;
     getContextByAreaId(areaId: string, options?: ILocationAreaOption): {
         range: IRange;

package/dist/src/editor/core/draw/interactive/Search.d.ts

@@ -28,4 +28,5 @@ export declare class Search {
     compute(payload: string): void;
     render(ctx: CanvasRenderingContext2D, pageIndex: number): void;
     replace(payload: string, option?: IReplaceOption): void;
+    private replaceWithTrace;
 }

package/dist/src/editor/core/draw/particle/ListParticle.d.ts

@@ -9,9 +9,19 @@ export declare class ListParticle {
     private readonly UN_COUNT_STYLE_WIDTH;
     private readonly MEASURE_BASE_TEXT;
     private readonly LIST_GAP;
+    readonly LIST_INDENT_WIDTH = 30;
+    private readonly MAX_LEVEL;
     constructor(draw: Draw);
     setList(listType: ListType | null, listStyle?: ListStyle): void;
     unsetList(): void;
+    increaseListLevel(): void;
+    decreaseListLevel(): void;
+    private applySegmentLevel;
+    private findPreviousListId;
+    private isParagraphStart;
+    private clearListInfo;
+    private clearPreviousEmptyListItems;
+    private extractListSegments;
     computeListStyle(ctx: CanvasRenderingContext2D, elementList: IElement[]): Map<string, number>;
     private findStyledElement;
     private getListFontStyle;

package/dist/src/editor/core/draw/particle/TraceParticle.d.ts

@@ -0,0 +1,40 @@
+import { IElement, IElementMetrics, IElementPosition } from '../../../interface/Element';
+import { IRow, IRowElement } from '../../../interface/Row';
+import { IMarkElementListDeletedOption } from '../../../interface/Trace';
+import { Draw } from '../Draw';
+interface ITraceRenderContext {
+    ctx: CanvasRenderingContext2D;
+    element: IRowElement;
+    x: number;
+    y: number;
+    curRow: IRow;
+    metrics: IElementMetrics;
+    offsetY: number;
+    scale: number;
+}
+export declare class TraceParticle {
+    private draw;
+    private options;
+    private container;
+    private tracePopupContainer;
+    private listDom;
+    private lastHoverKey;
+    private strikeoutState;
+    private underlineState;
+    private currentRow;
+    constructor(draw: Draw);
+    private _createTracePopupDom;
+    drawTracePopup(element: IElement, position: IElementPosition | undefined, pageNo: number): void;
+    clearTracePopup(): void;
+    handleMouseMove(evt: MouseEvent): void;
+    private _getTraceFlags;
+    render(context: ITraceRenderContext): void;
+    flush(ctx: CanvasRenderingContext2D): void;
+    private _flushStrikeout;
+    private _flushUnderline;
+    isTraceHidden(element: IElement): boolean;
+    private _markElementList;
+    markElementListInserted(elementList: IElement[]): void;
+    markElementListDeleted(elementList: IElement[], options?: IMarkElementListDeletedOption): IElement[];
+}
+export {};

package/dist/src/editor/core/draw/particle/table/TableOperate.d.ts

@@ -28,5 +28,8 @@ export declare class TableOperate {
     tableTdBorderType(payload: TdBorder): void;
     tableTdSlashType(payload: TdSlash): void;
     tableTdBackgroundColor(payload: string): void;
+    private _measureTdContentWidth;
+    tableAutoFitToContent(): void;
+    tableAutoFitToPage(): void;
     tableSelectAll(): void;
 }

package/dist/src/editor/core/draw/particle/table/TablePaging.d.ts

@@ -0,0 +1,13 @@
+import { IElement, ITableRowFragment } from '../../../../interface/Element';
+import { IRow } from '../../../../interface/Row';
+import { Draw } from '../../Draw';
+export declare class TablePaging {
+    private draw;
+    private options;
+    private tableParticle;
+    constructor(draw: Draw);
+    splitTableRowAcrossPages(rowList: IRow[]): IRow[];
+    truncateTableByFragment(element: IElement, fragment: ITableRowFragment, elementList: IElement[]): boolean;
+    private _trimTdContentToWindow;
+    private _repairTableContextAfterTruncate;
+}

package/dist/src/editor/core/draw/particle/table/TableParticle.d.ts

@@ -1,4 +1,6 @@
 import { IElement } from '../../../..';
+import { ITableRowFragment } from '../../../../interface/Element';
+import { IRow } from '../../../../interface/Row';
 import { ITd } from '../../../../interface/table/Td';
 import { ITr } from '../../../../interface/table/Tr';
 import { Draw } from '../../Draw';
@@ -6,19 +8,34 @@ export declare class TableParticle {
     private draw;
     private range;
     private options;
+    private fragmentContentHeightCache;
+    private tdLineHeightPrefixCache;
+    private fragmentTdListCache;
     constructor(draw: Draw);
     getTrListGroupByCol(payload: ITr[]): ITr[];
     getRangeRowCol(): ITd[][] | null;
     private _drawOuterBorder;
+    getFragmentTdList(element: IElement, fragment: ITableRowFragment): ITd[];
+    private _getDrawTdList;
     private _drawSlash;
     private _drawBorder;
     private _drawBackgroundColor;
     getTableWidth(element: IElement): number;
+    getFragmentTrHeight(tr: ITr, trIndex: number, fragment?: ITableRowFragment): number;
+    getFragmentContentHeight(element: IElement, fragment: Pick<ITableRowFragment, 'startTrIndex' | 'endTrIndex' | 'startSplitTrOffset' | 'endSplitTrHeight'>): number;
+    getTdWindowInFragment(td: ITd, element: IElement, fragment: ITableRowFragment): [number, number];
+    getTdWindowOffsetY(windowStart: number, fragment: ITableRowFragment): number;
+    getTdVisibleRowListByWindow(td: ITd, windowStart: number, windowEnd: number): {
+        rowList: IRow[];
+        startIndex: number;
+        startRowIndex: number;
+    };
+    getTdLineRangeBySplitWindow(td: ITd, windowStart: number, windowEnd: number): [number, 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;
+    drawRange(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
+    render(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
 }

package/dist/src/editor/core/draw/particle/table/TableTool.d.ts

@@ -22,6 +22,8 @@ export declare class TableTool {
     private anchorLine;
     private mousedownX;
     private mousedownY;
+    private lastAnchorKey;
+    private anchorPageNo;
     constructor(draw: Draw);
     dispose(): void;
     render(): void;

package/dist/src/editor/core/draw/ruler/Ruler.d.ts

@@ -0,0 +1,43 @@
+import { Draw } from '../Draw';
+export declare class Ruler {
+    private readonly MM_PX;
+    private readonly HANDLE_HIT_TOLERANCE;
+    private readonly MIN_INNER_SIZE;
+    private draw;
+    private options;
+    private container;
+    private rulerContainer;
+    private canvasX;
+    private ctxX;
+    private canvasY;
+    private ctxY;
+    private dragSide;
+    private dragStartPosition;
+    private dragOriginMargins;
+    private mousemoveHandler;
+    private mouseupHandler;
+    constructor(draw: Draw);
+    isEnable(): boolean;
+    private _createDOM;
+    setEnabled(enabled: boolean): void;
+    dispose(): void;
+    render(): void;
+    private _renderX;
+    private _renderY;
+    private _drawXHandle;
+    private _drawYHandle;
+    private _getHitMarginSideX;
+    private _getHitMarginSideY;
+    private _getRelativeX;
+    private _getRelativeY;
+    private _isMarginDragDisabled;
+    private _startDrag;
+    private _mousedownX;
+    private _mousedownY;
+    private _updateCursorX;
+    private _updateCursorY;
+    private _dragMargin;
+    private _stopDrag;
+    clampMargin(value: number, max: number): number;
+    private _setDisplayedMargins;
+}

package/dist/src/editor/core/macro/MacroManager.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from '../command/Command';
+import type { IMacro, IRecordedMacro, IScriptMacro, IMacroHandler } from '../../interface/Macro';
+export declare class MacroManager {
+    private macros;
+    private recording;
+    private isPlaying;
+    private command;
+    constructor(command: Command);
+    isRecording(): boolean;
+    startRecording(): void;
+    stopRecording(name: string): IRecordedMacro | null;
+    cancelRecording(): void;
+    play(idOrName: string, ...args: unknown[]): Promise<void>;
+    getMacros(): IMacro[];
+    getMacro(idOrName: string): IMacro | undefined;
+    removeMacro(idOrName: string): boolean;
+    exportMacros(): string;
+    importMacros(json: string, options?: {
+        overwrite?: boolean;
+    }): void;
+    register(name: string, handler: IMacroHandler): IScriptMacro;
+    unregister(idOrName: string): boolean;
+    private findMacro;
+    private logStep;
+}

package/dist/src/editor/core/position/Position.d.ts

@@ -1,19 +1,24 @@
 import { IComputePageRowPositionPayload, IComputePageRowPositionResult, IComputeRowPositionPayload, IFloatPosition, IGetFloatPositionByXYPayload, ISetSurroundPositionPayload } from '../../interface/Position';
 import { IElement, IElementPosition } from '../../interface/Element';
+import { ITd } from '../../interface/table/Td';
 import { ICurrentPosition, IGetPositionByXYPayload, IPositionContext } from '../../interface/Position';
 import { Draw } from '../draw/Draw';
 export declare class Position {
     private cursorPosition;
     private positionContext;
     private positionList;
+    private tablePagingPositionList;
+    private tablePagingPositionMap;
     private floatPositionList;
     private draw;
     private eventBus;
     private options;
     constructor(draw: Draw);
     getFloatPositionList(): IFloatPosition[];
+    getTablePagingPositionList(): IElementPosition[];
+    getTableFragmentPosition(index: number, pageNo: number, anchorPosition?: IElementPosition | null): IElementPosition | null;
     getTablePositionList(sourceElementList: IElement[]): IElementPosition[];
-    getTableTdByContext(sourceElementList: IElement[], context: IPositionContext): import("../../interface/table/Td").ITd | null;
+    getTableTdByContext(sourceElementList: IElement[], context: IPositionContext): ITd | null;
     buildTablePositionContext(context: IPositionContext, element: IElement, trIndex: number, tdIndex: number): IPositionContext;
     getTableElementByContext(sourceElementList: IElement[], context: IPositionContext): IElement | null;
     getTableElementPositionByContext(sourceElementList: IElement[], sourcePositionList: IElementPosition[], context: IPositionContext): IElementPosition | null;
@@ -31,12 +36,15 @@ export declare class Position {
         y: number;
     };
     computePageRowPosition(payload: IComputePageRowPositionPayload): IComputePageRowPositionResult;
+    private _offsetTdPositionByVerticalAlign;
     computePositionList(): void;
     computeRowPosition(payload: IComputeRowPositionPayload): IElementPosition[];
     setCursorPosition(position: IElementPosition | null): void;
     getCursorPosition(): IElementPosition | null;
     getPositionContext(): IPositionContext;
     setPositionContext(payload: IPositionContext): void;
+    private _getColumnIndexByX;
+    private _getTableChildPositionByXY;
     getPositionByXY(payload: IGetPositionByXYPayload): ICurrentPosition;
     getFloatPositionByXY(payload: IGetFloatPositionByXYPayload): ICurrentPosition | void;
     adjustPositionContext(payload: IGetPositionByXYPayload): ICurrentPosition | null;

package/dist/src/editor/core/validate/Validate.d.ts

@@ -0,0 +1,19 @@
+import { IControlValidateResult, IValidateOption } from '../../interface/Control';
+import { Draw } from '../draw/Draw';
+export declare class Validate {
+    private draw;
+    private control;
+    private i18n;
+    private highlightedControlIds;
+    private lastErrorBackgroundColor;
+    constructor(draw: Draw);
+    private collectControlElements;
+    private getNormalizedValue;
+    private isHidden;
+    private t;
+    private validateControl;
+    private walkAllControlElements;
+    private applyHighlight;
+    clearHighlight(): void;
+    execute(payload?: IValidateOption): IControlValidateResult[];
+}