archgine 1.0.36 → 1.0.38

package/lib/applications/app-cvs.d.ts

@@ -0,0 +1,11 @@
+import { Application } from './application';
+import { IAppOffscreenConfig } from './app-offscreen';
+import { MainScene } from '../scenes/main-scene';
+export declare class AppCvs<Config extends IAppOffscreenConfig> extends Application<Config> {
+    params: Config;
+    mainScene: MainScene<Config>;
+    constructor(config?: Config);
+    destroy(): void;
+    load(url?: string, layers?: string[]): Promise<void>;
+    trans2MainScene(): void;
+}

package/lib/applications/app-offscreen.d.ts

@@ -1,14 +1,19 @@
-import { default as EventDispatcher } from '../core/event-dispatcher';
 import { IApplicationConfig } from './application';
+import { OpeView } from '../core/ope-view';
 export interface IAppOffscreenConfig extends IApplicationConfig {
 }
-export declare class AppOffscreen<Config extends IAppOffscreenConfig> extends EventDispatcher {
-    readonly name: string;
+export declare class AppOffscreen<Config extends IAppOffscreenConfig> {
     params: Config;
-    private readonly runningHandler;
+    cvs: OffscreenCanvas;
+    worker: Worker;
+    view: OpeView<Config>;
+    readonly workerMessageHandler: (e: MessageEvent) => void;
     constructor(config?: Config);
     destroy(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    handleWorkerMessage(e: MessageEvent): void;
+    resize(): void;
+    load(url: string, layers?: string[], lv?: number): Promise<void>;
     start(): void;
-    /** @description application's lifeCycle */
-    running(): void;
 }

package/lib/applications/application.d.ts

@@ -1,9 +1,9 @@
+import { IRenderer2, IRenderer2Config } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-import { IRenderer2Config } from '../interfaces';
-import { default as Scene } from '../scenes/scene';
 import { default as Box2 } from '../math/box2';
-import { default as Renderer2 } from '../renders/renderer2';
 import { View } from '../core/view';
+import { EffectComposer } from '../effects/effect-composer';
+import { default as Scene } from '../scenes/scene';
 export interface IApplicationConfig extends IRenderer2Config {
     frameInterval?: number;
     syncDelay?: number;
@@ -11,7 +11,7 @@ export interface IApplicationConfig extends IRenderer2Config {
 }
 /**
  * @author Dio Zhu
- * @since 2024.8.22
+ * @since 2024.11.13
  */
 export declare abstract class Application<Config extends IApplicationConfig> extends EventDispatcher {
     name: string;
@@ -19,13 +19,15 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     scenes: Scene[];
     nextScenes: Scene[];
     nextBoundingBox: Box2;
-    renderer: Renderer2<Config>;
-    view: View<Config>;
-    runningHandler: () => void;
+    loadingScene: Scene;
+    composer: EffectComposer;
+    renderer: IRenderer2;
+    view: View<any>;
+    readonly runningHandler: (time: DOMHighResTimeStamp) => void;
     protected constructor(config?: Config);
     destroy(): void;
-    setViewAreaLimit(v: number): void;
-    updateScenes(): void;
+    get isLoadingScene(): boolean;
+    trans2LoadingScene(): void;
     hasScene(scene: Scene): boolean;
     pushScene(scene: Scene): void;
     clearScenes(): void;
@@ -35,5 +37,6 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     trans2Scenes(...scenes: Scene[]): void;
     start(): void;
     /** @description application's lifeCycle */
-    running(): void;
+    running(time: DOMHighResTimeStamp): void;
+    stop(): void;
 }

package/lib/controls/interactive-controls.d.ts

@@ -1,10 +1,10 @@
 import { OrbitControls } from './orbit-controls';
-import { ICamera2, ICanvas } from '../interfaces';
+import { ICamera2 } from '../interfaces';
 export declare class InteractiveControls extends OrbitControls {
     name: string;
     mouseButtons: any;
     private readonly clickHandler;
-    constructor(camera: ICamera2, domElement: ICanvas);
+    constructor(camera: ICamera2, domElement: HTMLElement);
     destroy(): void;
     bindMapEvents(): void;
     unbindMapEvents(): void;

package/lib/controls/orbit-controller.d.ts

@@ -1,6 +1,6 @@
-import { ICamera2, IVector2 } from '../interfaces';
+import { ICamera2, IOrbitController, IVector2 } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-export declare class OrbitController extends EventDispatcher {
+export declare class OrbitController extends EventDispatcher implements IOrbitController {
     name: string;
     isSvg: boolean;
     dom: HTMLElement;

package/lib/controls/orbit-controls.d.ts

@@ -1,6 +1,6 @@
 import { default as Vector2 } from '../math/vector2';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-import { ICamera2, ICanvas, IMatrix3, IVector2 } from '../interfaces';
+import { ICamera2, IMatrix3, IVector2 } from '../interfaces';
 interface IScene {
 }
 export interface IOrbitControlsConfig {
@@ -22,7 +22,7 @@ export interface IOrbitControlsConfig {
 export declare class OrbitControls extends EventDispatcher {
     name: string;
     camera: ICamera2;
-    domElement: ICanvas;
+    domElement: HTMLElement;
     domOffset: Vector2;
     enableNegateControl: boolean;
     focus: Vector2;
@@ -44,20 +44,22 @@ export declare class OrbitControls extends EventDispatcher {
         ONE: TouchEnum;
         TWO: TouchEnum;
     };
-    private _lastPosition;
     target0: IVector2;
     position0: IVector2;
     scene: IScene | null;
     enabled: boolean;
     state: number;
     EPS: number;
+    scaled: number;
+    rotateTheta: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    private _lastPosition;
     private pointers;
     private pointerPositions;
-    scaled: number;
     private rotateStart;
     private rotateEnd;
     private rotateDelta;
-    rotateTheta: number;
     private panStart;
     private panEnd;
     private panDelta;
@@ -66,15 +68,13 @@ export declare class OrbitControls extends EventDispatcher {
     private dollyEnd;
     private dollyDelta;
     private dollyOffset;
-    enableDamping: boolean;
-    dampingFactor: number;
     private readonly contextMenuHandler;
     private readonly pointerDownHandler;
     private readonly pointerUpHandler;
     private readonly pointerCancelHandler;
     private readonly pointerMoveHandler;
     private readonly wheelHandler;
-    constructor(camera: ICamera2, domElement: ICanvas);
+    constructor(camera: ICamera2, domElement: HTMLElement);
     destroy(): void;
     update(): void;
     pan(deltaX: number, deltaY: number): void;

package/lib/core/camera2.d.ts

@@ -1,28 +1,15 @@
 import { default as Vector2 } from '../math/vector2';
-import { ICamera2, ICamera2Position, IObject2, IVector2 } from '../interfaces';
+import { ICamera2, ICamera2Config, ICamera2Position, IObject2, IVector2 } from '../interfaces';
 import { default as Matrix3 } from '../math/matrix3';
 import { Object2 } from './object2';
 import { default as Box2 } from '../math/box2';
-export interface ICamera2Config {
-    width?: number;
-    height?: number;
-    aspect?: number;
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-    eye?: number[];
-    up?: number[];
-    helperEnable?: boolean;
-    flipY?: boolean;
-}
 interface IView {
     enabled: boolean;
     width: number;
     height: number;
     offset: IVector2;
 }
-export default class Camera2<Config extends ICamera2Config = ICamera2Config> extends Object2 implements ICamera2 {
+export default class Camera2<Config extends ICamera2Config> extends Object2 implements ICamera2 {
     readonly isCamera: boolean;
     type: string;
     name: string;
@@ -61,7 +48,7 @@ export default class Camera2<Config extends ICamera2Config = ICamera2Config> ext
     toJSON(): any;
     fromJSON(o: any): void;
     clone(): any;
-    copy(source: Camera2, recursive?: boolean): IObject2;
+    copy(source: Camera2<Config>, recursive?: boolean): IObject2;
 }
 export declare enum CAMERA_ENUM {
     UPDATE = "update"

package/lib/core/ope-view.d.ts

@@ -0,0 +1,40 @@
+import { IBox2, ICamera2, ICamera2Config, ICanvas, IRenderer2Config, IView } from '../interfaces';
+import { IOrbitControlsConfig } from '../controls/orbit-controls';
+import { default as Scene } from '../scenes/scene';
+import { OrbitController } from '../controls/orbit-controller';
+import { default as Box2 } from '../math/box2';
+import { IAxesHelperConfig } from '../helpers/axes-helper';
+export interface IViewConfig extends IRenderer2Config {
+    name?: string;
+    cvs?: ICanvas;
+    camera?: ICamera2Config;
+    controls?: IOrbitControlsConfig;
+    axesHelper?: IAxesHelperConfig;
+    alignStageCenter?: boolean;
+}
+/**
+ * @author Dio Zhu 2024.8.22
+ */
+export declare class OpeView<Config extends IViewConfig> implements IView {
+    name: string;
+    params: Config;
+    visible: boolean;
+    cvs: ICanvas | undefined;
+    scene: Scene | undefined;
+    scenes: Scene[];
+    camera: ICamera2 | undefined;
+    controller?: OrbitController;
+    constructor(config?: Config);
+    destroy(): void;
+    initController(camera?: ICamera2, dom?: HTMLElement): void;
+    handleCameraChanged(e: any): void;
+    reset(): void;
+    bindScene(scene: Scene): void;
+    resetCameraByBoundingBox(box: IBox2, animate?: boolean): void;
+    computeScenesBoundingBox(scenes: Scene[], target?: Box2): Box2;
+    expandScenesBoundingBox(scenes: Scene[], box?: Box2): void;
+    /**
+     * @see Application.running
+     */
+    update(time?: DOMHighResTimeStamp): void;
+}

package/lib/core/view.d.ts

@@ -1,6 +1,5 @@
-import { IBox2, ICamera2, ICanvas, IRenderer2Config, IView } from '../interfaces';
+import { IBox2, ICamera2, ICamera2Config, ICanvas, IRenderer2Config, IView } from '../interfaces';
 import { IOrbitControlsConfig } from '../controls/orbit-controls';
-import { ICamera2Config } from './camera2';
 import { default as Scene } from '../scenes/scene';
 import { OrbitController } from '../controls/orbit-controller';
 import { default as Box2 } from '../math/box2';
@@ -20,7 +19,6 @@ export declare class View<Config extends IViewConfig> implements IView {
     name: string;
     params: Config;
     visible: boolean;
-    container: HTMLElement;
     cvs: ICanvas | undefined;
     scene: Scene | undefined;
     scenes: Scene[];
@@ -28,15 +26,15 @@ export declare class View<Config extends IViewConfig> implements IView {
     controller?: OrbitController;
     constructor(config?: Config);
     destroy(): void;
-    initController(camera?: ICamera2, dom?: HTMLElement): void;
+    bindScene(scene: Scene): void;
+    fullscreen(padding?: number, animate?: boolean): void;
     handleCameraChanged(e: any): void;
     reset(): void;
-    bindScene(scene: Scene): void;
     resetCameraByBoundingBox(box: IBox2, animate?: boolean): void;
     computeScenesBoundingBox(scenes: Scene[], target?: Box2): Box2;
     expandScenesBoundingBox(scenes: Scene[], box?: Box2): void;
     /**
      * @see Application.running
      */
-    update(): void;
+    update(time?: DOMHighResTimeStamp): void;
 }

package/lib/environment.worker.js

@@ -3995,7 +3995,7 @@ Fu.__DOMHandler = Eu;
 Fu.normalizeLineEndings = Le;
 Fu.DOMParser = Ie;
 var gr = Fu.DOMParser;
-const Er = "1.0.36";
+const Er = "1.0.38";
 function vr() {
   return typeof window < "u" && ({}.toString.call(window) === "[object Window]" || {}.toString.call(window) === "[object global]");
 }
@@ -4432,7 +4432,7 @@ function Tr(u) {
 `, postMessage({ cmd: "echo", data: { msg: e } });
 }
 function Nr() {
-  console.log("- DOMParser: ", !!P.window.DOMParser);
+  console.log("- DOMParser: ", !!DOMParser, !!P.window.DOMParser);
   const u = new P.window.DOMParser().parseFromString(
     `<xml xmlns="a" xmlns:c="./lite">
 	<child>test</child>

package/lib/extras/adapter.d.ts

@@ -0,0 +1,23 @@
+import { default as EventDispatcher } from '../core/event-dispatcher';
+import { default as Box2 } from '../math/box2';
+import { IShape2 } from '../interfaces';
+export declare class Adapter extends EventDispatcher {
+    name: string;
+    boundingBox: Box2;
+    resources: Record<string, IShape2[]>;
+    private _svg?;
+    private _svgRoot?;
+    private _viewBox;
+    private _elementsMap;
+    constructor();
+    destroy(): void;
+    load(url: string, layers?: string[], lv?: number): Promise<void>;
+    init(str?: string): void;
+    initResources(): void;
+    initResource(id: string): void;
+    getElementById(id: string): Element | undefined;
+}
+export declare enum AdapterEnum {
+    INITIALIZATION_START = "INITIALIZATION_START",
+    INITIALIZATION_COMPLETE = "INITIALIZATION_COMPLETE"
+}

package/lib/extras/chef.d.ts

@@ -1,5 +1,5 @@
 import { IElement, ISvgElement } from '../svg/interfaces';
-import { IGroup2, IShape } from '../interfaces';
+import { IGroup2, IShape, ITree } from '../interfaces';
 import { default as Box2 } from '../math/box2';
 export declare class Chef {
     svg?: HTMLElement;
@@ -15,15 +15,9 @@ export declare class Chef {
     bind(data: ISvgElement): this;
     splitDefs(): this;
     splitLayers(ids?: string[], out?: (IGroup2 | IShape)[]): this;
-    getLayers(lv?: number): TLayer[];
-    _getLayer(el: IElement, lv?: number, lvi?: number, out?: TLayer[]): TLayer[];
+    getLayers(lv?: number): ITree[];
+    _getLayer(el: IElement, lv?: number, lvi?: number, out?: ITree[]): ITree[];
     getById(id: string): IGroup2 | IShape | undefined;
     getByIds(ids: string[]): (IGroup2 | IShape)[];
     trans2RenderObject(el: IElement): IGroup2 | IShape | undefined;
 }
-export type TLayer = {
-    id: string;
-    label: string;
-    selected?: boolean;
-    children?: TLayer[];
-};

package/lib/extras/interfaces.d.ts

@@ -52,6 +52,8 @@ export interface IApp {
     highlightDummies(ids: string | string[]): void;
     resetHighlightDummies(): void;
 }
+export interface IResource {
+}
 export declare enum AE_TYPES {
     DEFAULT = "default",
     INFO = "info",

package/lib/extras/svg-app.d.ts

@@ -1,6 +1,5 @@
 import { default as EventDispatcher } from '../core/event-dispatcher';
 import { IApplicationConfig } from '../applications/application';
-import { TLayer } from './chef';
 import { default as SvgRenderer } from '../renders/svg-renderer';
 import { IApp, IDummyVo } from './interfaces';
 import { default as Scene } from '../scenes/scene';
@@ -59,9 +58,9 @@ export declare class SvgApp<Config extends ISvgAppConfig> extends EventDispatche
     start(): void;
     /** @description application's lifeCycle */
     running(time: DOMHighResTimeStamp): void;
-    load(url: string, layers?: string[], lv?: number, skeletons?: string[]): Promise<TLayer[]>;
+    load(url: string, layers?: string[], lv?: number, skeletons?: string[]): Promise<ITree[]>;
     setSkeletons(skeletons: string[]): void;
-    getLayers(lv?: number): TLayer[] | undefined;
+    getLayers(lv?: number): ITree[] | undefined;
     updateLayersVisibility(ids: string[], visible?: boolean): void;
     selectByIds(ids: string | string[]): void;
     getSelectedIds(): string[] | undefined;

package/lib/extras/svg-chef.d.ts

@@ -1,13 +1,12 @@
 import { ISvgElement } from '../svg/interfaces';
 import { default as Box2 } from '../math/box2';
 import { default as Vector2 } from '../math/vector2';
-import { TLayer } from './chef';
 import { ITree, IVector2 } from '../interfaces';
 export declare class SvgChef {
     svg?: HTMLElement;
     offset: Vector2;
     svgRoot?: Element;
-    layers: TLayer[];
+    layers: ITree[];
     elementsMap: Record<string, Element>;
     boundingBoxMap: Record<string, Box2>;
     boundingBox: Box2;
@@ -17,8 +16,8 @@ export declare class SvgChef {
     private readonly _exceptIds;
     private _lvi;
     bindSvg(data: HTMLElement): this;
-    getLayers(lv?: number): TLayer[];
-    _getSvgLayer(el: HTMLElement, lv?: number, lvi?: number, out?: TLayer[]): TLayer[];
+    getLayers(lv?: number): ITree[];
+    _getSvgLayer(el: HTMLElement, lv?: number, lvi?: number, out?: ITree[]): ITree[];
     getElementsMap(el: Element, out?: Record<string, Element>): Record<string, Element>;
     computeBoundingBoxMap(): Record<string, Box2>;
     updateLayersVisibility(ids: string[], visible?: boolean): void;
@@ -31,7 +30,7 @@ export declare class SvgChef {
     findSkeletonByPath(out?: Element[]): Element[];
     setTextInChildren2(o: Element, v: string): void;
     traverseSvg(o: Element, cb: Function): void;
-    traverseSvgTLayers(o: TLayer | TLayer[], cb: Function): void;
+    traverseSvgTLayers(o: ITree | ITree[], cb: Function): void;
     getLabelElementsByType(assetType: string, out?: Record<string, Element>): Record<string, Element>;
     getLabelElementById(id: string, assetType?: string): Element | undefined;
     setLabelsById(id: string, labels?: string[], assetType?: string): void;

package/lib/geometries/circle-geo2.d.ts

@@ -0,0 +1,14 @@
+import { Geo2, IGeo2Config } from './geo2';
+export interface ICircleGeo2 extends IGeo2Config {
+    radius?: number;
+    start?: number;
+    end?: number;
+}
+export declare class CircleGeo2<Config extends ICircleGeo2> extends Geo2<Config> {
+    readonly name: string;
+    radius: number;
+    start: number;
+    end: number;
+    constructor(config?: Config);
+    recomputePath(): this;
+}

package/lib/geometries/geo2.d.ts

@@ -1,14 +1,28 @@
-import { IBox2, IPoint3 } from '../interfaces';
-import { default as Matrix3 } from '../math/matrix3';
 import { SVGPathData } from 'svg-pathdata';
+import { default as Matrix3 } from '../math/matrix3';
+import { IBox2, IContext2D, IGeo2, IMatrix3, IPath2Command, IPoint2 } from '../interfaces';
 export interface IGeo2Config {
-    points?: IPoint3[];
+    points?: IPoint2[];
+    commands?: string | IPath2Command[];
 }
-export declare class Geo2<Config extends IGeo2Config> {
+export declare class Geo2<Config extends IGeo2Config> extends SVGPathData implements IGeo2 {
     readonly name: string;
-    path2?: SVGPathData[];
-    points: IPoint3[];
-    matrix: Matrix3;
+    _version: number;
+    params: Config;
+    viewMatrix: Matrix3;
     boundingBox: IBox2;
     constructor(config?: Config);
+    set needsUpdate(v: boolean);
+    get version(): number;
+    set version(v: number);
+    static getInstanceByPath(o: Element): Geo2<any> | undefined;
+    static render(ctx: IContext2D, commands: IPath2Command[]): void;
+    setFromPoints(ps?: IPoint2[]): IGeo2;
+    recomputePath(): void;
+    computeBoundingBox(): IBox2;
+    render(ctx: IContext2D): void;
+    applyMatrix(m: IMatrix3): IGeo2;
+    getRenderCommands(m?: IMatrix3): IPath2Command[];
+    copy(source: IGeo2): IGeo2;
+    clone(): IGeo2;
 }

package/lib/geometries/polygon-geo2.d.ts

@@ -0,0 +1,6 @@
+import { Geo2, IGeo2Config } from './geo2';
+export declare class PolygonGeo2<Config extends IGeo2Config> extends Geo2<Config> {
+    readonly name: string;
+    constructor(config?: Config);
+    recomputePath(): this;
+}

package/lib/geometries/polyline-geo2.d.ts

@@ -0,0 +1,22 @@
+import { Geo2, IGeo2Config } from './geo2';
+export interface IPolylineGeo2Options extends IGeo2Config {
+    stArrow?: boolean;
+    edArrow?: boolean;
+    arrowLength?: number;
+    arrowDeg?: number;
+}
+export declare class PolylineGeo2<Config extends IPolylineGeo2Options> extends Geo2<Config> {
+    readonly name: string;
+    arrowLength: number;
+    arrowDeg: number;
+    stArrow: boolean;
+    edArrow: boolean;
+    constructor(config?: Config);
+    recomputePath(): this;
+    /**
+     *       v3  \
+     * vo ---- v2-v1
+     *       v4  /
+     */
+    addArrow(len?: number): this;
+}

package/lib/helpers/axes-helper.d.ts

@@ -1,6 +1,5 @@
 import { Axes, IAxesConfig } from '../shapes/axes';
 import { default as Vector2 } from '../math/vector2';
-import { default as Camera2 } from '../core/camera2';
 import { default as Box2 } from '../math/box2';
 import { ICamera2 } from '../interfaces';
 export interface IAxesHelperConfig extends IAxesConfig {
@@ -10,8 +9,8 @@ export declare class AxesHelper<Config extends IAxesHelperConfig = IAxesHelperCo
     usedCache: boolean;
     castShadow: boolean;
     padding: Vector2;
-    camera: Camera2 | undefined;
-    constructor(config?: Config, camera?: Camera2);
+    camera: ICamera2 | undefined;
+    constructor(config?: Config, camera?: ICamera2);
     computeBoundingBox(): Box2;
     /** @override */
     updateModelViewMatrix(camera?: ICamera2): void;

package/lib/helpers/axes-helper2.d.ts

@@ -0,0 +1,19 @@
+import { Axes, IAxesConfig } from '../shapes2/axes';
+import { default as Vector2 } from '../math/vector2';
+import { default as Box2 } from '../math/box2';
+import { ICamera2 } from '../interfaces';
+export interface IAxesHelper2Config extends IAxesConfig {
+    gridEnabled?: boolean;
+}
+export declare class AxesHelper2<Config extends IAxesHelper2Config> extends Axes<Config> {
+    name: string;
+    usedCache: boolean;
+    castShadow: boolean;
+    padding: Vector2;
+    camera: ICamera2 | undefined;
+    constructor(config?: Config, camera?: ICamera2);
+    computeBoundingBox(): Box2;
+    /** @override */
+    updateModelViewMatrix(camera?: ICamera2): void;
+    computeAxes(camera?: ICamera2): void;
+}

package/lib/helpers/canvas-helper.d.ts

@@ -1,4 +1,4 @@
-import { IShape } from '../interfaces';
+import { ICanvas, IContext2D, IShape2 } from '../interfaces';
 import { default as Vector2 } from '../math/vector2';
 interface ICanvasConfig {
     containerId?: string;
@@ -17,14 +17,14 @@ export default class CanvasHelper {
     /**
      * @todo: cvs.getContext('bitmaprenderer') => ImageBitmapRenderingContext.transferFromImageBitmap()
      */
-    static getContext2D(cvs: OffscreenCanvas | HTMLCanvasElement, params?: any): OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D;
-    static resizeCanvas(cvs: OffscreenCanvas | HTMLCanvasElement, w: number, h: number, r?: number): void;
-    static getImageBitmapByCanvasAsync(cvs?: OffscreenCanvas | HTMLCanvasElement): Promise<ImageBitmap | undefined>;
+    static getContext2D(cvs: ICanvas, params?: any): IContext2D;
+    static resizeCanvas(cvs: ICanvas, w: number, h: number, r?: number): void;
+    static getImageBitmapByCanvasAsync(cvs?: ICanvas): Promise<ImageBitmap | undefined>;
     static get(k: string, w: number, h: number, dpr?: number): OffscreenCanvas;
     static set(k: string, v: OffscreenCanvas): Map<string, OffscreenCanvas>;
     static remove(k: string): void;
     static create(w: number, h: number, dpr?: number): OffscreenCanvas;
     static createHtmlCanvas(w: number, h: number, dpr?: number): HTMLCanvasElement;
-    static measureText(text: string, obj: IShape, out?: Vector2): Vector2;
+    static measureText(text: string, obj: IShape2, out?: Vector2): Vector2;
 }
 export {};

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import { default as EnvironmentWorker } from './workers/environment.worker?worker';
+import { default as RendererWorker } from './workers/renderer.worker?worker';
 import { default as defaultConfig } from './env/default-config.js';
 export { GLOB } from './core/global.js';
 export { Color, ColorsEnum } from './math/color.js';
@@ -9,4 +10,4 @@ export { AssetTypeEnum, LayerTypeEnum } from './env/enums';
 export type { ITree } from './interfaces';
 export type { IApp, IDummyVo, IDummy } from './extras/interfaces';
 export { AppEnum, SvgApp } from './extras/svg-app';
-export { defaultConfig, EnvironmentWorker, };
+export { defaultConfig, EnvironmentWorker, RendererWorker, };