@agile_jy/word-editor 0.0.1

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

@@ -0,0 +1,27 @@
+import { Draw } from '../Draw';
+import { IAreaInfo, IGetAreaValueOption, IGetAreaValueResult, IInsertAreaOption, ILocationAreaOption, ISetAreaPropertiesOption, ISetAreaValueOption } from '../../../interface/Area';
+import { IRange } from '../../../interface/Range';
+import { IElementPosition } from '../../../interface/Element';
+export declare class Area {
+    private draw;
+    private zone;
+    private range;
+    private position;
+    private options;
+    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;
+    setAreaValue(payload: ISetAreaValueOption): void;
+}

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

@@ -0,0 +1,18 @@
+import { IElement } from '../../../interface/Element';
+import { IPositionContext } from '../../../interface/Position';
+import { IRange } from '../../../interface/Range';
+import { Draw } from '../Draw';
+export declare class Group {
+    private draw;
+    private options;
+    private range;
+    private fillRectMap;
+    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;
+}

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

@@ -0,0 +1,30 @@
+import { IElement, IElementPosition } from '../../../interface/Element';
+import { IReplaceOption, ISearchOption, ISearchResult } from '../../../interface/Search';
+import { Draw } from '../Draw';
+export interface INavigateInfo {
+    index: number;
+    count: number;
+}
+export declare class Search {
+    private draw;
+    private options;
+    private position;
+    private range;
+    private searchKeyword;
+    private searchNavigateIndex;
+    private searchOptions;
+    private searchMatchList;
+    constructor(draw: Draw);
+    getSearchKeyword(): string | null;
+    setSearchKeyword(payload: string | null, options?: ISearchOption): 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;
+}

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

@@ -0,0 +1,18 @@
+import { IElement } from '../../../interface/Element';
+import { IRow } from '../../../interface/Row';
+import { Draw } from '../Draw';
+interface ICheckboxRenderOption {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    row: IRow;
+    index: number;
+}
+export declare class CheckboxParticle {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    setSelect(element: IElement): void;
+    render(payload: ICheckboxRenderOption): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { IElement } from '../../..';
+import { IElementPosition } from '../../../interface/Element';
+import { IRowElement } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class HyperlinkParticle {
+    private draw;
+    private options;
+    private container;
+    private hyperlinkPopupContainer;
+    private hyperlinkDom;
+    constructor(draw: Draw);
+    private _createHyperlinkPopupDom;
+    drawHyperlinkPopup(element: IElement, position: IElementPosition): void;
+    clearHyperlinkPopup(): void;
+    openHyperlink(element: IElement): void;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}

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

@@ -0,0 +1,23 @@
+import { DeepRequired } from '../../../interface/Common';
+import { IEditorOption } from '../../../interface/Editor';
+import { IElement } from '../../../interface/Element';
+import { Draw } from '../Draw';
+export declare class ImageParticle {
+    private draw;
+    protected options: DeepRequired<IEditorOption>;
+    protected imageCache: Map<string, HTMLImageElement>;
+    private container;
+    private floatImageContainer;
+    private floatImage;
+    constructor(draw: Draw);
+    getOriginalMainImageList(): IElement[];
+    private _countImagesBeforeTarget;
+    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;
+    private _drawImageWithCrop;
+    private _renderCaption;
+    render(ctx: CanvasRenderingContext2D, element: IElement, x: number, y: number): void;
+}

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

@@ -0,0 +1,8 @@
+import { IRowElement } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class LabelParticle {
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    private _drawRoundedRect;
+}

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

@@ -0,0 +1,10 @@
+import { IRowElement } from '../../../interface/Row';
+import { Draw } from '../Draw';
+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;
+}

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

@@ -0,0 +1,20 @@
+import { ListStyle, ListType } from '../../../dataset/enum/List';
+import { IElement, IElementPosition } from '../../../interface/Element';
+import { IRow } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class ListParticle {
+    private draw;
+    private range;
+    private options;
+    private readonly UN_COUNT_STYLE_WIDTH;
+    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>;
+    private findStyledElement;
+    private getListFontStyle;
+    getListStyleWidth(ctx: CanvasRenderingContext2D, listElementList: IElement[]): number;
+    drawListStyle(ctx: CanvasRenderingContext2D, row: IRow, position: IElementPosition): void;
+}

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

@@ -0,0 +1,9 @@
+import { IRowElement } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class PageBreakParticle {
+    private draw;
+    private options;
+    private i18n;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}

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

@@ -0,0 +1,18 @@
+import { IElement } from '../../../interface/Element';
+import { IRow } from '../../../interface/Row';
+import { Draw } from '../Draw';
+interface IRadioRenderOption {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    row: IRow;
+    index: number;
+}
+export declare class RadioParticle {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    setSelect(element: IElement): void;
+    render(payload: IRadioRenderOption): void;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { IRowElement } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class SeparatorParticle {
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}

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

@@ -0,0 +1,5 @@
+import { IRowElement } from '../../../interface/Row';
+export declare class SubscriptParticle {
+    getOffsetY(element: IRowElement): number;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}

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

@@ -0,0 +1,5 @@
+import { IRowElement } from '../../../interface/Row';
+export declare class SuperscriptParticle {
+    getOffsetY(element: IRowElement): number;
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}

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

@@ -0,0 +1,29 @@
+import { IElement } from '../../..';
+import { IRowElement } from '../../../interface/Row';
+import { ITextMetrics } from '../../../interface/Text';
+import { Draw } from '../Draw';
+export interface IMeasureWordResult {
+    width: number;
+    endElement: IElement | null;
+}
+export declare class TextParticle {
+    private draw;
+    private options;
+    private ctx;
+    private curX;
+    private curY;
+    private text;
+    private curStyle;
+    private curColor?;
+    cacheMeasureText: Map<string, TextMetrics>;
+    constructor(draw: Draw);
+    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;
+    getBasisWordBoundingBoxAscent(ctx: CanvasRenderingContext2D, font: string): number;
+    complete(): void;
+    record(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    private _setCurXY;
+    private _render;
+}

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

@@ -0,0 +1,7 @@
+import { IRowElement } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class WhiteSpaceParticle {
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+}

package/dist/src/editor/core/draw/particle/block/BlockParticle.d.ts

@@ -0,0 +1,14 @@
+import { IRowElement } from '../../../../interface/Row';
+import { Draw } from '../../Draw';
+export declare class BlockParticle {
+    private draw;
+    private container;
+    private blockContainer;
+    private blockMap;
+    constructor(draw: Draw);
+    private _createBlockContainer;
+    getDraw(): Draw;
+    getBlockContainer(): HTMLDivElement;
+    render(ctx: CanvasRenderingContext2D, pageNo: number, element: IRowElement, x: number, y: number): void;
+    clear(): void;
+}

package/dist/src/editor/core/draw/particle/block/modules/BaseBlock.d.ts

@@ -0,0 +1,33 @@
+import { IRowElement } from '../../../../../interface/Row';
+import { BlockParticle } from '../BlockParticle';
+import { IFrameBlock } from './IFrameBlock';
+import { VideoBlock } from './VideoBlock';
+export declare class BaseBlock {
+    private draw;
+    private options;
+    private element;
+    private block;
+    private blockContainer;
+    private blockItem;
+    protected blockCache: Map<string, IFrameBlock | VideoBlock>;
+    private resizerMask;
+    private resizerSelection;
+    private resizerHandleList;
+    private width;
+    private height;
+    private mousedownX;
+    private mousedownY;
+    private curHandleIndex;
+    private isAllowResize;
+    constructor(blockParticle: BlockParticle, element: IRowElement);
+    getBlockElement(): IRowElement;
+    getBlockWidth(): number;
+    private _createBlockItem;
+    private _updateResizerRect;
+    private _mousedown;
+    private _mousemove;
+    snapshot(ctx: CanvasRenderingContext2D, x: number, y: number): void;
+    render(): void;
+    setClientRects(pageNo: number, x: number, y: number): void;
+    remove(): void;
+}

package/dist/src/editor/core/draw/particle/block/modules/IFrameBlock.d.ts

@@ -0,0 +1,9 @@
+import { IRowElement } from '../../../../../interface/Row';
+export declare class IFrameBlock {
+    static readonly sandbox: string[];
+    static readonly allow: string[];
+    private element;
+    constructor(element: IRowElement);
+    private _defineIframeProperties;
+    render(blockItemContainer: HTMLDivElement): void;
+}

package/dist/src/editor/core/draw/particle/block/modules/VideoBlock.d.ts

@@ -0,0 +1,8 @@
+import { IRowElement } from '../../../../../interface/Row';
+export declare class VideoBlock {
+    private element;
+    protected videoCache: Map<string, HTMLVideoElement>;
+    constructor(element: IRowElement);
+    snapshot(ctx: CanvasRenderingContext2D, x: number, y: number): Promise<unknown>;
+    render(blockItemContainer: HTMLDivElement): void;
+}

package/dist/src/editor/core/draw/particle/date/DateParticle.d.ts

@@ -0,0 +1,13 @@
+import { IElement, IElementPosition } from '../../../../interface/Element';
+import { Draw } from '../../Draw';
+export declare class DateParticle {
+    private draw;
+    private range;
+    private datePicker;
+    private options;
+    constructor(draw: Draw);
+    private _setValue;
+    getDateElementRange(): [number, number] | null;
+    clearDatePicker(): void;
+    renderDatePicker(element: IElement, position: IElementPosition): void;
+}

package/dist/src/editor/core/draw/particle/date/DatePicker.d.ts

@@ -0,0 +1,64 @@
+import { IElementPosition } from '../../../../interface/Element';
+import { Draw } from '../../Draw';
+export interface IDatePickerLang {
+    now: string;
+    confirm: string;
+    return: string;
+    timeSelect: string;
+    weeks: {
+        sun: string;
+        mon: string;
+        tue: string;
+        wed: string;
+        thu: string;
+        fri: string;
+        sat: string;
+    };
+    year: string;
+    month: string;
+    hour: string;
+    minute: string;
+    second: string;
+}
+export interface IDatePickerOption {
+    onSubmit?: (date: string) => void;
+}
+interface IRenderOption {
+    value: string;
+    position: IElementPosition;
+    dateFormat?: string;
+}
+export declare class DatePicker {
+    private draw;
+    private options;
+    private now;
+    private dom;
+    private renderOptions;
+    private isDatePicker;
+    private pickDate;
+    private lang;
+    constructor(draw: Draw, options?: IDatePickerOption);
+    private _createDom;
+    private _bindEvent;
+    private _setPosition;
+    isInvalidDate(value: Date): boolean;
+    private _setValue;
+    private _getLang;
+    private _setLangChange;
+    private _update;
+    private _toggleDateTimePicker;
+    private _setDatePick;
+    private _setTimePick;
+    private _preMonth;
+    private _nextMonth;
+    private _preYear;
+    private _nextYear;
+    private _now;
+    private _toggleVisible;
+    private _submit;
+    formatDate(date: Date, format?: string): string;
+    render(option: IRenderOption): void;
+    dispose(): void;
+    destroy(): void;
+}
+export {};

package/dist/src/editor/core/draw/particle/latex/LaTexParticle.d.ts

@@ -0,0 +1,7 @@
+import { IElement } from '../../../../interface/Element';
+import { ImageParticle } from '../ImageParticle';
+import { LaTexSVG } from './utils/LaTexUtils';
+export declare class LaTexParticle extends ImageParticle {
+    static convertLaTextToSVG(laTex: string): LaTexSVG;
+    render(ctx: CanvasRenderingContext2D, element: IElement, x: number, y: number): void;
+}

package/dist/src/editor/core/draw/particle/latex/utils/LaTexUtils.d.ts

@@ -0,0 +1,47 @@
+declare const CONFIG: Record<string, number>;
+interface Bbox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface Expr {
+    type: string;
+    text: string;
+    mode: string;
+    chld: Expr[];
+    bbox: Bbox;
+}
+interface ExportOpt {
+    MIN_CHAR_H?: number;
+    MAX_W?: number;
+    MAX_H?: number;
+    MARGIN_X?: number;
+    MARGIN_Y?: number;
+    SCALE_X?: number;
+    SCALE_Y?: number;
+    STROKE_W?: number;
+    FG_COLOR?: string;
+    BG_COLOR?: string;
+}
+export interface LaTexSVG {
+    svg: string;
+    width: number;
+    height: number;
+}
+export declare class LaTexUtils {
+    _latex: string;
+    _tree: Expr;
+    _tokens: string[];
+    _polylines: number[][][];
+    constructor(latex: string);
+    private resolveScale;
+    polylines(opt?: ExportOpt): number[][][];
+    pathd(opt?: ExportOpt): string;
+    svg(opt: ExportOpt): LaTexSVG;
+    pdf(opt: ExportOpt): string;
+    boxes(opt: ExportOpt): Bbox[];
+    box(opt: ExportOpt): Bbox;
+}
+declare const _impl: Record<string, Function>;
+export { CONFIG, _impl };

package/dist/src/editor/core/draw/particle/latex/utils/hershey.d.ts

@@ -0,0 +1,10 @@
+interface HersheyEntry {
+    w: number;
+    xmin: number;
+    xmax: number;
+    ymin: number;
+    ymax: number;
+    polylines: Array<Array<Array<number>>>;
+}
+export declare function HERSHEY(i: number): HersheyEntry;
+export {};

package/dist/src/editor/core/draw/particle/latex/utils/symbols.d.ts

@@ -0,0 +1,8 @@
+export interface Symb {
+    glyph: number;
+    arity?: number;
+    flags: Record<string, boolean>;
+}
+declare const SYMB: Record<string, Symb>;
+export { SYMB };
+export declare function asciiMap(x: string, mode?: string): number;

package/dist/src/editor/core/draw/particle/previewer/Previewer.d.ts

@@ -0,0 +1,47 @@
+import { IElement, IElementPosition } from '../../../../interface/Element';
+import { IPreviewerDrawOption } from '../../../../interface/Previewer';
+import { Draw } from '../../Draw';
+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;
+}

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

@@ -0,0 +1,32 @@
+import { IElement, TableBorder, VerticalAlign } from '../../../..';
+import { TdBorder, TdSlash } from '../../../../dataset/enum/table/Table';
+import { Draw } from '../../Draw';
+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;
+    tableTdBorderType(payload: TdBorder): void;
+    tableTdSlashType(payload: TdSlash): void;
+    tableTdBackgroundColor(payload: string): void;
+    tableSelectAll(): void;
+}

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

@@ -0,0 +1,24 @@
+import { IElement } from '../../../..';
+import { ITd } from '../../../../interface/table/Td';
+import { ITr } from '../../../../interface/table/Tr';
+import { Draw } from '../../Draw';
+export declare class TableParticle {
+    private draw;
+    private range;
+    private options;
+    constructor(draw: Draw);
+    getTrListGroupByCol(payload: ITr[]): ITr[];
+    getRangeRowCol(): ITd[][] | null;
+    private _drawOuterBorder;
+    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;
+}

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

@@ -0,0 +1,31 @@
+import { Draw } from '../../Draw';
+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;
+}

package/dist/src/editor/core/draw/richtext/AbstractRichText.d.ts

@@ -0,0 +1,11 @@
+import { TextDecorationStyle } from '../../../dataset/enum/Text';
+import { IElementFillRect } from '../../../interface/Element';
+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;
+}

package/dist/src/editor/core/draw/richtext/Highlight.d.ts

@@ -0,0 +1,7 @@
+import { AbstractRichText } from './AbstractRichText';
+import { Draw } from '../Draw';
+export declare class Highlight extends AbstractRichText {
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D): void;
+}