@leafer/interface 1.0.0-rc.9 → 1.0.1

package/types/index.d.ts

@@ -1,102 +1,33 @@
 import { ILeaferCanvas as ILeaferCanvas$1, IScreenSizeData as IScreenSizeData$1 } from '@leafer/interface';
 
-type INumber = number;
-type IBoolean = boolean;
-type IString = string;
-type IValue = INumber | IBoolean | IString | IObject;
-type ITimer = any;
-type IPathString = string;
-interface IObject {
-    [name: string]: any;
-}
-interface IBooleanMap {
-    [name: string]: boolean;
-}
-interface INumberMap {
-    [name: string]: number;
-}
-interface IStringMap {
-    [name: string]: string;
-}
-interface IDataTypeHandle {
-    (target: any): void;
-}
-
-interface ILeafMap {
-    [name: string]: ILeaf;
-}
-interface ILeafArrayMap {
-    [name: string]: ILeaf[];
-}
-type ILeafListItemCallback = (item: ILeaf, index?: number) => void;
-interface ILeafList {
-    list: ILeaf[];
-    keys: INumberMap;
-    readonly length: number;
-    has(leaf: ILeaf): boolean;
-    indexAt(index: number): ILeaf;
-    indexOf(leaf: ILeaf): number;
-    add(leaf: ILeaf): void;
-    addAt(leaf: ILeaf, index: number): void;
-    addList(list: ILeaf[]): void;
-    remove(leaf: ILeaf): void;
-    forEach(itemCallback: ILeafListItemCallback): void;
-    sort(reverse?: boolean): void;
-    clone(): ILeafList;
-    update(): void;
-    reset(): void;
-    destroy(): void;
-}
-interface ILeafLevelList {
-    levelMap: ILeafArrayMap;
-    keys: INumberMap;
-    levels: number[];
-    readonly length: number;
-    has(leaf: ILeaf): boolean;
-    without(leaf: ILeaf): boolean;
-    sort(reverse?: boolean): void;
-    addList(list: ILeaf[]): void;
-    add(leaf: ILeaf): void;
-    forEach(itemCallback: ILeafListItemCallback): void;
-    reset(): void;
-    destroy(): void;
+interface IPointData {
+    x: number;
+    y: number;
 }
-
-interface IControl {
-    start(): void;
-    stop(): void;
-    destroy(): void;
+interface IUnitPointData {
+    type?: 'percent' | 'px';
+    x: number;
+    y: number;
 }
-
-interface IWatchEventData {
-    updatedList: ILeafList;
+interface IFromToData {
+    from: IPointData;
+    to: IPointData;
 }
-interface IWatcherConfig {
+interface IScrollPointData {
+    scrollX: number;
+    scrollY: number;
 }
-interface IWatcher extends IControl {
-    target: ILeaf;
-    totalTimes: number;
-    disabled: boolean;
-    running: boolean;
-    changed: boolean;
-    hasVisible: boolean;
-    hasAdd: boolean;
-    hasRemove: boolean;
-    readonly childrenChanged: boolean;
-    config: IWatcherConfig;
-    updatedList: ILeafList;
-    disable(): void;
-    update(): void;
-}
-
-interface IPointData {
-    x: number;
-    y: number;
+interface IClientPointData {
+    clientX: number;
+    clientY: number;
 }
 interface IPoint extends IPointData {
     set(x?: number | IPointData, y?: number): IPoint;
     get(): IPointData;
     clone(): IPoint;
+    move(x: number, y: number): IPoint;
+    scale(scaleX: number, scaleY?: number): IPoint;
+    scaleOf(origin: IPointData, scaleX: number, scaleY?: number): IPoint;
     rotate(rotation: number, origin?: IPointData): IPoint;
     rotateOf(origin: IPointData, rotation: number): IPoint;
     getRotation(origin: IPointData, to: IPointData, toOrigin?: IPointData): number;
@@ -104,7 +35,7 @@ interface IPoint extends IPointData {
     toOuterOf(matrix: IMatrixData, to?: IPointData): IPoint;
     getCenter(to: IPointData): IPoint;
     getDistance(to: IPointData): number;
-    getDistancePoint(to: IPointData, distance: number): IPoint;
+    getDistancePoint(to: IPointData, distance: number, changeTo?: boolean): IPoint;
     getAngle(to: IPointData): number;
     getAtan2(to: IPointData): number;
     reset(): IPoint;
@@ -135,19 +66,25 @@ interface IBounds extends IBoundsData, ITwoPointBoundsData {
     set(x?: number | IBoundsData, y?: number, width?: number, height?: number): IBounds;
     get(): IBoundsData;
     clone(): IBounds;
+    move(x: number, y: number): IBounds;
     scale(scaleX: number, scaleY?: number): IBounds;
     scaleOf(origin: IPointData, scaleX: number, scaleY?: number): IBounds;
     toOuterOf(matrix: IMatrixData, to?: IBoundsData): IBounds;
-    getFitMatrix(put: IBoundsData): IMatrix;
-    spread(spreadX: number, spreadY?: number): IBounds;
+    toInnerOf(matrix: IMatrixData, to?: IBoundsData): IBounds;
+    getFitMatrix(put: IBoundsData, baseScale?: number): IMatrix;
+    spread(fourNumber: IFourNumber): IBounds;
+    shrink(fourNumber: IFourNumber): IBounds;
     ceil(): IBounds;
     unsign(): IBounds;
+    float(maxLength?: number): IBounds;
     add(bounds: IBoundsData): IBounds;
     addList(boundsList: IBoundsData[]): IBounds;
     setList(boundsList: IBoundsData[]): IBounds;
     addListWithFn(list: IObject[], boundsDataHandle: IBoundsDataFn): IBounds;
     setListWithFn(list: IObject[], boundsDataHandle: IBoundsDataFn): IBounds;
+    setPoint(point: IPointData): IBounds;
     setPoints(points: IPointData[]): IBounds;
+    addPoint(point: IPointData): IBounds;
     getPoints(): IPointData[];
     hitPoint(point: IPointData, pointMatrix?: IMatrixData): boolean;
     hitRadiusPoint(point: IRadiusPointData, pointMatrix?: IMatrixWithLayoutData): boolean;
@@ -165,11 +102,13 @@ interface ITwoPointBoundsData {
     maxX: number;
     maxY: number;
 }
-interface IAutoBoundsData {
+interface IAutoBoxData {
     top?: number;
     right?: number;
     bottom?: number;
     left?: number;
+}
+interface IAutoBoundsData extends IAutoBoxData {
     width?: number;
     height?: number;
 }
@@ -202,13 +141,15 @@ interface ILayoutData extends IScaleRotationData, ISkewData, IPointData {
 type ILayoutAttr = 'x' | 'y' | 'scaleX' | 'scaleY' | 'rotation' | 'skewX' | 'skewY';
 interface ILayoutBoundsData extends ILayoutData, IBoundsData {
 }
-interface IMatrix extends IMatrixData {
+interface IMatrix extends IMatrixWithScaleData {
     set(a: number | IMatrixData, b: number, c: number, d: number, e: number, f: number): IMatrix;
+    setWith(dataWithScale: IMatrixWithScaleData): IMatrix;
     get(): IMatrixData;
     clone(): IMatrix;
     translate(x: number, y: number): IMatrix;
     translateInner(x: number, y: number): IMatrix;
     scale(x: number, y?: number): IMatrix;
+    scaleWith(x: number, y?: number): IMatrix;
     scaleOfOuter(origin: IPointData, x: number, y?: number): IMatrix;
     scaleOfInner(origin: IPointData, x: number, y?: number): IMatrix;
     rotate(angle: number): IMatrix;
@@ -222,19 +163,145 @@ interface IMatrix extends IMatrixData {
     divide(child: IMatrixData): IMatrix;
     divideParent(parent: IMatrixData): IMatrix;
     invert(): IMatrix;
+    invertWith(): IMatrix;
     toOuterPoint(inner: IPointData, to?: IPointData, distance?: boolean): void;
     toInnerPoint(outer: IPointData, to?: IPointData, distance?: boolean): void;
-    setLayout(data: ILayoutData, origin?: IPointData): IMatrix;
-    getLayout(origin?: IPointData, firstSkewY?: boolean): ILayoutData;
+    setLayout(data: ILayoutData, origin?: IPointData, around?: IPointData): IMatrix;
+    getLayout(origin?: IPointData, around?: IPointData, firstSkewY?: boolean): ILayoutData;
+    withScale(scaleX?: number, scaleY?: number): IMatrixWithScaleData;
     reset(): void;
 }
 interface IMatrixWithBoundsData extends IMatrixData, IBoundsData {
 }
 interface IMatrixWithScaleData extends IMatrixData, IScaleData {
 }
+interface IMatrixWithOptionScaleData extends IMatrixData {
+    scaleX?: number;
+    scaleY?: number;
+}
+interface IMatrixWithBoundsScaleData extends IMatrixData, IBoundsData, IScaleData {
+}
 interface IMatrixWithLayoutData extends IMatrixData, ILayoutBoundsData {
 }
 
+interface IFunction {
+    (...arg: any): any;
+}
+interface INumberFunction {
+    (...arg: any): number;
+}
+interface IStringFunction {
+    (...arg: any): string;
+}
+interface IObjectFunction {
+    (...arg: any): IObject;
+}
+interface IPointDataFunction {
+    (...arg: any): IPointData;
+}
+interface IAttrDecorator {
+    (...arg: any): IAttrDecoratorInner;
+}
+interface IAttrDecoratorInner {
+    (target: any, key: string): any;
+}
+
+type INumber = number;
+type IBoolean = boolean;
+type IString = string;
+type IValue = INumber | IBoolean | IString | IObject;
+type ITimer = any;
+type IPathString = string;
+type IFourNumber = number | number[];
+interface IObject {
+    [name: string]: any;
+}
+interface IBooleanMap {
+    [name: string]: boolean;
+}
+interface INumberMap {
+    [name: string]: number;
+}
+interface IStringMap {
+    [name: string]: string;
+}
+interface IFunctionMap {
+    [name: string]: IFunction;
+}
+interface IPointDataMap {
+    [name: string]: IPointData;
+}
+interface IDataTypeHandle {
+    (target: any): void;
+}
+
+interface ILeafMap {
+    [name: string]: ILeaf;
+}
+interface ILeafArrayMap {
+    [name: string]: ILeaf[];
+}
+type ILeafListItemCallback = (item: ILeaf, index?: number) => void;
+interface ILeafList {
+    list: ILeaf[];
+    keys: INumberMap;
+    readonly length: number;
+    has(leaf: ILeaf): boolean;
+    indexAt(index: number): ILeaf;
+    indexOf(leaf: ILeaf): number;
+    add(leaf: ILeaf): void;
+    addAt(leaf: ILeaf, index: number): void;
+    addList(list: ILeaf[]): void;
+    remove(leaf: ILeaf): void;
+    forEach(itemCallback: ILeafListItemCallback): void;
+    sort(reverse?: boolean): void;
+    clone(): ILeafList;
+    update(): void;
+    reset(): void;
+    destroy(): void;
+}
+interface ILeafLevelList {
+    levelMap: ILeafArrayMap;
+    keys: INumberMap;
+    levels: number[];
+    readonly length: number;
+    has(leaf: ILeaf): boolean;
+    without(leaf: ILeaf): boolean;
+    sort(reverse?: boolean): void;
+    addList(list: ILeaf[]): void;
+    add(leaf: ILeaf): void;
+    forEach(itemCallback: ILeafListItemCallback): void;
+    reset(): void;
+    destroy(): void;
+}
+
+interface IControl {
+    start(): void;
+    stop(): void;
+    destroy(): void;
+}
+
+interface IWatchEventData {
+    updatedList: ILeafList;
+}
+interface IWatcherConfig {
+}
+interface IWatcher extends IControl {
+    target: ILeaf;
+    totalTimes: number;
+    disabled: boolean;
+    running: boolean;
+    changed: boolean;
+    hasVisible: boolean;
+    hasAdd: boolean;
+    hasRemove: boolean;
+    readonly childrenChanged: boolean;
+    config: IWatcherConfig;
+    updatedList: ILeafList;
+    disable(): void;
+    update(): void;
+}
+
 interface ILayoutChangedData {
     matrixList: ILeaf[];
     boundsList: ILeaf[];
@@ -346,7 +413,7 @@ interface IKeepTouchData {
 type ILeafEventerModule = ILeafEventer & ThisType<ILeaf>;
 interface ILeafEventer {
     on?(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void;
-    off?(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void;
+    off?(type?: string | string[], listener?: IEventListener, options?: IEventListenerOptions | boolean): void;
     on_?(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventListenerOptions | boolean): IEventListenerId;
     off_?(id: IEventListenerId | IEventListenerId[]): void;
     once?(type: string | string[], listener: IEventListener, capture?: boolean): void;
@@ -355,47 +422,35 @@ interface ILeafEventer {
     hasEvent?(type: string, capture?: boolean): boolean;
 }
 
-interface IFunction {
-    (...arg: any): any;
-}
-interface INumberFunction {
-    (...arg: any): number;
-}
-interface IPointDataFunction {
-    (...arg: any): IPointData;
-}
-interface IAttrDecorator {
-    (...arg: any): IAttrDecoratorInner;
-}
-interface IAttrDecoratorInner {
-    (target: any, key: string): any;
-}
-
 type IEventListener = IFunction;
 interface IEventListenerOptions {
     capture?: boolean;
     once?: boolean;
 }
+type IEventOption = IEventListenerOptions | boolean | 'once';
 interface IEventListenerItem extends IEventListenerOptions {
     listener: IEventListener;
 }
 interface IEventListenerMap {
     [name: string]: IEventListenerItem[];
 }
+interface IEventMap {
+    [name: string]: IEventListener | [IEventListener, IEventOption];
+}
 interface IEventListenerId {
     type: string | string[];
     current: ILeaf;
     listener: IEventListener;
-    options?: IEventListenerOptions | boolean;
+    options?: IEventOption;
 }
 type InnerId = number;
 interface IEventer extends ILeafEventer {
     readonly innerId: InnerId;
     __captureMap?: IEventListenerMap;
     __bubbleMap?: IEventListenerMap;
-    on(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void;
-    off(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void;
-    on_(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventListenerOptions | boolean): IEventListenerId;
+    on(type: string | string[], listener: IEventListener, options?: IEventOption): void;
+    off(type?: string | string[], listener?: IEventListener, options?: IEventOption): void;
+    on_(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventOption): IEventListenerId;
     off_(id: IEventListenerId | IEventListenerId[]): void;
     once(type: string | string[], listener: IEventListener): void;
     emit(type: string, event?: IEvent | IObject, capture?: boolean): void;
@@ -489,21 +544,23 @@ interface CanvasPathDrawingStyles {
 interface CanvasPattern {
     setTransform(transform?: DOMMatrix2DInit): void;
 }
+type ICanvasPattern = CanvasPattern;
 interface CanvasRect {
     clearRect(x: number, y: number, w: number, h: number): void;
     fillRect(x: number, y: number, w: number, h: number): void;
     strokeRect(x: number, y: number, w: number, h: number): void;
 }
 type PredefinedColorSpace = 'display-p3' | 'srgb';
-interface CanvasRenderingContext2DSettings {
+interface ICanvasRenderingContext2DSettings {
     alpha?: boolean;
     colorSpace?: PredefinedColorSpace;
     desynchronized?: boolean;
     willReadFrequently?: boolean;
 }
+type ICanvasContext2DSettings = ICanvasRenderingContext2DSettings;
 interface ICanvasContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform, CanvasUserInterface {
     readonly canvas: HTMLCanvasElement;
-    getContextAttributes(): CanvasRenderingContext2DSettings;
+    getContextAttributes(): ICanvasRenderingContext2DSettings;
 }
 interface CanvasShadowStyles {
     shadowBlur: number;
@@ -723,22 +780,24 @@ interface IPathDrawer {
     rect(x: number, y: number, width: number, height: number): void;
     roundRect(x: number, y: number, width: number, height: number, radius?: number | number[]): void;
 }
-interface IPathCreator {
+interface IPathCreator extends IPathDrawer {
     path: IPathCommandData;
+    __path: IPathCommandData;
     beginPath(): IPathCreator;
     moveTo(x: number, y: number): IPathCreator;
     lineTo(x: number, y: number): IPathCreator;
     bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): IPathCreator;
     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): IPathCreator;
     closePath(): IPathCreator;
-    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): IPathCreator;
+    arc(x: number, y: number, radius: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPathCreator;
     arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): IPathCreator;
-    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): IPathCreator;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation?: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPathCreator;
     rect(x: number, y: number, width: number, height: number): IPathCreator;
     roundRect(x: number, y: number, width: number, height: number, radius?: number | number[]): IPathCreator;
     drawEllipse(x: number, y: number, radiusX: number, radiusY: number, rotation?: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPathCreator;
     drawArc(x: number, y: number, radius: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): IPathCreator;
     drawPoints(points: number[], curve?: boolean | number, close?: boolean): IPathCreator;
+    clearPath(): IPathCreator;
 }
 
 interface ICanvasManager {
@@ -750,13 +809,121 @@ interface ICanvasManager {
     destroy(): void;
 }
 
+type IExportImageType = 'jpg' | 'png' | 'webp';
+type IExportFileType = IExportImageType | 'svg' | 'pdf' | 'json';
+
+type ILocationType = 'world' | 'page' | 'local' | 'inner';
+type IBoundsType = 'content' | 'box' | 'stroke' | 'render';
+interface ILeafLayout {
+    leaf: ILeaf;
+    proxyZoom: boolean;
+    contentBounds: IBoundsData;
+    boxBounds: IBoundsData;
+    strokeBounds: IBoundsData;
+    renderBounds: IBoundsData;
+    localContentBounds: IBoundsData;
+    localStrokeBounds: IBoundsData;
+    localRenderBounds: IBoundsData;
+    worldContentBounds: IBoundsData;
+    worldBoxBounds: IBoundsData;
+    worldStrokeBounds: IBoundsData;
+    resized: boolean;
+    waitAutoLayout: boolean;
+    matrixChanged: boolean;
+    scaleChanged: boolean;
+    rotationChanged: boolean;
+    boundsChanged: boolean;
+    boxChanged: boolean;
+    strokeChanged: boolean;
+    renderChanged: boolean;
+    localBoxChanged: boolean;
+    surfaceChanged: boolean;
+    opacityChanged: boolean;
+    hitCanvasChanged: boolean;
+    childrenSortChanged?: boolean;
+    affectScaleOrRotation: boolean;
+    affectRotation: boolean;
+    affectChildrenSort?: boolean;
+    strokeSpread: number;
+    strokeBoxSpread: number;
+    renderSpread: number;
+    renderShapeSpread: number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    createLocal(): void;
+    update(): void;
+    getTransform(relative?: ILocationType | ILeaf): IMatrixData;
+    getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData;
+    getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData;
+    getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[];
+    shrinkContent(): void;
+    spreadStroke(): void;
+    spreadRender(): void;
+    shrinkContentCancel(): void;
+    spreadStrokeCancel(): void;
+    spreadRenderCancel(): void;
+    boxChange(): void;
+    localBoxChange(): void;
+    strokeChange(): void;
+    renderChange(): void;
+    scaleChange(): void;
+    rotationChange(): void;
+    matrixChange(): void;
+    surfaceChange(): void;
+    opacityChange(): void;
+    childrenSortChange(): void;
+    destroy(): void;
+}
+
+interface IExportOptions {
+    quality?: number;
+    blob?: boolean;
+    scale?: number;
+    smooth?: boolean;
+    pixelRatio?: number;
+    slice?: boolean;
+    trim?: boolean;
+    fill?: string;
+    screenshot?: IBoundsData | boolean;
+    relative?: ILocationType | ILeaf;
+    json?: IJSONOptions;
+    contextSettings?: ICanvasContext2DSettings;
+    onCanvas?: IExportOnCanvasFunction;
+}
+interface IJSONOptions {
+    matrix?: boolean;
+}
+interface IExportResult {
+    data: ILeaferCanvas | IBlob | string | boolean;
+    width?: number;
+    height?: number;
+    renderBounds?: IBoundsData;
+    trimBounds?: IBoundsData;
+}
+interface IExportResultFunction {
+    (data: IExportResult): void;
+}
+interface IExportOnCanvasFunction {
+    (data: ILeaferCanvas): void;
+}
+
 interface ILeaferCanvasConfig extends IAutoBoundsData {
     view?: string | IObject;
+    canvas?: string | IObject;
     fill?: string;
     pixelRatio?: number;
     smooth?: boolean;
     hittable?: boolean;
     webgl?: boolean;
+    contextSettings?: ICanvasContext2DSettings;
 }
 type IHitCanvasConfig = ILeaferCanvasConfig;
 interface ICanvasStrokeOptions {
@@ -768,6 +935,10 @@ interface ICanvasStrokeOptions {
     dashOffset?: number;
     miterLimit?: number;
 }
+interface ICanvasCacheOptions extends ICanvasStrokeOptions {
+    fillStyle?: string | object;
+    strokeStyle?: string | object;
+}
 interface ICanvasAttr extends ICanvasStrokeOptions, IObject {
     smooth: boolean;
     smoothLevel: string;
@@ -822,6 +993,7 @@ interface ICanvasMethod {
     restoreBlendMode(): void;
     hitFill(point: IPointData, fillRule?: string): boolean;
     hitStroke(point: IPointData, strokeWidth?: number): boolean;
+    hitPixel(radiusPoint: IRadiusPointData, offset?: IPointData, scale?: number): boolean;
     setStroke(strokeStyle: string | object, strokeWidth: number, options?: ICanvasStrokeOptions): void;
     setStrokeOptions(options: ICanvasStrokeOptions): void;
     setWorld(matrix: IMatrixData, parentMatrix?: IMatrixData): void;
@@ -829,7 +1001,7 @@ interface ICanvasMethod {
     setWorldShadow(x: number, y: number, blur: number, color?: string): void;
     setWorldBlur(blur: number): void;
     copyWorld(canvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData, blendMode?: string): void;
-    copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: string): void;
+    copyWorldByReset(canvas: ILeaferCanvas, from?: IBoundsData, to?: IBoundsData, blendMode?: string, onlyResetTransform?: boolean): void;
     copyWorldToInner(canvas: ILeaferCanvas, fromWorld: IMatrixWithBoundsData, toInnerBounds: IBoundsData, blendMode?: string): void;
     useMask(maskCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void;
     useEraser(eraserCanvas: ILeaferCanvas, fromBounds?: IBoundsData, toBounds?: IBoundsData): void;
@@ -839,6 +1011,7 @@ interface ICanvasMethod {
     clearWorld(bounds: IBoundsData, ceilPixel?: boolean): void;
     clear(): void;
 }
+type ILeaferCanvasView = any;
 interface ILeaferCanvas extends ICanvasAttr, ICanvasMethod, IPathDrawer {
     readonly innerId: InnerId;
     name: string;
@@ -851,17 +1024,20 @@ interface ILeaferCanvas extends ICanvasAttr, ICanvasMethod, IPathDrawer {
     readonly allowBackgroundColor?: boolean;
     backgroundColor?: string;
     hittable?: boolean;
+    zIndex?: number;
+    childIndex?: number;
     bounds: IBounds;
     clientBounds: IBoundsData;
     config: ILeaferCanvasConfig;
     autoLayout: boolean;
-    view: any;
+    view: ILeaferCanvasView;
     parentView: any;
     unreal?: boolean;
     context: ICanvasContext2D;
     recycled?: boolean;
     worldTransform: IMatrixData;
     init(): void;
+    export(filename: IExportFileType | string, options?: IExportOptions | number | boolean): string | Promise<any>;
     toBlob(type?: string, quality?: number): Promise<IBlob>;
     toDataURL(type?: string, quality?: number): string | Promise<string>;
     saveAs(filename: string, quality?: number): Promise<boolean>;
@@ -870,16 +1046,16 @@ interface ILeaferCanvas extends ICanvasAttr, ICanvasMethod, IPathDrawer {
     resize(size: IScreenSizeData): void;
     updateViewSize(): void;
     updateClientBounds(): void;
-    setCursor(cursor: ICursorType | ICursorType[]): void;
+    getClientBounds(update?: boolean): IBoundsData;
     isSameSize(options: ILeaferCanvasConfig): boolean;
     getSameCanvas(useSameWorldTransform?: boolean, useSameSmooth?: boolean): ILeaferCanvas;
-    getBiggerCanvas(addWidth: number, addHeight: number): ILeaferCanvas;
-    recycle(): void;
-    updateRender(): void;
+    recycle(clearBounds?: IBoundsData): void;
+    updateRender(bounds: IBoundsData): void;
     unrealCanvas(): void;
     destroy(): void;
 }
 interface IHitCanvas extends ILeaferCanvas {
+    hitScale?: number;
 }
 interface IBlobFunction {
     (blob: IBlob | null): void;
@@ -890,7 +1066,7 @@ interface IRenderOptions {
     includes?: boolean;
     bounds?: IBounds;
     hideBounds?: IBounds;
-    matrix?: IMatrix;
+    matrix?: IMatrixWithScaleData;
     inCamera?: boolean;
 }
 interface IRendererConfig {
@@ -909,6 +1085,7 @@ interface IRenderer extends IControl {
     rendering: boolean;
     waitAgain: boolean;
     changed: boolean;
+    ignore: boolean;
     config: IRendererConfig;
     update(): void;
     requestLayout(): void;
@@ -926,7 +1103,7 @@ interface IRenderer extends IControl {
 
 type ILeafDataProxyModule = ILeafDataProxy & ThisType<ILeaf>;
 interface ILeafDataProxy {
-    __setAttr?(name: string, newValue: IValue): void;
+    __setAttr?(name: string, newValue: IValue): boolean;
     __getAttr?(name: string): IValue;
     setProxyAttr?(name: string, newValue: IValue): void;
     getProxyAttr?(name: string): IValue;
@@ -949,77 +1126,20 @@ interface ILeafBounds {
     __updateStrokeBounds?(): void;
     __updateRenderBounds?(): void;
     __updateAutoLayout?(): void;
+    __updateFlowLayout?(): void;
     __updateNaturalSize?(): void;
     __updateStrokeSpread?(): number;
     __updateRenderSpread?(): number;
     __onUpdateSize?(): void;
 }
 
-type ILocationType = 'world' | 'local' | 'inner';
-type IBoundsType = 'content' | 'box' | 'stroke' | 'margin' | 'render';
-interface ILeafLayout {
-    leaf: ILeaf;
-    proxyZoom: boolean;
-    boxBounds: IBoundsData;
-    strokeBounds: IBoundsData;
-    renderBounds: IBoundsData;
-    marginBounds: IBoundsData;
-    contentBounds: IBoundsData;
-    localStrokeBounds?: IBoundsData;
-    localRenderBounds?: IBoundsData;
-    resized: boolean;
-    waitAutoLayout: boolean;
-    matrixChanged: boolean;
-    scaleChanged: boolean;
-    rotationChanged: boolean;
-    boundsChanged: boolean;
-    boxChanged: boolean;
-    strokeChanged: boolean;
-    renderChanged: boolean;
-    localBoxChanged: boolean;
-    surfaceChanged: boolean;
-    opacityChanged: boolean;
-    hitCanvasChanged: boolean;
-    childrenSortChanged?: boolean;
-    affectScaleOrRotation: boolean;
-    affectRotation: boolean;
-    affectChildrenSort?: boolean;
-    strokeSpread: number;
-    renderSpread: number;
-    strokeBoxSpread: number;
-    renderShapeSpread: number;
-    a: number;
-    b: number;
-    c: number;
-    d: number;
-    e: number;
-    f: number;
-    update(): void;
-    getTransform(relative?: ILocationType | ILeaf): IMatrixData;
-    getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData;
-    getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData;
-    getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[];
-    spreadStroke(): void;
-    spreadRender(): void;
-    spreadStrokeCancel(): void;
-    spreadRenderCancel(): void;
-    boxChange(): void;
-    localBoxChange(): void;
-    strokeChange(): void;
-    renderChange(): void;
-    scaleChange(): void;
-    rotationChange(): void;
-    matrixChange(): void;
-    surfaceChange(): void;
-    opacityChange(): void;
-    childrenSortChange(): void;
-    destroy(): void;
-}
-
 type ILeafHitModule = ILeafHit & ThisType<ILeaf>;
 interface ILeafHit {
     __hitWorld?(point: IRadiusPointData): boolean;
-    __hit?(local: IRadiusPointData): boolean;
+    __hit?(inner: IRadiusPointData): boolean;
+    __hitFill?(inner: IRadiusPointData): boolean;
+    __hitStroke?(inner: IRadiusPointData, strokeWidth: number): boolean;
+    __hitPixel(inner: IRadiusPointData): boolean;
     __drawHitPath?(canvas: ILeaferCanvas): void;
     __updateHitCanvas?(): void;
 }
@@ -1029,31 +1149,22 @@ interface ILeafRender {
     __render?(canvas: ILeaferCanvas, options: IRenderOptions): void;
     __draw?(canvas: ILeaferCanvas, options: IRenderOptions): void;
     __drawFast?(canvas: ILeaferCanvas, options: IRenderOptions): void;
-    __renderShape?(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __clip?(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __renderShape?(canvas: ILeaferCanvas, options: IRenderOptions, ignoreFill?: boolean, ignoreStroke?: boolean): void;
     __updateWorldOpacity?(): void;
     __updateChange?(): void;
 }
 
-type ILeafMaskModule = ILeafMask & ThisType<ILeaf>;
-interface ILeafMask {
-    __updateEraser?(value?: boolean): void;
-    __updateMask?(value?: boolean): void;
-    __renderMask?(canvas: ILeaferCanvas, content: ILeaferCanvas, mask: ILeaferCanvas, recycle?: boolean): void;
-    __removeMask?(child?: ILeaf): void;
-}
-
 interface IDataProcessor {
     __leaf: ILeaf;
     __input: IObject;
     __middle: IObject;
-    __single: boolean;
-    __checkSingle(): void;
     __get(name: string): any;
     __getData(): IObject;
     __setInput(name: string, value: any): void;
     __getInput(name: string): any;
     __removeInput(name: string): void;
-    __getInputData(): IObject;
+    __getInputData(names?: string[] | IObject, options?: IJSONOptions): IObject;
     __setMiddle(name: string, value: any): void;
     __getMiddle(name: string): any;
     destroy(): void;
@@ -1063,29 +1174,48 @@ interface ILeafDataOptions {
     children?: boolean;
 }
 interface ILeafData extends IDataProcessor, ILeafComputedData {
+    __single?: boolean;
+    __checkSingle(): void;
+    __removeNaturalSize(): void;
 }
 
-interface ISelectPathResult {
-    leaf: ILeaf;
+interface IBranch extends ILeaf {
+    children: ILeaf[];
+    __renderBranch?(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    addMany(...children: ILeaf[]): void;
+    removeAll(destroy?: boolean): void;
+    clear(): void;
+}
+
+interface IPickResult {
+    target: ILeaf;
     path: ILeafList;
     throughPath?: ILeafList;
 }
-interface ISelectPathOptions {
+interface IPickOptions {
     name?: string;
+    hitRadius?: number;
     through?: boolean;
+    target?: IBranch;
+    findList?: ILeaf[];
+    bottomList?: IPickBottom[];
     exclude?: ILeafList;
     ignoreHittable?: boolean;
 }
+interface IPickBottom {
+    target: ILeaf;
+    proxy?: ILeaf;
+}
 interface ISelectorConfig {
 }
-declare enum AnswerType {
-    No = 0,
-    Yes = 1,
-    NoAndSkip = 2,
-    YesAndSkip = 3
+type IAnswer = 0 | 1 | 2 | 3;
+interface IFindCondition {
+    id?: number | string;
+    className?: string;
+    tag?: string | string[];
 }
 interface IFindMethod {
-    (leaf: ILeaf, options?: any): AnswerType;
+    (leaf: ILeaf, options?: any): IAnswer;
 }
 interface ISelectorProxy {
     list: ILeaf[];
@@ -1094,7 +1224,7 @@ interface ISelector {
     target: ILeaf;
     proxy?: ISelectorProxy;
     config: ISelectorConfig;
-    getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult;
+    getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult;
     getBy(condition: number | string | IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[];
     getByInnerId(innerId: number, branch?: ILeaf): ILeaf;
     getById(id: string, branch?: ILeaf): ILeaf;
@@ -1110,52 +1240,124 @@ interface ICachedLeaf {
     bounds: IBoundsData;
 }
 interface ILeafAttrData {
-    id: IString;
-    name: IString;
-    className: IString;
-    blendMode: IBlendMode;
-    opacity: INumber;
-    visible: IBoolean;
-    isMask: IBoolean;
-    isEraser: IBoolean;
-    locked: IBoolean;
-    zIndex: INumber;
-    x: INumber;
-    y: INumber;
-    width: INumber;
-    height: INumber;
-    scaleX: INumber;
-    scaleY: INumber;
-    rotation: INumber;
-    skewX: INumber;
-    skewY: INumber;
-    scale: INumber | IPointData;
-    around: IAround;
-    draggable: IBoolean;
-    editable: IBoolean;
-    editSize?: IEditSize;
-    hittable: IBoolean;
-    hitFill: IHitType;
-    hitStroke: IHitType;
-    hitBox: IBoolean;
-    hitChildren: IBoolean;
-    hitSelf: IBoolean;
-    hitRadius: INumber;
-    cursor: ICursorType | ICursorType[];
+    id?: IString;
+    name?: IString;
+    className?: IString;
+    blendMode?: IBlendMode;
+    opacity?: INumber;
+    visible?: IBoolean | 0;
+    selected?: IBoolean;
+    disabled?: IBoolean;
+    locked?: IBoolean;
+    zIndex?: INumber;
+    mask?: IBoolean | IMaskType;
+    eraser?: IBoolean | IEraserType;
+    x?: INumber;
+    y?: INumber;
+    width?: INumber;
+    height?: INumber;
+    scaleX?: INumber;
+    scaleY?: INumber;
+    rotation?: INumber;
+    skewX?: INumber;
+    skewY?: INumber;
+    scale?: INumber | IPointData;
+    offsetX?: INumber;
+    offsetY?: INumber;
+    scrollX?: INumber;
+    scrollY?: INumber;
+    origin?: IAlign | IUnitPointData;
+    around?: IAlign | IUnitPointData;
+    lazy?: IBoolean;
+    pixelRatio?: INumber;
+    path?: IPathCommandData | IPathString;
+    windingRule?: IWindingRule;
+    closed?: IBoolean;
+    flow?: IFlowType;
+    padding?: IFourNumber;
+    gap?: IGap | IPointGap;
+    flowAlign?: IFlowAlign | IFlowAxisAlign;
+    flowWrap?: IFlowWrap;
+    itemBox?: IFlowBoxType;
+    inFlow?: IBoolean;
+    autoWidth?: IAutoSize;
+    autoHeight?: IAutoSize;
+    lockRatio?: IBoolean;
+    autoBox?: IAutoBoxData | IConstraint;
+    widthRange?: IRangeSize;
+    heightRange?: IRangeSize;
+    draggable?: IBoolean | IAxis;
+    dragBounds?: IBoundsData | 'parent';
+    editable?: IBoolean;
+    hittable?: IBoolean;
+    hitFill?: IHitType;
+    hitStroke?: IHitType;
+    hitBox?: IBoolean;
+    hitChildren?: IBoolean;
+    hitSelf?: IBoolean;
+    hitRadius?: INumber;
+    cursor?: ICursorType | ICursorType[];
+    event?: IEventMap;
+    normalStyle?: ILeafInputData;
+    hoverStyle?: ILeafInputData;
+    pressStyle?: ILeafInputData;
+    focusStyle?: ILeafInputData;
+    selectedStyle?: ILeafInputData;
+    disabledStyle?: ILeafInputData;
+    data: IObject;
+}
+type IAxis = 'x' | 'y';
+type IAxisReverse = 'x-reverse' | 'y-reverse';
+type IFlowType = boolean | IAxis | IAxisReverse;
+type IFlowBoxType = 'box' | 'stroke';
+type IGap = INumber | 'auto' | 'fit';
+interface IPointGap {
+    x?: IGap;
+    y?: IGap;
+}
+type IAxisAlign = 'from' | 'center' | 'to';
+interface IFlowAxisAlign {
+    content?: IFlowAlign;
+    x?: IAxisAlign;
+    y?: IAxisAlign;
+}
+type IFlowWrap = boolean | 'reverse';
+type IAutoSize = IBoolean | INumber | IPercentData;
+interface IRangeSize {
+    min?: number;
+    max?: number;
+}
+interface IUnitData {
+    type: 'percent' | 'px';
+    value: number;
+}
+interface IPercentData extends IUnitData {
+    type: 'percent';
 }
+interface IConstraint {
+    x: IConstraintType;
+    y: IConstraintType;
+}
+type IConstraintType = 'from' | 'center' | 'to' | 'from-to' | 'scale';
 type IHitType = 'path' | 'pixel' | 'all' | 'none';
+type IMaskType = 'path' | 'pixel' | 'clipping';
+type IEraserType = 'path' | 'pixel';
 type IBlendMode = 'pass-through' | 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'source-over' | 'source-in' | 'source-out' | 'source-atop' | 'destination-over' | 'destination-in' | 'destination-out' | 'destination-atop' | 'xor';
-type IEditSize = 'size' | 'scale';
+type IEditSize = 'size' | 'font-size' | 'scale';
 interface IImageCursor {
     url: string;
     x?: number;
     y?: number;
+    rotation?: number;
 }
-type IAround = 'topLeft' | 'top' | 'topRight' | 'right' | 'bottomRight' | 'bottom' | 'bottomLeft' | 'left' | 'center' | IPointData;
-type ICursorType = IImageCursor | '' | 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'grab' | 'grabbing' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom -in' | 'zoom-out';
-interface ICursorTypeMap {
-    [name: string]: ICursorType | ICursorType[];
-}
+type IDirection = 'top-left' | 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'left' | 'center';
+type IDirection4 = 'top' | 'right' | 'bottom' | 'left';
+type IAlign = IDirection;
+type IBaseLineAlign = 'baseline-left' | 'baseline-center' | 'baseline-right';
+type IFlowAlign = IAlign | IBaseLineAlign;
+type IAround = IAlign | IUnitPointData;
+type ICursorType = IImageCursor | '' | 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'grab' | 'grabbing' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out';
+type IStateStyleType = 'hoverStyle' | 'pressStyle' | 'focusStyle' | 'selectedStyle' | 'disabledStyle';
 interface ILeafInputData {
     tag?: string;
     id?: IString;
@@ -1163,11 +1365,13 @@ interface ILeafInputData {
     className?: IString;
     blendMode?: IBlendMode;
     opacity?: INumber;
-    visible?: IBoolean;
-    isMask?: IBoolean;
-    isEraser?: IBoolean;
+    visible?: IBoolean | 0;
+    selected?: IBoolean;
+    disabled?: IBoolean;
     locked?: IBoolean;
     zIndex?: INumber;
+    mask?: IBoolean | IMaskType;
+    eraser?: IBoolean | IEraserType;
     x?: INumber;
     y?: INumber;
     width?: INumber;
@@ -1178,10 +1382,33 @@ interface ILeafInputData {
     skewX?: INumber;
     skewY?: INumber;
     scale?: INumber | IPointData;
-    around?: IAround;
-    draggable?: IBoolean;
+    offsetX?: INumber;
+    offsetY?: INumber;
+    scrollX?: INumber;
+    scrollY?: INumber;
+    origin?: IAlign | IUnitPointData;
+    around?: IAlign | IUnitPointData;
+    lazy?: IBoolean;
+    pixelRatio?: INumber;
+    path?: IPathCommandData | IPathString;
+    windingRule?: IWindingRule;
+    closed?: IBoolean;
+    flow?: IFlowType;
+    padding?: IFourNumber;
+    gap?: IGap | IPointGap;
+    flowAlign?: IFlowAlign | IFlowAxisAlign;
+    flowWrap?: IFlowWrap;
+    itemBox?: IFlowBoxType;
+    inFlow?: IBoolean;
+    autoWidth?: IAutoSize;
+    autoHeight?: IAutoSize;
+    lockRatio?: IBoolean;
+    autoBox?: IAutoBoxData | IConstraint;
+    widthRange?: IRangeSize;
+    heightRange?: IRangeSize;
+    draggable?: IBoolean | IAxis;
+    dragBounds?: IBoundsData | 'parent';
     editable?: IBoolean;
-    editSize?: IEditSize;
     hittable?: IBoolean;
     hitFill?: IHitType;
     hitStroke?: IHitType;
@@ -1190,6 +1417,14 @@ interface ILeafInputData {
     hitSelf?: IBoolean;
     hitRadius?: INumber;
     cursor?: ICursorType | ICursorType[];
+    event?: IEventMap;
+    normalStyle?: ILeafInputData;
+    hoverStyle?: ILeafInputData;
+    pressStyle?: ILeafInputData;
+    focusStyle?: ILeafInputData;
+    selectedStyle?: ILeafInputData;
+    disabledStyle?: ILeafInputData;
+    data?: IObject;
     children?: ILeafInputData[];
     noBounds?: boolean;
 }
@@ -1199,11 +1434,13 @@ interface ILeafComputedData {
     className?: string;
     blendMode?: IBlendMode;
     opacity?: number;
-    visible?: boolean;
-    isMask?: boolean;
-    isEraser?: boolean;
+    visible?: boolean | 0;
+    selected?: boolean;
+    disabled?: boolean;
     locked?: boolean;
     zIndex?: number;
+    mask?: boolean | IMaskType;
+    eraser?: boolean | IEraserType;
     x?: number;
     y?: number;
     width?: number;
@@ -1213,10 +1450,33 @@ interface ILeafComputedData {
     rotation?: number;
     skewX?: number;
     skewY?: number;
-    around?: IAround;
-    draggable?: boolean;
+    offsetX?: number;
+    offsetY?: number;
+    scrollX?: number;
+    scrollY?: number;
+    origin?: IAlign | IUnitPointData;
+    around?: IAlign | IUnitPointData;
+    lazy?: boolean;
+    pixelRatio?: number;
+    path?: IPathCommandData;
+    windingRule?: IWindingRule;
+    closed?: boolean;
+    flow?: IFlowType;
+    padding?: IFourNumber;
+    gap?: IGap | IPointGap;
+    flowAlign?: IFlowAlign | IFlowAxisAlign;
+    flowWrap?: IFlowWrap;
+    itemBox?: IFlowBoxType;
+    inFlow?: boolean;
+    autoWidth?: IAutoSize;
+    autoHeight?: IAutoSize;
+    lockRatio?: boolean;
+    autoBox?: IAutoBoxData | IConstraint;
+    widthRange?: IRangeSize;
+    heightRange?: IRangeSize;
+    draggable?: boolean | IAxis;
+    dragBounds?: IBoundsData | 'parent';
     editable?: boolean;
-    editSize?: IEditSize;
     hittable?: boolean;
     hitFill?: IHitType;
     hitStroke?: IHitType;
@@ -1225,12 +1485,31 @@ interface ILeafComputedData {
     hitSelf?: boolean;
     hitRadius?: number;
     cursor?: ICursorType | ICursorType[];
+    normalStyle?: ILeafInputData;
+    hoverStyle?: ILeafInputData;
+    pressStyle?: ILeafInputData;
+    focusStyle?: ILeafInputData;
+    selectedStyle?: ILeafInputData;
+    disabledStyle?: ILeafInputData;
+    data?: IObject;
     __childBranchNumber?: number;
     __complex?: boolean;
     __naturalWidth?: number;
     __naturalHeight?: number;
-}
-interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatrix, ILeafDataProxy, ILeafInputData, IEventer {
+    readonly __autoWidth?: boolean;
+    readonly __autoHeight?: boolean;
+    readonly __autoSide?: boolean;
+    readonly __autoSize?: boolean;
+    readonly __useNaturalRatio: boolean;
+    readonly __isLinePath: boolean;
+    readonly __blendMode: string;
+    __useArrow?: boolean;
+    __useEffect?: boolean;
+    __pathInputed?: number;
+    __pathForRender?: IPathCommandData;
+    __path2DForRender?: IPath2D;
+}
+interface ILeaf extends ILeafRender, ILeafHit, ILeafBounds, ILeafMatrix, ILeafDataProxy, ILeafInputData, IEventer {
     tag: string;
     readonly __tag: string;
     readonly innerName: string;
@@ -1239,22 +1518,28 @@ interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatr
     readonly app?: ILeaferBase;
     leafer?: ILeaferBase;
     parent?: ILeaf;
+    zoomLayer?: ILeaf;
     readonly isApp?: boolean;
-    isLeafer?: boolean;
-    isBranch?: boolean;
-    isBranchLeaf?: boolean;
+    readonly isLeafer?: boolean;
+    readonly isBranch?: boolean;
+    readonly isBranchLeaf?: boolean;
+    readonly isOutside?: boolean;
     __: ILeafData;
     proxyData?: ILeafInputData;
     __proxyData?: ILeafInputData;
+    syncEventer?: ILeaf;
     __layout: ILeafLayout;
-    __world: IMatrixWithLayoutData;
+    __world: IMatrixWithBoundsScaleData;
     __local?: IMatrixWithBoundsData;
+    __nowWorld?: IMatrixWithBoundsScaleData;
+    __cameraWorld?: IMatrixWithBoundsScaleData;
     readonly __localMatrix: IMatrixData;
-    readonly __localBounds: IBoundsData;
+    readonly __localBoxBounds: IBoundsData;
     __worldOpacity: number;
-    readonly worldTransform: IMatrixWithLayoutData;
-    readonly localTransform: IMatrixWithBoundsData;
+    readonly worldTransform: IMatrixWithScaleData;
+    readonly localTransform: IMatrixData;
     readonly boxBounds: IBoundsData;
+    readonly renderBounds: IBoundsData;
     readonly worldBoxBounds: IBoundsData;
     readonly worldStrokeBounds: IBoundsData;
     readonly worldRenderBounds: IBoundsData;
@@ -1266,29 +1551,46 @@ interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatr
     __hasMask?: boolean;
     __hasEraser?: boolean;
     __hitCanvas?: IHitCanvas;
+    __flowBounds?: IBoundsData;
+    __widthGrow?: number;
+    __heightGrow?: number;
+    __hasGrow?: boolean;
     readonly __onlyHitMask: boolean;
     readonly __ignoreHitWorld: boolean;
+    readonly __inLazyBounds: boolean;
+    readonly pathInputed: boolean;
     __parentWait?: IFunction[];
     __leaferWait?: IFunction[];
     destroyed: boolean;
     reset(data?: ILeafInputData): void;
     resetCustom(): void;
-    waitParent(item: IFunction): void;
-    waitLeafer(item: IFunction): void;
-    nextRender(item: IFunction): void;
+    waitParent(item: IFunction, bind?: IObject): void;
+    waitLeafer(item: IFunction, bind?: IObject): void;
+    nextRender(item: IFunction, bind?: IObject, off?: 'off'): void;
+    removeNextRender(item: IFunction): void;
     __bindLeafer(leafer: ILeaferBase | null): void;
     set(data: IObject): void;
-    get(): ILeafInputData;
-    toJSON(): IObject;
-    toString(): string;
-    __setAttr(attrName: string, newValue: IValue): void;
+    get(name?: string | string[] | IObject): ILeafInputData | IValue;
+    setAttr(name: string, value: any): void;
+    getAttr(name: string): any;
+    getComputedAttr(name: string): any;
+    toJSON(options?: IJSONOptions): IObject;
+    toString(options?: IJSONOptions): string;
+    toSVG(): string;
+    __SVG(data: IObject): void;
+    toHTML(): string;
+    __setAttr(attrName: string, newValue: IValue, checkFiniteNumber?: boolean): boolean;
     __getAttr(attrName: string): IValue;
     setProxyAttr(name: string, newValue: IValue): void;
     getProxyAttr(name: string): IValue;
     find(condition: number | string | IFindMethod, options?: any): ILeaf[];
-    findOne(condition: number | string | IFindMethod, options?: any): ILeaf;
-    forceUpdate(attrName?: string): void;
+    findTag(tag: string | string[]): ILeaf[];
+    findOne(condition: number | string | IFindMethod, options?: any): ILeaf | undefined;
+    findId(id: number | string): ILeaf | undefined;
+    focus(value?: boolean): void;
     updateLayout(): void;
+    forceUpdate(attrName?: string): void;
+    forceRender(_bounds?: IBoundsData): void;
     __updateWorldMatrix(): void;
     __updateLocalMatrix(): void;
     __updateWorldBounds(): void;
@@ -1296,21 +1598,26 @@ interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatr
     __updateLocalBoxBounds(): void;
     __updateLocalStrokeBounds(): void;
     __updateLocalRenderBounds(): void;
+    __updateContentBounds(): void;
     __updateBoxBounds(): void;
     __updateStrokeBounds(): void;
     __updateRenderBounds(): void;
     __updateAutoLayout(): void;
+    __updateFlowLayout(): void;
     __updateNaturalSize(): void;
     __updateStrokeSpread(): number;
     __updateRenderSpread(): number;
     __onUpdateSize(): void;
     __updateEraser(value?: boolean): void;
     __updateMask(value?: boolean): void;
-    __renderMask(canvas: ILeaferCanvas, content: ILeaferCanvas, mask: ILeaferCanvas, recycle?: boolean): void;
-    __removeMask(child?: ILeaf): void;
-    getWorld(attrName: ILayoutAttr): number;
+    __renderMask(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __renderEraser(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __getNowWorld(options: IRenderOptions): IMatrixWithBoundsScaleData;
+    getTransform(relative?: ILocationType | ILeaf): IMatrixData;
     getBounds(type?: IBoundsType, relative?: ILocationType | ILeaf): IBoundsData;
     getLayoutBounds(type?: IBoundsType, relative?: ILocationType | ILeaf, unscale?: boolean): ILayoutBoundsData;
+    getLayoutPoints(type?: IBoundsType, relative?: ILocationType | ILeaf): IPointData[];
+    getWorldBounds(inner: IBoundsData, relative?: ILeaf, change?: boolean): IBoundsData;
     worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
     localToWorld(local: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
     worldToInner(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
@@ -1321,22 +1628,36 @@ interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatr
     getLocalPointByInner(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     getWorldPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getPagePoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getWorldPointByPage(page: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
     setTransform(transform?: IMatrixData, resize?: boolean): void;
     transform(transform?: IMatrixData, resize?: boolean): void;
-    move(x: number, y?: number): void;
-    scaleOf(origin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void;
-    rotateOf(origin: IPointData, rotation: number): void;
-    skewOf(origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void;
+    move(x: number | IPointData, y?: number): void;
+    scaleOf(origin: IPointData | IAlign, scaleX: number, scaleY?: number, resize?: boolean): void;
+    rotateOf(origin: IPointData | IAlign, rotation: number): void;
+    skewOf(origin: IPointData | IAlign, skewX: number, skewY?: number, resize?: boolean): void;
+    transformWorld(worldTransform?: IMatrixData, resize?: boolean): void;
+    moveWorld(x: number | IPointData, y?: number): void;
+    scaleOfWorld(worldOrigin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void;
+    rotateOfWorld(worldOrigin: IPointData, rotation: number): void;
+    skewOfWorld(worldOrigin: IPointData, skewX: number, skewY?: number, resize?: boolean): void;
+    flip(axis: IAxis): void;
     scaleResize(scaleX: number, scaleY: number, noResize?: boolean): void;
     __scaleResize(scaleX: number, scaleY: number): void;
+    resizeWidth(width: number): void;
+    resizeHeight(height: number): void;
     __hitWorld(point: IRadiusPointData): boolean;
     __hit(local: IRadiusPointData): boolean;
+    __hitFill(inner: IRadiusPointData): boolean;
+    __hitStroke(inner: IRadiusPointData, strokeWidth: number): boolean;
+    __hitPixel(inner: IRadiusPointData): boolean;
     __drawHitPath(canvas: ILeaferCanvas): void;
     __updateHitCanvas(): void;
     __render(canvas: ILeaferCanvas, options: IRenderOptions): void;
     __drawFast(canvas: ILeaferCanvas, options: IRenderOptions): void;
     __draw(canvas: ILeaferCanvas, options: IRenderOptions): void;
-    __renderShape(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __clip(canvas: ILeaferCanvas, options: IRenderOptions): void;
+    __renderShape(canvas: ILeaferCanvas, options: IRenderOptions, ignoreFill?: boolean, ignoreStroke?: boolean): void;
     __updateWorldOpacity(): void;
     __updateChange(): void;
     __drawPath(canvas: ILeaferCanvas): void;
@@ -1349,9 +1670,10 @@ interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatr
     remove(child?: ILeaf, destroy?: boolean): void;
     dropTo(parent: ILeaf, index?: number, resize?: boolean): void;
 }
-
-type IExportImageType = 'jpg' | 'png' | 'webp';
-type IExportFileType = IExportImageType | 'svg' | 'pdf' | 'json';
+type ILeafAttrDescriptor = IObject & ThisType<ILeaf>;
+interface ILeafAttrDescriptorFn {
+    (key: string): ILeafAttrDescriptor;
+}
 
 interface ILeaferImageConfig {
     url: string;
@@ -1364,6 +1686,13 @@ interface ILeaferImageOnLoaded {
 interface ILeaferImageOnError {
     (error?: string | IObject, image?: ILeaferImage): any;
 }
+interface ILeaferImageCacheCanvas {
+    data: IObject;
+    params: IArguments;
+}
+interface ILeaferImagePatternPaint {
+    transform: IMatrixData;
+}
 interface ILeaferImage {
     readonly innerId: InnerId;
     readonly url: string;
@@ -1371,6 +1700,7 @@ interface ILeaferImage {
     width: number;
     height: number;
     isSVG: boolean;
+    hasOpacityPixel: boolean;
     readonly completed: boolean;
     ready: boolean;
     error: IObject;
@@ -1380,6 +1710,7 @@ interface ILeaferImage {
     load(onSuccess?: ILeaferImageOnLoaded, onError?: ILeaferImageOnError): number;
     unload(index: number, stopEvent?: boolean): void;
     getCanvas(width: number, height: number, opacity?: number, _filters?: IObject): unknown;
+    getPattern(canvas: any, repeat: string | null, transform?: IMatrixData, paint?: IObject): ICanvasPattern;
     destroy(): void;
 }
 
@@ -1397,6 +1728,7 @@ interface IUIEvent extends IEvent {
     buttons?: number;
     path?: ILeafList;
     throughPath?: ILeafList;
+    getPage?(): IPointData;
     getInner?(relative?: ILeaf): IPointData;
     getLocal?(relative?: ILeaf): IPointData;
 }
@@ -1404,11 +1736,13 @@ interface IPointerEvent extends IUIEvent {
     width?: number;
     height?: number;
     pointerType?: PointerType;
+    multiTouch?: boolean;
     pressure?: number;
     tangentialPressure?: number;
     tiltX?: number;
     tiltY?: number;
     twist?: number;
+    isCancel?: boolean;
 }
 type PointerType = 'mouse' | 'pen' | 'touch';
 interface IDragEvent extends IPointerEvent {
@@ -1416,10 +1750,13 @@ interface IDragEvent extends IPointerEvent {
     moveY: number;
     totalX?: number;
     totalY?: number;
+    getPageMove?(total?: boolean): IPointData;
     getInnerMove?(relative?: ILeaf): IPointData;
     getLocalMove?(relative?: ILeaf): IPointData;
+    getPageTotal?(): IPointData;
     getInnerTotal?(relative?: ILeaf): IPointData;
     getLocalTotal?(relative?: ILeaf): IPointData;
+    getPageBounds?(): IBoundsData;
 }
 interface IDropEvent extends IPointerEvent {
     list: ILeafList;
@@ -1432,6 +1769,7 @@ interface IZoomEvent extends IUIEvent {
     scale: number;
 }
 interface IMoveEvent extends IDragEvent {
+    moveType?: 'drag' | 'move';
 }
 interface ISwipeEvent extends IDragEvent {
 }
@@ -1452,15 +1790,23 @@ interface IInteraction extends IControl {
     selector: ISelector;
     running: boolean;
     readonly dragging: boolean;
-    readonly isDragEmpty: boolean;
+    readonly transforming: boolean;
     readonly moveMode: boolean;
+    readonly canHover: boolean;
+    readonly isDragEmpty: boolean;
+    readonly isMobileDragEmpty: boolean;
+    readonly isHoldMiddleKey: boolean;
+    readonly isHoldRightKey: boolean;
+    readonly isHoldSpaceKey: boolean;
     config: IInteractionConfig;
     cursor: ICursorType | ICursorType[];
     readonly hitRadius: number;
+    bottomList?: IPickBottom[];
     shrinkCanvasBounds: IBounds;
     downData: IPointerEvent;
     hoverData: IPointerEvent;
     downTime: number;
+    focusData: ILeaf;
     receive(event: any): void;
     pointerDown(data?: IPointerEvent, defaultPath?: boolean): void;
     pointerMove(data?: IPointerEvent): void;
@@ -1473,11 +1819,20 @@ interface IInteraction extends IControl {
     rotate(data: IRotateEvent): void;
     keyDown(data: IKeyEvent): void;
     keyUp(data: IKeyEvent): void;
-    findPath(data: IPointerEvent, options?: ISelectPathOptions): ILeafList;
+    findPath(data: IPointerEvent, options?: IPickOptions): ILeafList;
+    isRootPath(data: IPointerEvent): boolean;
+    isTreePath(data: IPointerEvent): boolean;
+    canMove(data: IPointerEvent): boolean;
     isDrag(leaf: ILeaf): boolean;
-    updateDownData(data?: IPointerEvent): void;
+    isPress(leaf: ILeaf): boolean;
+    isHover(leaf: ILeaf): boolean;
+    isFocus(leaf: ILeaf): boolean;
+    cancelHover(): void;
+    updateDownData(data?: IPointerEvent, options?: IPickOptions, merge?: boolean): void;
     updateHoverData(data: IPointerEvent): void;
     updateCursor(hoverData?: IPointerEvent): void;
+    setCursor(cursor: ICursorType | ICursorType[]): void;
+    getLocal(clientPoint: IClientPointData, updateClient?: boolean): IPointData;
     emit(type: string, data: IUIEvent, path?: ILeafList, excludePath?: ILeafList): void;
 }
 interface IInteractionCanvas extends ILeaferCanvas {
@@ -1485,23 +1840,31 @@ interface IInteractionCanvas extends ILeaferCanvas {
 interface IInteractionConfig {
     wheel?: IWheelConfig;
     pointer?: IPointerConfig;
-    cursor?: ICursorConfig;
     zoom?: IZoomConfig;
     move?: IMoveConfig;
     eventer?: IObject;
+    cursor?: boolean;
+    keyEvent?: boolean;
 }
 interface IZoomConfig {
+    disabled?: boolean;
     min?: number;
     max?: number;
 }
 interface IMoveConfig {
+    disabled?: boolean;
     holdSpaceKey?: boolean;
+    holdMiddleKey?: boolean;
+    holdRightKey?: boolean;
+    scroll?: boolean | 'limit';
     drag?: boolean;
+    dragAnimate?: boolean;
     dragEmpty?: boolean;
     dragOut?: boolean;
     autoDistance?: number;
 }
 interface IWheelConfig {
+    disabled?: boolean;
     zoomMode?: boolean | 'mouse';
     zoomSpeed?: number;
     moveSpeed?: number;
@@ -1518,38 +1881,32 @@ interface IPointerConfig {
     tapTime?: number;
     longPressTime?: number;
     transformTime?: number;
+    hover?: boolean;
+    touch?: boolean;
     dragHover?: boolean;
     dragDistance?: number;
     swipeDistance?: number;
     ignoreMove?: boolean;
     preventDefault?: boolean;
-}
-interface ICursorConfig {
-    stop?: boolean;
+    preventDefaultMenu?: boolean;
 }
 
 interface IHitCanvasManager extends ICanvasManager {
+    maxTotal: number;
     getPathType(leaf: ILeaf): IHitCanvas;
-    getImageType(leaf: ILeaf, size: IScreenSizeData): IHitCanvas;
-}
-
-interface IBranch extends ILeaf {
-    children: ILeaf[];
-    __renderBranch?(canvas: ILeaferCanvas, options: IRenderOptions): void;
-    addMany(...children: ILeaf[]): void;
-    removeAll(destroy?: boolean): void;
+    getPixelType(leaf: ILeaf, config?: ILeaferCanvasConfig): IHitCanvas;
 }
 
 interface IZoomView extends IBranch {
-    zoomLayer?: ILeaf;
-    setZoomLayer(zoomLayer: ILeaf): void;
 }
 
-type ILeaferType = 'draw' | 'design' | 'board' | 'document' | 'user';
+type ILeaferType = 'draw' | 'editor' | 'design' | 'board' | 'document' | 'app' | 'website' | 'game' | 'player' | 'chart' | 'custom';
 interface ILeaferConfig extends IRendererConfig, ILeaferCanvasConfig, IInteractionConfig, ILayouterConfig {
     start?: boolean;
     type?: ILeaferType;
+    mobile?: boolean;
     realCanvas?: boolean;
+    lazySpeard?: IFourNumber;
 }
 interface ILeaferAttrData {
     running: boolean;
@@ -1559,7 +1916,7 @@ interface ILeaferAttrData {
     imageReady: boolean;
     viewCompleted: boolean;
     layoutLocked: boolean;
-    pixelRatio: number;
+    transforming: boolean;
     view: unknown;
     canvas: ILeaferCanvas;
     renderer: IRenderer;
@@ -1570,8 +1927,10 @@ interface ILeaferAttrData {
     canvasManager: ICanvasManager;
     hitCanvasManager?: IHitCanvasManager;
     autoLayout?: IAutoBounds;
+    lazyBounds: IBounds;
     config: ILeaferConfig;
     readonly cursorPoint: IPointData;
+    readonly clientBounds: IBoundsData;
     leafs: number;
     __eventIds: IEventListenerId[];
     __nextRenderWait: IFunction[];
@@ -1580,14 +1939,17 @@ interface ILeaferAttrData {
     stop(): void;
     unlockLayout(): void;
     lockLayout(): void;
-    setZoomLayer(zoomLayer: ILeaf): void;
-    forceFullRender(): void;
-    updateCursor(): void;
+    updateCursor(cursor?: ICursorType): void;
     resize(size: IScreenSizeData): void;
-    waitReady(item: IFunction): void;
-    waitViewReady(item: IFunction): void;
-    waitViewCompleted(item: IFunction): void;
-}
+    waitReady(item: IFunction, bind?: IObject): void;
+    waitViewReady(item: IFunction, bind?: IObject): void;
+    waitViewCompleted(item: IFunction, bind?: IObject): void;
+    zoom(zoomType: IZoomType, padding?: IFourNumber, fixedScale?: boolean): IBoundsData;
+    getValidMove(moveX: number, moveY: number): IPointData;
+    getValidScale(changeScale: number): number;
+    getWorldPointByClient(clientPoint: IClientPointData, updateClient?: boolean): IPointData;
+}
+type IZoomType = 'in' | 'out' | 'fit' | 'fit-width' | 'fit-height' | number | ILeaf | ILeaf[] | IBoundsData;
 interface ILeaferBase extends IZoomView, IControl, ILeaferAttrData {
     readonly isApp: boolean;
     readonly app: ILeaferBase;
@@ -1608,6 +1970,7 @@ interface ICreator {
     image?(options?: ILeaferImageConfig): ILeaferImage;
     canvas?(options?: ILeaferCanvasConfig, manager?: ICanvasManager): ILeaferCanvas;
     hitCanvas?(options?: IHitCanvasConfig, manager?: ICanvasManager): IHitCanvas;
+    hitCanvasManager?(): IHitCanvasManager;
     watcher?(target: ILeaf, options?: IWatcherConfig): IWatcher;
     layouter?(target: ILeaf, options?: ILayouterConfig): ILayouter;
     renderer?(target: ILeaf, canvas: ILeaferCanvas, options?: IRendererConfig): IRenderer;
@@ -1678,11 +2041,12 @@ interface IImageManager {
     recycledList: ILeaferImage[];
     tasker: ITaskProcessor;
     patternTasker: ITaskProcessor;
+    patternLocked?: boolean;
     readonly isComplete: boolean;
     get(config: ILeaferImageConfig): ILeaferImage;
     recycle(image: ILeaferImage): void;
     clearRecycled(): void;
-    isPixel(config: ILeaferImageConfig): boolean;
+    hasOpacityPixel(config: ILeaferImageConfig): boolean;
     isFormat(format: IExportFileType, config: ILeaferImageConfig): boolean;
     destroy(): void;
 }
@@ -1719,12 +2083,13 @@ interface ISkiaNAPICanvas {
 interface IPlatform {
     name?: 'web' | 'node' | 'miniapp';
     os?: 'Mac' | 'Windows' | 'Linux';
+    toURL(text: string, fileType?: 'text' | 'svg'): string;
     requestRender?(render: IFunction): void;
     canvas?: ILeaferCanvas;
     canvasType?: ICanvasType;
     isWorker?: boolean;
     isMobile?: boolean;
-    devicePixelRatio?: number;
+    readonly devicePixelRatio?: number;
     intWheelDeltaY?: boolean;
     conicGradientSupport?: boolean;
     conicGradientRotate90?: boolean;
@@ -1736,6 +2101,7 @@ interface IPlatform {
         canvasToDataURL(canvas: any, type?: IExportImageType, quality?: number): string | Promise<string>;
         canvasToBolb(canvas: any, type?: IExportFileType, quality?: number): Promise<any>;
         canvasSaveAs(canvas: any, filename: string, quality?: number): Promise<void>;
+        download(url: string, filename: string): Promise<void>;
         loadImage(url: string): Promise<any>;
         noRepeat?: string;
     };
@@ -1748,9 +2114,13 @@ interface IPlatform {
     };
     miniapp?: IMiniapp;
     image: {
+        hitCanvasSize: number;
         maxCacheSize: number;
         maxPatternSize: number;
-        suffix: string;
+        prefix?: string;
+        suffix?: string;
+        crossOrigin: string | false;
+        getRealURL: IStringFunction;
     };
 }
 interface IMiniappSelect extends IObject {
@@ -1775,4 +2145,15 @@ interface IPlugin extends IObject {
     onLeafer?(leafer: ILeaferBase): void;
 }
 
-export { type ACommandData, AnswerType, type ArcCommandData, type ArcToCommandData, type CCommandData, type CanvasPathCommand, type EllipseCommandData, type HCommandData, type IAnimateEvent, type IAppBase, type IAround, type IAttrDecorator, type IAutoBounds, type IAutoBoundsData, type IBlendMode, type IBlob, type IBlobFunction, type IBoolean, type IBooleanMap, type IBounds, type IBoundsData, type IBoundsDataFn, type IBoundsType, type IBranch, type IBranchRender, type IBranchRenderModule, type ICachedLeaf, type ICanvasAttr, type ICanvasContext2D, type ICanvasManager, type ICanvasStrokeOptions, type ICanvasType, type IChildEvent, type IControl, type ICreator, type ICursorType, type ICursorTypeMap, type IDataProcessor, type IDataTypeHandle, type IDragEvent, type IDropEvent, type IEditSize, type IEvent, type IEventListener, type IEventListenerId, type IEventListenerItem, type IEventListenerMap, type IEventListenerOptions, type IEventTarget, type IEventer, type IExportFileType, type IExportImageType, type IFindMethod, type IFunction, type IHitCanvas, type IHitCanvasConfig, type IHitCanvasManager, type IHitType, type IImageEvent, type IImageManager, type IInteraction, type IInteractionCanvas, type IInteractionConfig, type IKeepTouchData, type IKeyEvent, type ILayoutAttr, type ILayoutBlockData, type ILayoutBoundsData, type ILayoutChangedData, type ILayoutData, type ILayoutEvent, type ILayouter, type ILayouterConfig, type ILeaf, type ILeafArrayMap, type ILeafAttrData, type ILeafBounds, type ILeafBoundsModule, type ILeafComputedData, type ILeafData, type ILeafDataOptions, type ILeafDataProxy, type ILeafDataProxyModule, type ILeafEventer, type ILeafEventerModule, type ILeafHit, type ILeafHitModule, type ILeafInputData, type ILeafLayout, type ILeafLevelList, type ILeafList, type ILeafListItemCallback, type ILeafMap, type ILeafMask, type ILeafMaskModule, type ILeafMatrix, type ILeafMatrixModule, type ILeafRender, type ILeafRenderModule, type ILeaferAttrData, type ILeaferBase, type ILeaferCanvas, type ILeaferCanvasConfig, type ILeaferConfig, type ILeaferEvent, type ILeaferImage, type ILeaferImageConfig, type ILeaferImageOnError, type ILeaferImageOnLoaded, type ILeaferType, type ILeaferTypeCreator, type ILeaferTypeFunction, type ILeaferTypeList, type ILocationType, type IMatrix, type IMatrixData, type IMatrixWithBoundsData, type IMatrixWithLayoutData, type IMatrixWithScaleData, type IMiniapp, type IMiniappSelect, type IMiniappSizeView, type IMoveEvent, type IMultiTouchData, type INumber, type INumberMap, type IObject, type IOffsetBoundsData, type IPartLayoutConfig, type IPath2D, type IPathCommandData, type IPathCreator, type IPathDrawer, type IPathString, type IPlatform, type IPlugin, type IPoint, type IPointData, type IPointerConfig, type IPointerEvent, type IPropertyEvent, type IRadiusPointData, type IRenderEvent, type IRenderOptions, type IRenderer, type IRendererConfig, type IResizeEvent, type IResizeEventListener, type IRotateEvent, type IScaleData, type IScaleRotationData, type IScreenSizeData, type ISelectPathOptions, type ISelectPathResult, type ISelector, type ISelectorConfig, type ISelectorProxy, type ISize, type ISizeData, type ISkewData, type ISkiaCanvas, type ISkiaCanvasExportConfig, type ISkiaNAPICanvas, type IString, type IStringMap, type ISwipeEvent, type ITaskItem, type ITaskOptions, type ITaskProcessor, type ITaskProcessorConfig, type ITextMetrics, type ITimer, type ITwoPointBoundsData, type IUICreator, type IUIEvent, type IUpdateEvent, type IValue, type IWatchEvent, type IWatchEventData, type IWatcher, type IWatcherConfig, type IWheelConfig, type IWindingRule, type IZoomEvent, type IZoomView, type InnerId, type LCommandData, type MCommandData, type PointerType, type QCommandData, type RectCommandData, type RoundRectCommandData, type SCommandData, type TCommandData, type VCommandData, type ZCommandData };
+interface ICursorTypeMap {
+    [name: string]: ICursorType | ICursorType[];
+}
+interface ICursorRotate {
+    rotation?: number;
+    data?: string;
+}
+interface ICursorRotateMap {
+    [name: string]: ICursorRotate;
+}
+
+export type { ACommandData, ArcCommandData, ArcToCommandData, CCommandData, CanvasPathCommand, EllipseCommandData, HCommandData, IAlign, IAnimateEvent, IAnswer, IAppBase, IAround, IAttrDecorator, IAutoBounds, IAutoBoundsData, IAutoBoxData, IAutoSize, IAxis, IAxisAlign, IAxisReverse, IBaseLineAlign, IBlendMode, IBlob, IBlobFunction, IBoolean, IBooleanMap, IBounds, IBoundsData, IBoundsDataFn, IBoundsType, IBranch, IBranchRender, IBranchRenderModule, ICachedLeaf, ICanvasAttr, ICanvasCacheOptions, ICanvasContext2D, ICanvasContext2DSettings, ICanvasManager, ICanvasPattern, ICanvasStrokeOptions, ICanvasType, IChildEvent, IClientPointData, IConstraint, IConstraintType, IControl, ICreator, ICursorRotate, ICursorRotateMap, ICursorType, ICursorTypeMap, IDataProcessor, IDataTypeHandle, IDirection, IDirection4, IDragEvent, IDropEvent, IEditSize, IEraserType, IEvent, IEventListener, IEventListenerId, IEventListenerItem, IEventListenerMap, IEventListenerOptions, IEventMap, IEventOption, IEventTarget, IEventer, IExportFileType, IExportImageType, IExportOnCanvasFunction, IExportOptions, IExportResult, IExportResultFunction, IFindCondition, IFindMethod, IFlowAlign, IFlowAxisAlign, IFlowBoxType, IFlowType, IFlowWrap, IFourNumber, IFromToData, IFunction, IFunctionMap, IGap, IHitCanvas, IHitCanvasConfig, IHitCanvasManager, IHitType, IImageCursor, IImageEvent, IImageManager, IInteraction, IInteractionCanvas, IInteractionConfig, IJSONOptions, IKeepTouchData, IKeyEvent, ILayoutAttr, ILayoutBlockData, ILayoutBoundsData, ILayoutChangedData, ILayoutData, ILayoutEvent, ILayouter, ILayouterConfig, ILeaf, ILeafArrayMap, ILeafAttrData, ILeafAttrDescriptor, ILeafAttrDescriptorFn, ILeafBounds, ILeafBoundsModule, ILeafComputedData, ILeafData, ILeafDataOptions, ILeafDataProxy, ILeafDataProxyModule, ILeafEventer, ILeafEventerModule, ILeafHit, ILeafHitModule, ILeafInputData, ILeafLayout, ILeafLevelList, ILeafList, ILeafListItemCallback, ILeafMap, ILeafMatrix, ILeafMatrixModule, ILeafRender, ILeafRenderModule, ILeaferAttrData, ILeaferBase, ILeaferCanvas, ILeaferCanvasConfig, ILeaferCanvasView, ILeaferConfig, ILeaferEvent, ILeaferImage, ILeaferImageCacheCanvas, ILeaferImageConfig, ILeaferImageOnError, ILeaferImageOnLoaded, ILeaferImagePatternPaint, ILeaferType, ILeaferTypeCreator, ILeaferTypeFunction, ILeaferTypeList, ILocationType, IMaskType, IMatrix, IMatrixData, IMatrixWithBoundsData, IMatrixWithBoundsScaleData, IMatrixWithLayoutData, IMatrixWithOptionScaleData, IMatrixWithScaleData, IMiniapp, IMiniappSelect, IMiniappSizeView, IMoveEvent, IMultiTouchData, INumber, INumberFunction, INumberMap, IObject, IObjectFunction, IOffsetBoundsData, IPartLayoutConfig, IPath2D, IPathCommandData, IPathCreator, IPathDrawer, IPathString, IPercentData, IPickBottom, IPickOptions, IPickResult, IPlatform, IPlugin, IPoint, IPointData, IPointDataFunction, IPointDataMap, IPointGap, IPointerConfig, IPointerEvent, IPropertyEvent, IRadiusPointData, IRangeSize, IRenderEvent, IRenderOptions, IRenderer, IRendererConfig, IResizeEvent, IResizeEventListener, IRotateEvent, IScaleData, IScaleRotationData, IScreenSizeData, IScrollPointData, ISelector, ISelectorConfig, ISelectorProxy, ISize, ISizeData, ISkewData, ISkiaCanvas, ISkiaCanvasExportConfig, ISkiaNAPICanvas, IStateStyleType, IString, IStringFunction, IStringMap, ISwipeEvent, ITaskItem, ITaskOptions, ITaskProcessor, ITaskProcessorConfig, ITextMetrics, ITimer, ITwoPointBoundsData, IUICreator, IUIEvent, IUnitData, IUnitPointData, IUpdateEvent, IValue, IWatchEvent, IWatchEventData, IWatcher, IWatcherConfig, IWheelConfig, IWindingRule, IZoomEvent, IZoomType, IZoomView, InnerId, LCommandData, MCommandData, PointerType, QCommandData, RectCommandData, RoundRectCommandData, SCommandData, TCommandData, VCommandData, ZCommandData };