@hufe921/canvas-editor 1.0.6 → 1.1.0

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

@@ -1,6 +1,7 @@
 import { IElement } from '../../..';
 import { IRowElement } from '../../../interface/Row';
 import { ITextMetrics } from '../../../interface/Text';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export interface IMeasureWordResult {
     width: number;
@@ -15,7 +16,10 @@ export declare class TextParticle {
     private text;
     private curStyle;
     private curColor?;
-    cacheMeasureText: Map<string, TextMetrics>;
+    private curSourceElement?;
+    private sourceKeys;
+    private sourceKeyId;
+    private textMeasurer;
     constructor(draw: Draw);
     measureBasisWord(ctx: CanvasRenderingContext2D, font: string): ITextMetrics;
     measureWord(ctx: CanvasRenderingContext2D, elementList: IElement[], curIndex: number): IMeasureWordResult;
@@ -23,7 +27,9 @@ export declare class TextParticle {
     measureText(ctx: CanvasRenderingContext2D, element: IElement): ITextMetrics;
     getBasisWordBoundingBoxAscent(ctx: CanvasRenderingContext2D, font: string): number;
     complete(): void;
-    record(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    renderTabLeader(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
+    record(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
     private _setCurXY;
+    private _getSourceKey;
     private _render;
 }

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

@@ -1,9 +1,10 @@
 import { IElement, IElementMetrics, IElementPosition } from '../../../interface/Element';
 import { IRow, IRowElement } from '../../../interface/Row';
 import { IMarkElementListDeletedOption } from '../../../interface/Trace';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 interface ITraceRenderContext {
-    ctx: CanvasRenderingContext2D;
+    ctx: IRenderContext;
     element: IRowElement;
     x: number;
     y: number;
@@ -29,7 +30,7 @@ export declare class TraceParticle {
     handleMouseMove(evt: MouseEvent): void;
     private _getTraceFlags;
     render(context: ITraceRenderContext): void;
-    flush(ctx: CanvasRenderingContext2D): void;
+    flush(ctx: IRenderContext): void;
     private _flushStrikeout;
     private _flushUnderline;
     isTraceHidden(element: IElement): boolean;

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

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

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

@@ -1,5 +1,6 @@
 import { IIframeInfo } from '../../../../interface/Block';
 import { IRowElement } from '../../../../interface/Row';
+import type { IRenderContext } from '../../../render/model/RenderContext';
 import { Draw } from '../../Draw';
 export declare class BlockParticle {
     private draw;
@@ -11,9 +12,10 @@ export declare class BlockParticle {
     private _createBlockContainer;
     getDraw(): Draw;
     getBlockContainer(): HTMLDivElement;
-    render(ctx: CanvasRenderingContext2D, pageNo: number, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, pageNo: number, element: IRowElement, x: number, y: number): void;
     clear(): void;
     update(): void;
     drawIframeToPage(pageList: HTMLCanvasElement[], snapDomFunction: (iframe: HTMLIFrameElement) => Promise<string>): Promise<void>;
+    drawIframeToSvgPage(pageList: SVGSVGElement[], snapDomFunction: (iframe: HTMLIFrameElement) => Promise<string>): Promise<void>;
     pickIframeInfo(): IIframeInfo[][];
 }

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

@@ -1,4 +1,5 @@
 import { IRowElement } from '../../../../../interface/Row';
+import type { IRenderContext } from '../../../../render/model/RenderContext';
 import { BlockParticle } from '../BlockParticle';
 import { IFrameBlock } from './IFrameBlock';
 import { VideoBlock } from './VideoBlock';
@@ -33,7 +34,7 @@ export declare class BaseBlock {
     private _updateResizerRect;
     private _mousedown;
     private _mousemove;
-    snapshot(ctx: CanvasRenderingContext2D, pageNo: number, x: number, y: number): void;
+    snapshot(ctx: IRenderContext, pageNo: number, x: number, y: number): void;
     render(): void;
     setClientRects(pageNo: number, x: number, y: number): void;
     setStatus(): void;

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

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

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

@@ -1,7 +1,12 @@
 import { IElement } from '../../../../interface/Element';
+import { IRenderContext } from '../../../render/model/RenderContext';
+import { Draw } from '../../Draw';
 import { ImageParticle } from '../ImageParticle';
 import { LaTexSVG } from './utils/LaTexUtils';
 export declare class LaTexParticle extends ImageParticle {
+    private latexDraw;
+    private pendingLaTexMap;
+    constructor(draw: Draw);
     static convertLaTextToSVG(laTex: string): LaTexSVG;
-    render(ctx: CanvasRenderingContext2D, element: IElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IElement, x: number, y: number): void;
 }

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

@@ -3,6 +3,7 @@ import { ITableRowFragment } from '../../../../interface/Element';
 import { IRow } from '../../../../interface/Row';
 import { ITd } from '../../../../interface/table/Td';
 import { ITr } from '../../../../interface/table/Tr';
+import { IRenderContext } from '../../../render/model/RenderContext';
 import { Draw } from '../../Draw';
 export declare class TableParticle {
     private draw;
@@ -36,6 +37,6 @@ export declare class TableParticle {
     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, fragment?: ITableRowFragment): void;
-    render(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
+    drawRange(ctx: IRenderContext, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
+    render(ctx: IRenderContext, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
 }

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

@@ -1,11 +1,12 @@
 import { TextDecorationStyle } from '../../../dataset/enum/Text';
 import { IElementFillRect } from '../../../interface/Element';
+import type { IRenderContext } from '../../render/model/RenderContext';
 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;
+    recordFillInfo(ctx: IRenderContext, x: number, y: number, width: number, height?: number, color?: string, decorationStyle?: TextDecorationStyle): void;
+    abstract render(ctx: IRenderContext): void;
 }

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

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

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

@@ -1,7 +1,8 @@
 import { AbstractRichText } from './AbstractRichText';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class Strikeout extends AbstractRichText {
     private options;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D): void;
+    render(ctx: IRenderContext): void;
 }

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

@@ -1,4 +1,5 @@
 import { AbstractRichText } from './AbstractRichText';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class Underline extends AbstractRichText {
     private options;
@@ -6,5 +7,5 @@ export declare class Underline extends AbstractRichText {
     private _drawLine;
     private _drawDouble;
     private _drawWave;
-    render(ctx: CanvasRenderingContext2D): void;
+    render(ctx: IRenderContext): void;
 }

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

@@ -3,6 +3,7 @@ export declare class Ruler {
     private readonly MM_PX;
     private readonly HANDLE_HIT_TOLERANCE;
     private readonly MIN_INNER_SIZE;
+    private readonly MIN_INNER_SIZE_INDENT;
     private draw;
     private options;
     private container;
@@ -14,6 +15,17 @@ export declare class Ruler {
     private dragSide;
     private dragStartPosition;
     private dragOriginMargins;
+    private dragIndentTarget;
+    private dragOriginIndents;
+    private isIndentApplied;
+    private dragTabStopIndex;
+    private dragOriginTabStops;
+    private dragOriginTabStopX;
+    private isTabStopApplied;
+    private isTabStopDragOutside;
+    private guideline;
+    private indentMarkerPositionCache;
+    private tabStopPositionCache;
     private mousemoveHandler;
     private mouseupHandler;
     constructor(draw: Draw);
@@ -24,18 +36,35 @@ export declare class Ruler {
     render(): void;
     private _renderX;
     private _renderY;
-    private _drawXHandle;
-    private _drawYHandle;
+    private _getParagraphElementList;
+    private _getParagraphIndents;
+    private _getFirstParagraphElementList;
+    private _getIndentAnchor;
+    private _getParagraphTabStops;
+    private _getIndentMarkerPositions;
+    private _drawIndentMarker;
+    private _drawTabStopMark;
+    private _getHitIndentTarget;
+    private _getHitTabStopIndex;
+    private _addTabStop;
+    private _showGuideline;
+    private _removeGuideline;
     private _getHitMarginSideX;
     private _getHitMarginSideY;
     private _getRelativeX;
     private _getRelativeY;
+    private _getRelativeYOnCanvasX;
     private _isMarginDragDisabled;
     private _startDrag;
+    private _startIndentDrag;
+    private _startTabStopDrag;
     private _mousedownX;
     private _mousedownY;
     private _updateCursorX;
     private _updateCursorY;
+    private _resetCursor;
+    private _dragIndent;
+    private _dragTabStop;
     private _dragMargin;
     private _stopDrag;
     clampMargin(value: number, max: number): number;

package/dist/src/editor/core/event/pagePointer.d.ts

@@ -0,0 +1,8 @@
+import type { RenderPage } from '../render/RenderBackend';
+export interface IPagePointer {
+    x: number;
+    y: number;
+    pageNo: number;
+    page: RenderPage;
+}
+export declare function getPagePointer(evt: MouseEvent, pageContainer: HTMLElement): IPagePointer | null;

package/dist/src/editor/core/layout/LayoutEngine.d.ts

@@ -0,0 +1,31 @@
+import { PageMode, PaperDirection } from '../../dataset/enum/Editor';
+import { IComputeRowListPayload } from '../../interface/Draw';
+import { IElement } from '../../interface/Element';
+import { IRow } from '../../interface/Row';
+import type { Draw } from '../draw/Draw';
+export interface IComputePageListPayload {
+    rowList: IRow[];
+    elementList: IElement[];
+    pageMode: PageMode;
+    paperDirection: PaperDirection;
+    maxPageNo?: number | null;
+}
+export interface IComputePageListResult {
+    pageRowList: IRow[][];
+    pageDirectionList: PaperDirection[];
+    elementList: IElement[];
+    isElementListTruncated: boolean;
+}
+export declare class LayoutEngine {
+    private draw;
+    private controlMinWidthPlaceholderElementListSet;
+    constructor(draw: Draw);
+    consumeControlMinWidthPlaceholders(elementList: IElement[]): void;
+    markControlMinWidthPlaceholders(elementList: IElement[]): void;
+    getIsControlMinWidthPlaceholder(elementList: IElement[]): boolean;
+    computeRowList(payload: IComputeRowListPayload): IRow[];
+    computePageList(payload: IComputePageListPayload): IComputePageListResult;
+    private _getHitTabStop;
+    private _isHangPunctuation;
+    private _getTabRunWidth;
+}

package/dist/src/editor/core/layout/TextMeasurer.d.ts

@@ -0,0 +1,10 @@
+import { IElement } from '../../interface/Element';
+import { ITextMetrics } from '../../interface/Text';
+export declare class TextMeasurer {
+    private ctx;
+    private cache;
+    constructor(ctx?: CanvasRenderingContext2D);
+    measure(element: IElement, font: string, ctx?: CanvasRenderingContext2D): ITextMetrics;
+    measureText(value: string, font: string, ctx?: CanvasRenderingContext2D): ITextMetrics;
+    measureBasis(font: string, ctx?: CanvasRenderingContext2D): ITextMetrics;
+}

package/dist/src/editor/core/range/RangeManager.d.ts

@@ -2,6 +2,7 @@ import { IControlContext } from '../../interface/Control';
 import { IElement } from '../../interface/Element';
 import { IRange, IRangeElementStyle, IRangeParagraphInfo, RangeRowArray, RangeRowMap } from '../../interface/Range';
 import { Draw } from '../draw/Draw';
+import type { IRenderContext } from '../render/model/RenderContext';
 export declare class RangeManager {
     private draw;
     private options;
@@ -40,6 +41,6 @@ export declare class RangeManager {
     setRangeStyle(): void;
     recoveryRangeStyle(): void;
     shrinkBoundary(context?: IControlContext): void;
-    render(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number): void;
+    render(ctx: IRenderContext, x: number, y: number, width: number, height: number): void;
     toString(): string;
 }

package/dist/src/editor/core/render/BackendFactory.d.ts

@@ -0,0 +1,3 @@
+import { BackendType } from '../../dataset/enum/Editor';
+import type { IRenderBackend } from './RenderBackend';
+export declare function createBackend(type: BackendType | undefined, pageContainer: HTMLElement): IRenderBackend;

package/dist/src/editor/core/render/RenderBackend.d.ts

@@ -0,0 +1,24 @@
+import type { DisplayList } from './model/DisplayList';
+export type RenderPage = HTMLElement | SVGSVGElement;
+export interface IPageResizeOption {
+    gap?: number;
+    updateCssHeight?: boolean;
+}
+export interface ICanvasCapability {
+    getPage(pageNo: number): HTMLCanvasElement;
+    getPageList(): HTMLCanvasElement[];
+    getContext(pageNo: number): CanvasRenderingContext2D;
+}
+export interface IRenderBackend {
+    readonly canvas: ICanvasCapability | null;
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): void;
+    resize(pageNo: number, width: number, height: number, dpr: number, options?: IPageResizeOption): void;
+    resizeHeight(pageNo: number, height: number, dpr: number): void;
+    renderPage(pageNo: number, displayList: DisplayList): void;
+    flush?(): void;
+    observeVisibility(callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+    getPage(pageNo: number): RenderPage;
+    getPageList(): RenderPage[];
+    destroy(): void;
+}

package/dist/src/editor/core/render/canvas/CanvasBackend.d.ts

@@ -0,0 +1,19 @@
+import type { DisplayList } from '../model/DisplayList';
+import type { ICanvasCapability, IPageResizeOption, IRenderBackend } from '../RenderBackend';
+export declare class CanvasBackend implements IRenderBackend, ICanvasCapability {
+    readonly canvas: ICanvasCapability;
+    private surface;
+    private renderer;
+    private pageList;
+    constructor(pageContainer: HTMLElement);
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): void;
+    resize(pageNo: number, width: number, height: number, dpr: number, options?: IPageResizeOption): void;
+    resizeHeight(pageNo: number, height: number, dpr: number): void;
+    renderPage(pageNo: number, displayList: DisplayList): void;
+    observeVisibility(callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+    getPage(pageNo: number): HTMLCanvasElement;
+    getPageList(): HTMLCanvasElement[];
+    getContext(pageNo: number): CanvasRenderingContext2D;
+    destroy(): void;
+}

package/dist/src/editor/core/render/canvas/CanvasRenderer.d.ts

@@ -0,0 +1,5 @@
+import { DisplayList } from '../model/DisplayList';
+export declare class CanvasRenderer {
+    render(ctx: CanvasRenderingContext2D, displayList: DisplayList): void;
+    private _isRenderPattern;
+}

package/dist/src/editor/core/render/canvas/CanvasSurface.d.ts

@@ -0,0 +1,17 @@
+export declare class CanvasSurface {
+    private pageContainer;
+    private visibilityObserver;
+    constructor(pageContainer: HTMLElement);
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): {
+        page: HTMLCanvasElement;
+        ctx: CanvasRenderingContext2D;
+    };
+    private initializeContext;
+    resize(page: HTMLCanvasElement, ctx: CanvasRenderingContext2D, width: number, height: number, dpr: number, options?: {
+        gap?: number;
+        updateCssHeight?: boolean;
+    }): void;
+    resizeHeight(page: HTMLCanvasElement, ctx: CanvasRenderingContext2D, height: number, dpr: number): void;
+    observeVisibility(pageList: Element[], callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+}

package/dist/src/editor/core/render/model/DisplayList.d.ts

@@ -0,0 +1,62 @@
+import type { ISceneResourceIdentity, SceneGroupKind } from '../svg/scene/SceneNode';
+import { IRenderContext, IRenderPattern, IRenderSource } from './RenderContext';
+export type IRenderMethodName = 'save' | 'restore' | 'fillRect' | 'beginPath' | 'moveTo' | 'lineTo' | 'arc' | 'quadraticCurveTo' | 'bezierCurveTo' | 'rect' | 'closePath' | 'fill' | 'strokeRect' | 'scale' | 'rotate' | 'clip' | 'fillText' | 'translate' | 'stroke' | 'drawImage' | 'setLineDash';
+export type IRenderOperation = {
+    type: 'set';
+    property: string;
+    value: unknown;
+} | {
+    type: IRenderMethodName;
+    args: unknown[];
+} | {
+    type: 'beginGroup';
+    key: string;
+    kind: SceneGroupKind;
+} | {
+    type: 'endGroup';
+};
+export declare class DisplayList implements IRenderContext {
+    private operations;
+    private state;
+    private stateStack;
+    constructor();
+    getOperations(): readonly IRenderOperation[];
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    set fillStyle(value: string | CanvasGradient | CanvasPattern | IRenderPattern);
+    set strokeStyle(value: string | CanvasGradient | CanvasPattern);
+    set font(value: string);
+    set globalAlpha(value: number);
+    set textAlign(value: 'center' | 'end' | 'left' | 'right' | 'start');
+    set textBaseline(value: CanvasTextBaseline);
+    set lineCap(value: 'butt' | 'round' | 'square');
+    set lineJoin(value: 'bevel' | 'miter' | 'round');
+    setLineDash(segments: number[]): void;
+    getLineDash(): number[];
+    createPattern(image: CanvasImageSource, repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat', resource?: ISceneResourceIdentity): IRenderPattern;
+    beginGroup(key: string, kind: SceneGroupKind): void;
+    endGroup(): void;
+    save(): void;
+    restore(): void;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    closePath(): void;
+    fill(): void;
+    strokeRect(x: number, y: number, width: number, height: number): void;
+    scale(x: number, y: number): void;
+    rotate(angle: number): void;
+    clip(): void;
+    fillText(text: string, x: number, y: number): void;
+    fillTextWithSource(text: string, x: number, y: number, source: IRenderSource): void;
+    translate(x: number, y: number): void;
+    stroke(): void;
+    drawImage(image: CanvasImageSource, ...args: [number, number, number, number] | [number, number, number, number, number, number, number, number]): void;
+    private set;
+    private record;
+}

package/dist/src/editor/core/render/model/RenderContext.d.ts

@@ -0,0 +1,48 @@
+import type { ISceneResourceIdentity, SceneGroupKind } from '../svg/scene/SceneNode';
+export interface IRenderPattern {
+    type: 'pattern';
+    image: CanvasImageSource;
+    repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+    resource?: ISceneResourceIdentity;
+}
+export interface IRenderSource {
+    key: string;
+}
+export interface IRenderContext {
+    fillStyle: any;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    font: string;
+    globalAlpha: number;
+    textAlign: 'center' | 'end' | 'left' | 'right' | 'start';
+    textBaseline: CanvasTextBaseline;
+    lineWidth: number;
+    lineCap: 'butt' | 'round' | 'square';
+    lineJoin: 'bevel' | 'miter' | 'round';
+    beginGroup?(key: string, kind: SceneGroupKind): void;
+    endGroup?(): void;
+    save(): void;
+    restore(): void;
+    setLineDash(segments: number[]): void;
+    getLineDash(): number[];
+    createPattern(image: CanvasImageSource, repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat', resource?: ISceneResourceIdentity): CanvasPattern | IRenderPattern | null;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    strokeRect(x: number, y: number, width: number, height: number): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    fill(): void;
+    stroke(): void;
+    clip(): void;
+    fillText(text: string, x: number, y: number): void;
+    fillTextWithSource?(text: string, x: number, y: number, source: IRenderSource): void;
+    translate(x: number, y: number): void;
+    scale(x: number, y: number): void;
+    rotate(angle: number): void;
+    drawImage(image: CanvasImageSource, x: number, y: number, width: number, height: number): void;
+    drawImage(image: CanvasImageSource, sx: number, sy: number, sWidth: number, sHeight: number, dx: number, dy: number, dWidth: number, dHeight: number): void;
+}

package/dist/src/editor/core/render/svg/SvgBackend.d.ts

@@ -0,0 +1,22 @@
+import type { DisplayList } from '../model/DisplayList';
+import type { IPageResizeOption, IRenderBackend } from '../RenderBackend';
+export declare class SvgBackend implements IRenderBackend {
+    readonly canvas: null;
+    private surface;
+    private renderer;
+    private pageList;
+    private renderedPages;
+    private pendingPages;
+    private frameId;
+    constructor(pageContainer: HTMLElement);
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): void;
+    resize(pageNo: number, width: number, height: number, dpr: number, options?: IPageResizeOption): void;
+    resizeHeight(pageNo: number, height: number, dpr: number): void;
+    renderPage(pageNo: number, displayList: DisplayList): void;
+    flush(): void;
+    observeVisibility(callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+    getPage(pageNo: number): SVGSVGElement;
+    getPageList(): SVGSVGElement[];
+    destroy(): void;
+}

package/dist/src/editor/core/render/svg/SvgRenderer.d.ts

@@ -0,0 +1,9 @@
+import type { DisplayList } from '../model/DisplayList';
+export declare class SvgRenderer {
+    private compiler;
+    private reconciler;
+    private resourceScopes;
+    constructor();
+    render(host: SVGSVGElement, displayList: DisplayList): void;
+    private _getResourceScope;
+}

package/dist/src/editor/core/render/svg/SvgSurface.d.ts

@@ -0,0 +1,13 @@
+import type { IPageResizeOption } from '../RenderBackend';
+export declare class SvgSurface {
+    private pageContainer;
+    private visibilityObserver;
+    constructor(pageContainer: HTMLElement);
+    create(pageNo: number, width: number, height: number, gap: number): {
+        page: SVGSVGElement;
+    };
+    resize(page: SVGSVGElement, width: number, height: number, options?: IPageResizeOption): void;
+    resizeHeight(page: SVGSVGElement, height: number): void;
+    observeVisibility(pageList: Element[], callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+}

package/dist/src/editor/core/render/svg/scene/PathCompiler.d.ts

@@ -0,0 +1,16 @@
+export declare class PathCompiler {
+    private commands;
+    private currentPoint;
+    private subpathStart;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    closePath(): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    getPathData(): string;
+    private _connectTo;
+    private _arcTo;
+    private _number;
+}

package/dist/src/editor/core/render/svg/scene/ResourceKey.d.ts

@@ -0,0 +1,7 @@
+import type { IRenderPattern } from '../../model/RenderContext';
+export declare function buildPatternResourceKey(pattern: IRenderPattern): string;
+export declare function createResourceId(kind: string, resourceKey: string, scope?: string): string;
+export declare function getImageSize(image: CanvasImageSource): {
+    width: number;
+    height: number;
+};

package/dist/src/editor/core/render/svg/scene/SceneCompiler.d.ts

@@ -0,0 +1,9 @@
+import type { DisplayList } from '../../model/DisplayList';
+import type { SceneNode } from './SceneNode';
+export declare class SceneCompiler {
+    compile(displayList: DisplayList, resourceScope?: string): SceneNode;
+    private _createInitialState;
+    private _isRenderPattern;
+    private _multiplyMatrix;
+    private _serializeMatrix;
+}

package/dist/src/editor/core/render/svg/scene/SceneKey.d.ts

@@ -0,0 +1,28 @@
+import type { EditorZone } from '../../../../dataset/enum/Editor';
+export interface IRowKeyPayload {
+    zoneKey: string;
+    containerKey: string;
+    occurrence: number;
+}
+export interface ITableFragmentKeyPayload {
+    containerKey: string;
+    tableId?: string;
+    tablePath: string[];
+    startTrIndex: number;
+    endTrIndex: number;
+    startSplitTrOffset?: number;
+    endSplitTrHeight?: number;
+}
+export interface IRepeatHeaderKeyPayload {
+    fragmentKey: string;
+    trIndex: number;
+    tdIndex: number;
+    tdId?: string;
+}
+export declare function buildSourceTextKey(sourceKeyId: number): string;
+export declare function buildPageKey(pageNo: number): string;
+export declare function buildLayerKey(pageNo: number, layer: string): string;
+export declare function buildZoneKey(zone: EditorZone, pageNo: number): string;
+export declare function buildRowKey(payload: IRowKeyPayload): string;
+export declare function buildTableFragmentKey(payload: ITableFragmentKeyPayload): string;
+export declare function buildRepeatHeaderKey(payload: IRepeatHeaderKeyPayload): string;