@leafer/interface 1.0.0-rc.3 → 1.0.0-rc.30

package/types/index.d.ts

@@ -1,110 +1,44 @@
-import { IFunction as IFunction$1, IObject as IObject$1, IEvent as IEvent$1, ILeaferCanvas as ILeaferCanvas$1, IScreenSizeData as IScreenSizeData$1 } from '@leafer/interface';
+import { ILeaferCanvas as ILeaferCanvas$1, IScreenSizeData as IScreenSizeData$1 } from '@leafer/interface';
 
-type __Number = number;
-type __Boolean = boolean;
-type __String = string;
-type __Object = IObject;
-type __Value = __Number | __Boolean | __String | __Object;
-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;
-    unshift(leaf: ILeaf): void;
-    pushList(list: ILeaf[]): void;
-    push(leaf: ILeaf): void;
-    sort(reverse?: boolean): void;
-    remove(leaf: ILeaf): void;
-    forEach(itemCallback: ILeafListItemCallback): void;
-    clone(): ILeafList;
-    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;
-    pushList(list: ILeaf[]): void;
-    push(leaf: ILeaf): void;
-    forEach(itemCallback: ILeafListItemCallback): void;
-    reset(): void;
-    destroy(): void;
-}
-
-interface IControl {
-    start(): void;
-    stop(): void;
-    destroy(): void;
+interface IPointData {
+    x: number;
+    y: number;
 }
-
-interface IWatchEventData {
-    updatedList: ILeafList;
+interface IUnitPointData {
+    type?: 'percent' | 'px';
+    x: number;
+    y: number;
 }
-interface IWatcherConfig {
+interface IFromToData {
+    from: IPointData;
+    to: IPointData;
 }
-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 IScrollPointData {
+    scrollX: number;
+    scrollY: number;
 }
-
-interface IPointData {
-    x: number;
-    y: number;
+interface IClientPointData {
+    clientX: number;
+    clientY: number;
 }
 interface IPoint extends IPointData {
-    set(x?: number, y?: number): void;
-    copy(point: IPointData): IPoint;
+    set(x?: number | IPointData, y?: number): IPoint;
+    get(): IPointData;
     clone(): IPoint;
-    rotate(angle: number, center?: IPointData): 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;
     toInnerOf(matrix: IMatrixData, to?: IPointData): IPoint;
     toOuterOf(matrix: IMatrixData, to?: IPointData): IPoint;
-    getCenter(to: IPointData): IPointData;
+    getCenter(to: IPointData): IPoint;
     getDistance(to: IPointData): number;
+    getDistancePoint(to: IPointData, distance: number, changeTo?: boolean): IPoint;
     getAngle(to: IPointData): number;
     getAtan2(to: IPointData): number;
-    reset(): void;
+    reset(): IPoint;
 }
 interface IRadiusPointData extends IPointData {
     radiusX: number;
@@ -125,25 +59,33 @@ interface IOffsetBoundsData extends IBoundsData {
     offsetX: number;
     offsetY: number;
 }
-interface IBoundsDataHandle {
+interface IBoundsDataFn {
     (target: any): IBoundsData;
 }
-interface IBounds extends IBoundsData {
-    set(x?: number, y?: number, width?: number, height?: number): void;
-    copy(bounds: IBoundsData): IBounds;
+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(size: 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: IBounds[]): IBounds;
-    setByList(boundsList: IBounds[], addMode?: boolean): IBounds;
-    addListWithHandle(list: IObject[], boundsDataHandle: IBoundsDataHandle): IBounds;
-    setByListWithHandle(list: IObject[], boundsDataHandle: IBoundsDataHandle, addMode: boolean): IBounds;
-    setByPoints(points: IPointData[]): 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;
     hit(bounds: IBoundsData, boundsMatrix?: IMatrixData): boolean;
@@ -160,16 +102,13 @@ interface ITwoPointBoundsData {
     maxX: number;
     maxY: number;
 }
-interface ITwoPointBounds extends ITwoPointBoundsData {
-    addPoint(x: number, y: number): void;
-    addBounds(x: number, y: number, width: number, height: number): void;
-    add(pointBounds: ITwoPointBoundsData): void;
-}
-interface IAutoBoundsData {
+interface IAutoBoxData {
     top?: number;
     right?: number;
     bottom?: number;
     left?: number;
+}
+interface IAutoBoundsData extends IAutoBoxData {
     width?: number;
     height?: number;
 }
@@ -186,23 +125,31 @@ interface IMatrixData {
     e: number;
     f: number;
 }
-interface IMatrixDecompositionData {
-    x: number;
-    y: number;
+interface IScaleData {
     scaleX: number;
     scaleY: number;
+}
+interface IScaleRotationData extends IScaleData {
     rotation: number;
+}
+interface ISkewData {
     skewX: number;
     skewY: number;
 }
-type IMatrixDecompositionAttr = 'x' | 'y' | 'scaleX' | 'scaleY' | 'rotation' | 'skewX' | 'skewY';
-interface IMatrix extends IMatrixData {
-    set(a: number, b: number, c: number, d: number, e: number, f: number): void;
-    copy(matrix: IMatrixData): IMatrix;
+interface ILayoutData extends IScaleRotationData, ISkewData, IPointData {
+}
+type ILayoutAttr = 'x' | 'y' | 'scaleX' | 'scaleY' | 'rotation' | 'skewX' | 'skewY';
+interface ILayoutBoundsData extends ILayoutData, IBoundsData {
+}
+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;
@@ -211,18 +158,123 @@ interface IMatrix extends IMatrixData {
     skew(x: number, y?: number): IMatrix;
     skewOfOuter(origin: IPointData, x: number, y?: number): IMatrix;
     skewOfInner(origin: IPointData, x: number, y?: number): IMatrix;
-    multiply(matrix: IMatrixData): IMatrix;
-    divide(matrix: IMatrixData): IMatrix;
-    preMultiply(matrix: IMatrixData): IMatrix;
+    multiply(child: IMatrixData): IMatrix;
+    multiplyParent(parent: IMatrixData): IMatrix;
+    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;
-    decompose(): IMatrixDecompositionData;
+    setLayout(data: ILayoutData, origin?: IPointData): IMatrix;
+    getLayout(origin?: IPointData, firstSkewY?: boolean): ILayoutData;
+    withScale(scaleX?: number, scaleY?: number): IMatrixWithScaleData;
     reset(): void;
 }
 interface IMatrixWithBoundsData extends IMatrixData, IBoundsData {
 }
-interface IMatrixWithLayoutData extends IMatrixData, IMatrixDecompositionData, 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 {
+}
+
+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 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 {
@@ -250,6 +302,7 @@ interface ILayouterConfig {
 interface ILayouter extends IControl {
     target: ILeaf;
     layoutedBlocks: ILayoutBlockData[];
+    extraBlock: ILayoutBlockData;
     totalTimes: number;
     times: number;
     disabled: boolean;
@@ -263,12 +316,14 @@ interface ILayouter extends IControl {
     layoutOnce(): void;
     partLayout(): void;
     fullLayout(): void;
+    addExtra(leaf: ILeaf): void;
     createBlock(data: ILeafList | ILeaf[]): ILayoutBlockData;
     getBlocks(list: ILeafList): ILayoutBlockData[];
     addBlocks(current: ILayoutBlockData[]): void;
 }
 
 interface IEvent {
+    origin?: IObject;
     type?: string;
     target?: IEventTarget;
     current?: IEventTarget;
@@ -319,25 +374,6 @@ interface ILayoutEvent extends IEvent {
 interface IWatchEvent extends IEvent {
     readonly data: IWatchEventData;
 }
-interface ITransformEventData {
-    x: number;
-    y: number;
-    scaleX: number;
-    scaleY: number;
-    rotation: number;
-    readonly zooming: boolean;
-    readonly moving: boolean;
-    readonly rotating: boolean;
-    readonly changing: boolean;
-}
-interface ITransformEvent extends IEvent, ITransformEventData {
-    readonly x: number;
-    readonly y: number;
-    readonly scaleX: number;
-    readonly scaleY: number;
-    readonly rotation: number;
-}
-type TransformMode = 'move' | 'zoom' | 'rotate';
 interface IMultiTouchData {
     move: IPointData;
     scale: number;
@@ -352,7 +388,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;
@@ -361,7 +397,29 @@ interface ILeafEventer {
     hasEvent?(type: string, capture?: boolean): boolean;
 }
 
-type IEventListener = IFunction$1;
+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 IEventListener = IFunction;
 interface IEventListenerOptions {
     capture?: boolean;
     once?: boolean;
@@ -374,6 +432,7 @@ interface IEventListenerMap {
 }
 interface IEventListenerId {
     type: string | string[];
+    current: ILeaf;
     listener: IEventListener;
     options?: IEventListenerOptions | boolean;
 }
@@ -383,12 +442,12 @@ interface IEventer extends ILeafEventer {
     __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$1, options?: IEventListenerOptions | boolean): IEventListenerId;
+    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): void;
-    emit(type: string, event?: IEvent$1 | IObject$1, capture?: boolean): void;
-    emitEvent(event?: IEvent$1, capture?: boolean): void;
+    emit(type: string, event?: IEvent | IObject, capture?: boolean): void;
+    emitEvent(event?: IEvent, capture?: boolean): void;
     hasEvent(type: string, capture?: boolean): boolean;
     destroy(): void;
 }
@@ -478,21 +537,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;
@@ -712,22 +773,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 {
@@ -739,6 +802,112 @@ 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;
     fill?: string;
@@ -746,6 +915,7 @@ interface ILeaferCanvasConfig extends IAutoBoundsData {
     smooth?: boolean;
     hittable?: boolean;
     webgl?: boolean;
+    contextSettings?: ICanvasContext2DSettings;
 }
 type IHitCanvasConfig = ILeaferCanvasConfig;
 interface ICanvasStrokeOptions {
@@ -757,6 +927,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;
@@ -811,6 +985,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;
@@ -818,7 +993,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;
@@ -828,6 +1003,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;
@@ -840,17 +1016,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>;
@@ -859,36 +1038,27 @@ 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): ILeaferCanvas;
-    getBiggerCanvas(addWidth: number, addHeight: number): ILeaferCanvas;
-    recycle(): void;
+    getSameCanvas(useSameWorldTransform?: boolean, useSameSmooth?: boolean): ILeaferCanvas;
+    recycle(clearBounds?: IBoundsData): void;
     updateRender(): void;
     unrealCanvas(): void;
     destroy(): void;
 }
 interface IHitCanvas extends ILeaferCanvas {
+    hitScale?: number;
 }
 interface IBlobFunction {
     (blob: IBlob | null): void;
 }
 type IBlob = any;
 
-interface IFunction {
-    (...arg: any): any;
-}
-interface INumberFunction {
-    (...arg: any): number;
-}
-interface IPointDataFunction {
-    (...arg: any): IPointData;
-}
-
 interface IRenderOptions {
+    includes?: boolean;
     bounds?: IBounds;
     hideBounds?: IBounds;
-    matrix?: IMatrix;
+    matrix?: IMatrixWithScaleData;
     inCamera?: boolean;
 }
 interface IRendererConfig {
@@ -907,6 +1077,7 @@ interface IRenderer extends IControl {
     rendering: boolean;
     waitAgain: boolean;
     changed: boolean;
+    ignore: boolean;
     config: IRendererConfig;
     update(): void;
     requestLayout(): void;
@@ -924,8 +1095,10 @@ interface IRenderer extends IControl {
 
 type ILeafDataProxyModule = ILeafDataProxy & ThisType<ILeaf>;
 interface ILeafDataProxy {
-    __setAttr?(name: string, newValue: __Value): void;
-    __getAttr?(name: string): __Value;
+    __setAttr?(name: string, newValue: IValue): boolean;
+    __getAttr?(name: string): IValue;
+    setProxyAttr?(name: string, newValue: IValue): void;
+    getProxyAttr?(name: string): IValue;
 }
 
 type ILeafMatrixModule = ILeafMatrix & ThisType<ILeaf>;
@@ -937,75 +1110,28 @@ interface ILeafMatrix {
 type ILeafBoundsModule = ILeafBounds & ThisType<ILeaf>;
 interface ILeafBounds {
     __updateWorldBounds?(): void;
+    __updateLocalBounds?(): void;
     __updateLocalBoxBounds?(): void;
     __updateLocalStrokeBounds?(): void;
     __updateLocalRenderBounds?(): void;
     __updateBoxBounds?(): void;
     __updateStrokeBounds?(): void;
     __updateRenderBounds?(): void;
+    __updateAutoLayout?(): void;
+    __updateFlowLayout?(): void;
     __updateNaturalSize?(): void;
     __updateStrokeSpread?(): number;
     __updateRenderSpread?(): number;
     __onUpdateSize?(): void;
 }
 
-type ILayoutLocationType = 'world' | 'local' | 'inner';
-type ILayoutBoundsType = 'content' | 'box' | 'stroke' | 'margin' | 'render';
-interface ILeafLayout {
-    leaf: ILeaf;
-    useZoomProxy: boolean;
-    boxBounds: IBoundsData;
-    strokeBounds: IBoundsData;
-    renderBounds: IBoundsData;
-    marginBounds: IBoundsData;
-    contentBounds: IBoundsData;
-    localStrokeBounds: IBoundsData;
-    localRenderBounds: IBoundsData;
-    matrixChanged: boolean;
-    positionChanged: boolean;
-    originChanged?: 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;
-    checkUpdate(force?: boolean): void;
-    getTransform(locationType: ILayoutLocationType): IMatrixData;
-    getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType): IBoundsData;
-    spreadStroke(): void;
-    spreadRender(): void;
-    spreadStrokeCancel(): void;
-    spreadRenderCancel(): void;
-    boxChange(): void;
-    localBoxChange(): void;
-    strokeChange(): void;
-    renderChange(): void;
-    positionChange(): void;
-    scaleChange(): void;
-    rotationChange(): 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;
 }
@@ -1015,35 +1141,89 @@ 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): void;
-    __removeMask?(child?: ILeaf): void;
-}
-
-interface IDataProcessor extends IObject {
+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;
 }
+interface ILeafDataOptions {
+    attrs?: 'all' | string[];
+    children?: boolean;
+}
 interface ILeafData extends IDataProcessor, ILeafComputedData {
+    __single?: boolean;
+    __checkSingle(): void;
+    __removeNaturalSize(): void;
+}
+
+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 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 {
+}
+type IAnswer = 0 | 1 | 2 | 3;
+interface IFindCondition {
+    id?: number | string;
+    className?: string;
+    tag?: string | string[];
+}
+interface IFindMethod {
+    (leaf: ILeaf, options?: any): IAnswer;
+}
+interface ISelectorProxy {
+    list: ILeaf[];
+}
+interface ISelector {
+    target: ILeaf;
+    proxy?: ISelectorProxy;
+    config: ISelectorConfig;
+    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;
+    getByClassName(className: string, branch?: ILeaf): ILeaf[];
+    getByTag(tag: string, branch?: ILeaf): ILeaf[];
+    getByMethod(method: IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[];
+    destroy(): void;
 }
 
 interface ICachedLeaf {
@@ -1052,79 +1232,190 @@ interface ICachedLeaf {
     bounds: IBoundsData;
 }
 interface ILeafAttrData {
-    id: __String;
-    name: __String;
-    className: __String;
-    blendMode: IBlendMode;
-    opacity: __Number;
-    visible: __Boolean;
-    isMask: __Boolean;
-    isEraser: __Boolean;
-    zIndex: __Number;
-    x: __Number;
-    y: __Number;
-    width: __Number;
-    height: __Number;
-    scaleX: __Number;
-    scaleY: __Number;
-    rotation: __Number;
-    skewX: __Number;
-    skewY: __Number;
-    scale: __Number | IPointData;
-    around: 'center' | IPointData;
-    draggable: __Boolean;
-    hittable: __Boolean;
-    hitFill: IHitType;
-    hitStroke: IHitType;
-    hitChildren: __Boolean;
-    hitSelf: __Boolean;
-    hitRadius: __Number;
-    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[];
+    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 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';
-type IResizeType = 'size' | 'scale';
+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' | 'font-size' | 'scale';
 interface IImageCursor {
     url: string;
     x?: number;
     y?: number;
+    rotation?: number;
 }
-type IAround = '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[];
-}
-interface ILeafInputData extends IObject {
+type IDirection = 'top-left' | 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'left' | 'center';
+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?: __String;
-    name?: __String;
-    className?: __String;
+    id?: IString;
+    name?: IString;
+    className?: IString;
     blendMode?: IBlendMode;
-    opacity?: __Number;
-    visible?: __Boolean;
-    isMask?: __Boolean;
-    isEraser?: __Boolean;
-    zIndex?: __Number;
-    x?: __Number;
-    y?: __Number;
-    width?: __Number;
-    height?: __Number;
-    scaleX?: __Number;
-    scaleY?: __Number;
-    rotation?: __Number;
-    skewX?: __Number;
-    skewY?: __Number;
-    scale?: __Number | IPointData;
-    around?: IAround;
-    draggable?: __Boolean;
-    hittable?: __Boolean;
+    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;
-    hitChildren?: __Boolean;
-    hitSelf?: __Boolean;
-    hitRadius?: __Number;
+    hitBox?: IBoolean;
+    hitChildren?: IBoolean;
+    hitSelf?: IBoolean;
+    hitRadius?: INumber;
     cursor?: ICursorType | ICursorType[];
+    normalStyle?: ILeafInputData;
+    hoverStyle?: ILeafInputData;
+    pressStyle?: ILeafInputData;
+    focusStyle?: ILeafInputData;
+    selectedStyle?: ILeafInputData;
+    disabledStyle?: ILeafInputData;
+    data?: IObject;
     children?: ILeafInputData[];
+    noBounds?: boolean;
 }
 interface ILeafComputedData {
     id?: string;
@@ -1132,10 +1423,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;
@@ -1145,86 +1439,174 @@ 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;
     hittable?: boolean;
     hitFill?: IHitType;
     hitStroke?: IHitType;
+    hitBox?: boolean;
     hitChildren?: boolean;
     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;
     readonly __DataProcessor: IObject;
     readonly __LayoutProcessor: IObject;
-    leafer?: ILeafer;
+    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;
-    __local: IMatrixWithBoundsData;
+    __world: IMatrixWithBoundsScaleData;
+    __local?: IMatrixWithBoundsData;
+    __nowWorld?: IMatrixWithBoundsScaleData;
+    __cameraWorld?: IMatrixWithBoundsScaleData;
+    readonly __localMatrix: IMatrixData;
+    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;
     readonly worldOpacity: number;
-    __renderTime?: number;
     __level: number;
     __tempNumber?: number;
-    readonly resizeable: boolean;
-    readonly __hasMirror: boolean;
+    readonly __worldFlipped: boolean;
+    __hasAutoLayout?: boolean;
     __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;
-    waitParent(item: IFunction): void;
-    waitLeafer(item: IFunction): void;
-    nextRender(item: IFunction): void;
-    __bindLeafer(leafer: ILeafer | null): void;
+    reset(data?: ILeafInputData): void;
+    resetCustom(): 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;
-    toJSON(): IObject;
-    toString(): string;
-    __setAttr(attrName: string, newValue: __Value): void;
-    __getAttr(attrName: string): __Value;
+    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[];
+    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;
+    __updateLocalBounds(): void;
     __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): void;
-    __removeMask(child?: ILeaf): void;
-    getWorld(attrName: IMatrixDecompositionAttr): number;
-    getBounds(type: ILayoutBoundsType, locationType?: ILayoutLocationType): IBoundsData;
+    __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;
@@ -1235,18 +1617,35 @@ 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;
-    move(x: number, y?: number): void;
-    scaleOf(origin: IPointData, x: number, y?: number): void;
-    rotateOf(origin: IPointData, rotation: number): void;
-    skewOf(origin: IPointData, x: number, y: number): void;
+    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 | 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;
+    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;
@@ -1257,36 +1656,13 @@ interface ILeaf extends ILeafMask, ILeafRender, ILeafHit, ILeafBounds, ILeafMatr
     __updateSortChildren(): void;
     add(child: ILeaf, index?: number): void;
     remove(child?: ILeaf, destroy?: boolean): void;
+    dropTo(parent: ILeaf, index?: number, resize?: boolean): void;
 }
-
-interface ISelectPathResult {
-    leaf: ILeaf;
-    path: ILeafList;
-    throughPath?: ILeafList;
-}
-interface ISelectPathOptions {
-    name?: string;
-    through?: boolean;
-    exclude?: ILeafList;
-    ignoreHittable?: boolean;
-}
-interface ISelectorConfig {
-}
-interface ISelector {
-    target: ILeaf;
-    config: ISelectorConfig;
-    getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult;
-    find(name: number | string, branch?: ILeaf): ILeaf | ILeaf[];
-    getByInnerId(name: number, branch?: ILeaf): ILeaf;
-    getById(name: string, branch?: ILeaf): ILeaf;
-    getByClassName(name: string, branch?: ILeaf): ILeaf[];
-    getByTagName(name: string, branch?: ILeaf): ILeaf[];
-    destroy(): void;
+type ILeafAttrDescriptor = IObject & ThisType<ILeaf>;
+interface ILeafAttrDescriptorFn {
+    (key: string): ILeafAttrDescriptor;
 }
 
-type IExportImageType = 'jpg' | 'png' | 'webp';
-type IExportFileType = IExportImageType | 'svg' | 'pdf' | 'json';
-
 interface ILeaferImageConfig {
     url: string;
     thumb?: string;
@@ -1298,6 +1674,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;
@@ -1305,6 +1688,7 @@ interface ILeaferImage {
     width: number;
     height: number;
     isSVG: boolean;
+    hasOpacityPixel: boolean;
     readonly completed: boolean;
     ready: boolean;
     error: IObject;
@@ -1314,6 +1698,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;
 }
 
@@ -1331,9 +1716,9 @@ interface IUIEvent extends IEvent {
     buttons?: number;
     path?: ILeafList;
     throughPath?: ILeafList;
-    origin?: IObject;
-    getInner?(target?: ILeaf): IPointData;
-    getLocal?(target?: ILeaf): IPointData;
+    getPage?(): IPointData;
+    getInner?(relative?: ILeaf): IPointData;
+    getLocal?(relative?: ILeaf): IPointData;
 }
 interface IPointerEvent extends IUIEvent {
     width?: number;
@@ -1344,6 +1729,7 @@ interface IPointerEvent extends IUIEvent {
     tiltX?: number;
     tiltY?: number;
     twist?: number;
+    isCancel?: boolean;
 }
 type PointerType = 'mouse' | 'pen' | 'touch';
 interface IDragEvent extends IPointerEvent {
@@ -1351,10 +1737,13 @@ interface IDragEvent extends IPointerEvent {
     moveY: number;
     totalX?: number;
     totalY?: number;
-    getInnerMove?(target?: ILeaf): IPointData;
-    getLocalMove?(target?: ILeaf): IPointData;
-    getInnerTotal?(target?: ILeaf): IPointData;
-    getLocalTotal?(target?: ILeaf): IPointData;
+    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;
@@ -1387,14 +1776,18 @@ interface IInteraction extends IControl {
     selector: ISelector;
     running: boolean;
     readonly dragging: boolean;
+    readonly isDragEmpty: boolean;
+    readonly isHoldRightKey: boolean;
     readonly moveMode: 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;
@@ -1407,10 +1800,20 @@ interface IInteraction extends IControl {
     rotate(data: IRotateEvent): void;
     keyDown(data: IKeyEvent): void;
     keyUp(data: IKeyEvent): void;
-    findPath(data: IPointerEvent, options?: ISelectPathOptions): ILeafList;
-    updateDownData(data?: IPointerEvent): void;
+    findPath(data: IPointerEvent, options?: IPickOptions): ILeafList;
+    isRootPath(data: IPointerEvent): boolean;
+    isTreePath(data: IPointerEvent): boolean;
+    canMove(data: IPointerEvent): boolean;
+    isDrag(leaf: ILeaf): boolean;
+    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 {
@@ -1421,19 +1824,29 @@ interface IInteractionConfig {
     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 {
-    zoomMode?: boolean;
+    disabled?: boolean;
+    zoomMode?: boolean | 'mouse';
     zoomSpeed?: number;
     moveSpeed?: number;
     rotateSpeed?: number;
@@ -1449,48 +1862,40 @@ interface IPointerConfig {
     tapTime?: number;
     longPressTime?: number;
     transformTime?: number;
+    hover?: boolean;
     dragHover?: boolean;
     dragDistance?: number;
     swipeDistance?: number;
     ignoreMove?: boolean;
     preventDefault?: 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;
-    moveLayer?: ILeaf;
-    transformData?: ITransformEventData;
-    setZoomLayer(zoomLayer: ILeaf, moveLayer?: 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;
     realCanvas?: boolean;
+    lazySpeard?: IFourNumber;
 }
-interface ILeafer extends IZoomView, IControl {
-    readonly isApp: boolean;
-    readonly app: ILeafer;
-    parent?: IApp;
+interface ILeaferAttrData {
     running: boolean;
     created: boolean;
     ready: boolean;
     viewReady: boolean;
+    imageReady: boolean;
     viewCompleted: boolean;
-    pixelRatio: number;
+    layoutLocked: boolean;
+    transforming: boolean;
     view: unknown;
     canvas: ILeaferCanvas;
     renderer: IRenderer;
@@ -1501,25 +1906,41 @@ interface ILeafer extends IZoomView, IControl {
     canvasManager: ICanvasManager;
     hitCanvasManager?: IHitCanvasManager;
     autoLayout?: IAutoBounds;
+    lazyBounds: IBounds;
     config: ILeaferConfig;
+    readonly cursorPoint: IPointData;
+    readonly clientBounds: IBoundsData;
+    leafs: number;
     __eventIds: IEventListenerId[];
     __nextRenderWait: IFunction[];
-    init(userConfig?: ILeaferConfig, parentApp?: IApp): void;
-    setZoomLayer(zoomLayer: ILeaf, moveLayer?: ILeaf): void;
-    forceFullRender(): void;
-    updateCursor(): void;
+    init(userConfig?: ILeaferConfig, parentApp?: IAppBase): void;
+    start(): void;
+    stop(): void;
+    unlockLayout(): void;
+    lockLayout(): 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;
+    parent?: IAppBase;
 }
 interface ILeaferTypeCreator {
     list: ILeaferTypeList;
     register(name: string, fn: ILeaferTypeFunction): void;
-    run(name: string, leafer: ILeafer): void;
+    run(name: string, leafer: ILeaferBase): void;
 }
 interface ILeaferTypeFunction {
-    (leafer: ILeafer): void;
+    (leafer: ILeaferBase): void;
 }
 interface ILeaferTypeList {
     [key: string]: ILeaferTypeFunction;
@@ -1528,19 +1949,21 @@ 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;
     selector?(target: ILeaf, options?: ISelectorConfig): ISelector;
     interaction?(target: ILeaf, canvas: IInteractionCanvas, selector: ISelector, options?: IInteractionConfig): IInteraction;
+    editor?(options?: IObject): ILeaf;
 }
 interface IUICreator {
     register(UI: IObject): void;
     get(tag: string, data: IObject): IObject;
 }
 
-interface IApp extends ILeafer {
-    children: ILeafer[];
+interface IAppBase extends ILeaferBase {
+    children: ILeaferBase[];
     realCanvas: boolean;
 }
 
@@ -1597,18 +2020,52 @@ interface IImageManager {
     recycledList: ILeaferImage[];
     tasker: ITaskProcessor;
     patternTasker: ITaskProcessor;
+    patternLocked?: boolean;
     readonly isComplete: boolean;
     get(config: ILeaferImageConfig): ILeaferImage;
     recycle(image: ILeaferImage): void;
     clearRecycled(): void;
+    hasOpacityPixel(config: ILeaferImageConfig): boolean;
+    isFormat(format: IExportFileType, config: ILeaferImageConfig): boolean;
     destroy(): void;
 }
 
+type ICanvasType = 'skia' | 'napi' | 'canvas' | 'wx';
+interface ISkiaCanvas {
+    toBuffer(format: IExportFileType, config: ISkiaCanvasExportConfig): Promise<any>;
+    toBufferSync(format: IExportFileType, config: ISkiaCanvasExportConfig): any;
+    toDataURL(format: IExportImageType, config: ISkiaCanvasExportConfig): Promise<string>;
+    toDataURLSync(format: IExportImageType, config: ISkiaCanvasExportConfig): string;
+    saveAs(filename: string, config: ISkiaCanvasExportConfig): Promise<void>;
+    saveAsSync(filename: string, config: ISkiaCanvasExportConfig): void;
+}
+interface ISkiaCanvasExportConfig {
+    page?: number;
+    matte?: string;
+    density?: number;
+    quality?: number;
+    outline?: boolean;
+}
+interface ISkiaNAPICanvas {
+    encodeSync(format: 'webp' | 'jpeg', quality?: number): any;
+    encodeSync(format: 'png'): any;
+    encode(format: 'webp' | 'jpeg' | string, quality?: number): Promise<any>;
+    encode(format: 'png'): Promise<any>;
+    toBuffer(mime: 'image/png'): any;
+    toBuffer(mime: 'image/jpeg' | 'image/webp' | string, quality?: number): any;
+    toDataURL(mime?: 'image/png'): string;
+    toDataURL(mime: 'image/jpeg' | 'image/webp' | string, quality?: number): string;
+    toDataURLAsync(mime?: 'image/png'): Promise<string>;
+    toDataURLAsync(mime: 'image/jpeg' | 'image/webp' | string, quality?: number): Promise<string>;
+}
+
 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;
@@ -1618,17 +2075,32 @@ interface IPlatform {
     fullImageShadow?: boolean;
     syncDomFont?: boolean;
     layout?(target: ILeaf): void;
-    realtimeLayout?: boolean;
     origin?: {
         createCanvas(width: number, height: number, format?: 'svg' | 'pdf'): any;
         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;
     };
+    roundRectPatch?: boolean;
+    ellipseToCurve?: boolean;
+    event?: {
+        stopDefault(origin: IObject): void;
+        stopNow(origin: IObject): void;
+        stop(origin: IObject): void;
+    };
     miniapp?: IMiniapp;
-    imageSuffix?: string;
+    image: {
+        hitCanvasSize: number;
+        maxCacheSize: number;
+        maxPatternSize: number;
+        prefix?: string;
+        suffix?: string;
+        crossOrigin: string | false;
+        getRealURL: IStringFunction;
+    };
 }
 interface IMiniappSelect extends IObject {
 }
@@ -1649,24 +2121,18 @@ interface IPlugin extends IObject {
     importVersion: string;
     import: string[];
     run(LeaferUI: IObject, config: IObject): void;
-    onLeafer?(leafer: ILeafer): void;
+    onLeafer?(leafer: ILeaferBase): void;
 }
 
-type ICanvasType = 'skia' | 'canvas' | 'wx';
-interface ISkiaCanvas {
-    toBuffer(format: IExportFileType, config: ISkiaCanvasExportConfig): Promise<any>;
-    toBufferSync(format: IExportFileType, config: ISkiaCanvasExportConfig): any;
-    toDataURL(format: IExportImageType, config: ISkiaCanvasExportConfig): Promise<string>;
-    toDataURLSync(format: IExportImageType, config: ISkiaCanvasExportConfig): string;
-    saveAs(filename: string, config: ISkiaCanvasExportConfig): Promise<void>;
-    saveAsSync(filename: string, config: ISkiaCanvasExportConfig): void;
+interface ICursorTypeMap {
+    [name: string]: ICursorType | ICursorType[];
 }
-interface ISkiaCanvasExportConfig {
-    page?: number;
-    matte?: string;
-    density?: number;
-    quality?: number;
-    outline?: boolean;
+interface ICursorRotate {
+    rotation?: number;
+    data?: string;
+}
+interface ICursorRotateMap {
+    [name: string]: ICursorRotate;
 }
 
-export type { ACommandData, ArcCommandData, ArcToCommandData, CCommandData, CanvasPathCommand, EllipseCommandData, HCommandData, IAnimateEvent, IApp, IAround, IAutoBounds, IAutoBoundsData, IBlendMode, IBlob, IBlobFunction, IBooleanMap, IBounds, IBoundsData, IBoundsDataHandle, IBranch, IBranchRender, IBranchRenderModule, ICachedLeaf, ICanvasAttr, ICanvasContext2D, ICanvasManager, ICanvasStrokeOptions, ICanvasType, IChildEvent, IControl, ICreator, ICursorType, ICursorTypeMap, IDataProcessor, IDataTypeHandle, IDragEvent, IDropEvent, IEvent, IEventListener, IEventListenerId, IEventListenerItem, IEventListenerMap, IEventListenerOptions, IEventTarget, IEventer, IExportFileType, IExportImageType, IFunction, IHitCanvas, IHitCanvasConfig, IHitCanvasManager, IHitType, IImageEvent, IImageManager, IInteraction, IInteractionCanvas, IInteractionConfig, IKeepTouchData, IKeyEvent, ILayoutBlockData, ILayoutBoundsType, ILayoutChangedData, ILayoutEvent, ILayoutLocationType, ILayouter, ILayouterConfig, ILeaf, ILeafArrayMap, ILeafAttrData, ILeafBounds, ILeafBoundsModule, ILeafComputedData, ILeafData, ILeafDataProxy, ILeafDataProxyModule, ILeafEventer, ILeafEventerModule, ILeafHit, ILeafHitModule, ILeafInputData, ILeafLayout, ILeafLevelList, ILeafList, ILeafListItemCallback, ILeafMap, ILeafMask, ILeafMaskModule, ILeafMatrix, ILeafMatrixModule, ILeafRender, ILeafRenderModule, ILeafer, ILeaferCanvas, ILeaferCanvasConfig, ILeaferConfig, ILeaferEvent, ILeaferImage, ILeaferImageConfig, ILeaferImageOnError, ILeaferImageOnLoaded, ILeaferType, ILeaferTypeCreator, ILeaferTypeFunction, ILeaferTypeList, IMatrix, IMatrixData, IMatrixDecompositionAttr, IMatrixDecompositionData, IMatrixWithBoundsData, IMatrixWithLayoutData, IMiniapp, IMiniappSelect, IMiniappSizeView, IMoveEvent, IMultiTouchData, INumberMap, IObject, IOffsetBoundsData, IPartLayoutConfig, IPath2D, IPathCommandData, IPathCreator, IPathDrawer, IPathString, IPlatform, IPlugin, IPoint, IPointData, IPointerConfig, IPointerEvent, IPropertyEvent, IRadiusPointData, IRenderEvent, IRenderOptions, IRenderer, IRendererConfig, IResizeEvent, IResizeEventListener, IResizeType, IRotateEvent, IScreenSizeData, ISelectPathOptions, ISelectPathResult, ISelector, ISelectorConfig, ISize, ISizeData, ISkiaCanvas, ISkiaCanvasExportConfig, IStringMap, ISwipeEvent, ITaskItem, ITaskOptions, ITaskProcessor, ITaskProcessorConfig, ITextMetrics, ITimer, ITransformEvent, ITransformEventData, ITwoPointBounds, ITwoPointBoundsData, IUICreator, IUIEvent, IUpdateEvent, IWatchEvent, IWatchEventData, IWatcher, IWatcherConfig, IWheelConfig, IWindingRule, IZoomEvent, IZoomView, InnerId, LCommandData, MCommandData, PointerType, QCommandData, RectCommandData, RoundRectCommandData, SCommandData, TCommandData, TransformMode, VCommandData, ZCommandData, __Boolean, __Number, __Object, __String, __Value };
+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, IDragEvent, IDropEvent, IEditSize, IEraserType, IEvent, IEventListener, IEventListenerId, IEventListenerItem, IEventListenerMap, IEventListenerOptions, IEventTarget, IEventer, IExportFileType, IExportImageType, IExportOnCanvasFunction, IExportOptions, IExportResult, IExportResultFunction, IFindCondition, IFindMethod, IFlowAlign, IFlowAxisAlign, IFlowBoxType, IFlowType, IFlowWrap, IFourNumber, IFromToData, IFunction, 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 };