archgine 1.0.78 → 2.0.2

package/lib/renderers/renderer.d.ts

@@ -1,26 +0,0 @@
-import { IRenderer2Config, IRenderTarget, IVector2 } from '../interfaces';
-export declare class Renderer<Config extends IRenderer2Config> {
-    readonly name: string;
-    id: string;
-    params: Config;
-    autoClear: boolean;
-    cvs?: HTMLCanvasElement | OffscreenCanvas;
-    ctx?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
-    _currentRenderTarget: IRenderTarget | undefined;
-    _isContextLost: boolean;
-    private readonly contextLostHandler;
-    private readonly contextRestoreHandler;
-    constructor(config?: Config);
-    destroy(): void;
-    init(): void;
-    resize(): void;
-    setSize(w: number, h: number): void;
-    getSize(out?: IVector2): IVector2;
-    bindEvents(): void;
-    unbindEvents(): void;
-    handleContextLost(e: any): void;
-    handleContextRestore(): void;
-    clean(): void;
-    getRenderTarget(): IRenderTarget | undefined;
-    setRenderTarget(renderTarget?: IRenderTarget): void;
-}

package/lib/renders/binding-states.d.ts

@@ -1,35 +0,0 @@
-import { ICamera2, ILight, IObject2, IRenderer2Config, IShape, ITexture } from '../interfaces';
-import { Path } from '../geometries/path';
-export interface IBindingState {
-    id: number;
-    uuid: string;
-    needsUpdate: boolean;
-    featureKey: string;
-    cameraVersion: number;
-    viewPath?: Path;
-    geoVersion?: number;
-    mtlVersion?: number;
-    version: number;
-    cachedTexture?: ITexture;
-}
-export interface IRenderState {
-    light?: ILight;
-}
-export declare class BindingStates {
-    params: IRenderer2Config;
-    currentCamera: ICamera2 | undefined;
-    bindingStates: WeakMap<IObject2, IBindingState>;
-    forceUpdate: boolean;
-    currentState: IBindingState | undefined;
-    cameraVersion: string | undefined;
-    currentRenderState: IRenderState | undefined;
-    constructor(config: IRenderer2Config);
-    destroy(): void;
-    reset(): void;
-    setup(obj: IShape, currentRenderState?: IRenderState, camera?: ICamera2): IBindingState;
-    getBindingState(obj: IObject2): IBindingState;
-    clearBindingState(): void;
-    needsUpdate(obj: IShape): boolean;
-    saveCache(obj: IShape): void;
-    updateModelViewMatrix(obj: IObject2, camera?: ICamera2): void;
-}

package/lib/renders/buffer-renderer.d.ts

@@ -1,19 +0,0 @@
-import { IContext2D, IObject2, IPath2D, IShape } from '../interfaces';
-import { BindingStates } from './binding-states';
-export default class BufferRenderer {
-    ctx: IContext2D;
-    bindingStates: BindingStates;
-    fill: string;
-    stroke: string;
-    lineWidth: number;
-    constructor(ctx: IContext2D, bindingStates: BindingStates);
-    destroy(): void;
-    beforeGlobalRender(): void;
-    afterGlobalRender(): void;
-    beforeRender(obj: IObject2): void;
-    render(obj: IShape): void;
-    afterRender(): void;
-    renderWireFrame(shape: IShape): void;
-    renderStroke(path?: IPath2D, color?: string, lineWidth?: number, lineDash?: [number, number]): void;
-    renderSelected(shape: IShape): void;
-}

package/lib/renders/render-lists.d.ts

@@ -1,29 +0,0 @@
-import { IObject2 } from '../interfaces';
-import { Group2, IGroup2Config } from '../objects/group2';
-import { IQueue } from '../core/queue';
-export interface IRenderItem {
-    id: number;
-    object: IObject2 | undefined;
-    groupOrder: number;
-    renderOrder: number;
-    group: Group2<IGroup2Config> | undefined;
-}
-export declare class RenderList {
-    renderItems: IRenderItem[];
-    renderItemsIndex: number;
-    queue: IQueue;
-    constructor();
-    destroy(): void;
-    clear(): void;
-    getNextRenderItem(object: IObject2, groupOrder: number, group?: Group2<IGroup2Config>): IRenderItem;
-    push(object: IObject2, groupOrder: number, group?: Group2<IGroup2Config>): this;
-    unshift(object: IObject2, groupOrder: number, group: Group2<IGroup2Config>): void;
-    sort(fn?: (a: any, b: any) => number): this;
-    finish(): this;
-}
-export declare class RenderLists {
-    lists: WeakMap<IObject2, RenderList[]>;
-    constructor();
-    destroy(): void;
-    get(scene: IObject2, renderCallDepth: number): RenderList;
-}

package/lib/renders/render-states.d.ts

@@ -1,18 +0,0 @@
-import { ILight, IObject2 } from '../interfaces';
-export declare class RenderState {
-    light: ILight | undefined;
-    lightsArray: ILight[];
-    shadowsArray: IObject2[];
-    lastCameraVersion: number;
-    constructor();
-    destroy(): void;
-    clear(): void;
-    pushLight(light: ILight): void;
-    pushShadow(shadow: IObject2): void;
-}
-export declare class RenderStates {
-    renderStates: WeakMap<IObject2, RenderState[]>;
-    constructor();
-    destroy(): void;
-    get(scene: IObject2, renderCallDepth?: number): RenderState;
-}

package/lib/renders/render-target.d.ts

@@ -1,26 +0,0 @@
-import { ICanvas, IContext2D, IRenderer2Config, IRenderTarget, ITexture } from '../interfaces';
-import { default as EventDispatcher } from '../core/event-dispatcher';
-export interface IRenderTargetConfig extends IRenderer2Config {
-    width: number;
-    height: number;
-    dpr?: number;
-    offscreen?: boolean;
-}
-export declare class RenderTarget<Config extends IRenderTargetConfig> extends EventDispatcher implements IRenderTarget {
-    name: string;
-    uuid: string;
-    featureKey: string;
-    offscreen: boolean;
-    width: number;
-    height: number;
-    dpr: number | undefined;
-    texture: ITexture;
-    cvs: ICanvas;
-    ctx: IContext2D;
-    constructor(config?: Config);
-    destroy(): void;
-    setSize(width: number, height: number, dpr?: number): void;
-    clean(): void;
-    clone(): IRenderTarget;
-    copy(source: RenderTarget<Config>): this;
-}

package/lib/renders/renderer2.d.ts

@@ -1,52 +0,0 @@
-import { ICamera2, ICanvas, IContext2D, IObject2, IRenderer2, IRenderer2Config, IRenderTarget, ITexture, IVector2 } from '../interfaces';
-import { default as BufferRenderer } from './buffer-renderer';
-import { IRenderItem, RenderList, RenderLists } from './render-lists';
-import { IQueue } from '../core/queue';
-import { BindingStates, IBindingState } from './binding-states';
-import { RenderState, RenderStates } from './render-states';
-import { default as EventDispatcher } from '../core/event-dispatcher';
-export default class Renderer2<Config extends IRenderer2Config> extends EventDispatcher implements IRenderer2 {
-    readonly isRenderer: boolean;
-    id: string;
-    params: IRenderer2Config;
-    cvs: ICanvas | undefined;
-    ctx: IContext2D | undefined;
-    renderer: BufferRenderer;
-    autoClear: boolean;
-    viewAreaLimit: number;
-    bindingStates: BindingStates;
-    currentBindingState: IBindingState | undefined;
-    renderStates: RenderStates;
-    renderStateStack: RenderState[];
-    currentRenderState: RenderState | undefined;
-    renderLists: RenderLists;
-    currentRenderList: RenderList | undefined;
-    renderListStack: RenderList[];
-    renderingOnDemand: boolean;
-    private _frustum;
-    _currentRenderTarget: IRenderTarget | undefined;
-    private contextLostHandler;
-    private contextRestoreHandler;
-    private _isContextLost;
-    constructor(params: Config);
-    destroy(): void;
-    initCanvas(): void;
-    resize(): void;
-    getSize(target: IVector2): IVector2;
-    setSize(w: number, h: number): void;
-    setRenderTarget(renderTarget?: IRenderTarget): void;
-    getRenderTarget(): IRenderTarget | undefined;
-    bindEvents(): void;
-    unbindEvents(): void;
-    handleContextLost(e: any): void;
-    handleContextRestore(): void;
-    handleShapeDestroy(): void;
-    clean(): void;
-    render(scene: IObject2, camera?: ICamera2): void;
-    projectObject(obj: IObject2, camera?: ICamera2 | undefined, groupOrder?: number): void;
-    renderScene(currentRenderList: RenderList, scene: IObject2, camera?: ICamera2): void;
-    renderObjects(queue: IQueue<IRenderItem>, scene: IObject2, camera?: ICamera2): void;
-    renderObject(obj: IObject2, scene: IObject2, camera?: ICamera2): void;
-    renderBufferDirect(obj: IObject2, scene: IObject2, camera?: ICamera2): void;
-    renderTexture(texture: ITexture, camera?: ICamera2): void;
-}

package/lib/renders/t-svg-renderer.d.ts

@@ -1,35 +0,0 @@
-import { ICamera2, ICanvas, IContext2D, IRenderer2Config, IVector2 } from '../interfaces';
-import { default as Box2 } from '../math/box2';
-import { default as Matrix3 } from '../math/matrix3';
-/**
- * render svg directly, just test efficiency, and verify matrix logic,
- * use pipeline rendering to process SVG in the future.
- * @author Dio Zhu 2024.9.4
- */
-export default class TSvgRenderer<Config extends IRenderer2Config> {
-    readonly isSvgRenderer: boolean;
-    id: string;
-    params: IRenderer2Config;
-    container: HTMLLIElement;
-    cvs: ICanvas | undefined;
-    ctx: IContext2D | undefined;
-    svg: SVGSVGElement | HTMLElement;
-    svgStr: string;
-    svgRoot: Element | undefined;
-    viewBox: Box2;
-    matrixWorld: Matrix3;
-    viewMatrix: Matrix3;
-    projectionMatrix: Matrix3;
-    cameraVersion: number;
-    constructor(params: Config);
-    destroy(): void;
-    initCanvas(): void;
-    initSvg(): void;
-    resize(w: number, h: number): void;
-    getSize(target: IVector2): IVector2;
-    bind(str: string): void;
-    clean(): void;
-    render(camera: ICamera2): Promise<void>;
-    render2(camera: ICamera2): Promise<void>;
-    render3(camera: ICamera2): Promise<void>;
-}

package/lib/scenes/animate-scene.d.ts

@@ -1,17 +0,0 @@
-import { DynamicScene } from './dynamic-scene';
-import { IApplicationConfig } from '../applications/application';
-import { default as Vector2 } from '../math/vector2';
-import { IObject2 } from '../interfaces';
-export declare class AnimateScene<Config extends IApplicationConfig> extends DynamicScene {
-    name: string;
-    params: IApplicationConfig;
-    resourcesMap: Record<string, IObject2>;
-    dynamicFill: string;
-    dynamicScale: Vector2;
-    constructor(config?: Config);
-    destroy(): void;
-    /** @override */
-    add(o: IObject2): IObject2;
-    getByIds(ids: string | string[]): IObject2[];
-    onBeforeRender(): void;
-}

package/lib/scenes/loading-text-scene.d.ts

@@ -1,19 +0,0 @@
-import { DynamicScene } from './dynamic-scene';
-import { Circle, ICircleConfig } from '../shapes2/circle';
-import { ITextConfig, Text } from '../shapes2/text';
-import { IShape2Config } from '../objects/shape2';
-export interface ILoadingTextSceneConfig extends IShape2Config {
-}
-export declare class LoadingTextScene<Config extends ILoadingTextSceneConfig> extends DynamicScene {
-    readonly isLoadingScene: boolean;
-    name: string;
-    params: ILoadingTextSceneConfig;
-    loadingMesh: Text<ITextConfig>;
-    circleMesh: Circle<ICircleConfig>;
-    circle2Mesh: Circle<ICircleConfig>;
-    scales: number[];
-    scaleTrend: boolean;
-    constructor(config?: Config);
-    destroy(): void;
-    onBeforeRender(): void;
-}

package/lib/scenes/main-scene.d.ts

@@ -1,34 +0,0 @@
-import { StaticScene } from './static-scene';
-import { AxesHelper2 } from '../helpers/axes-helper2';
-import { IBox2, IObject2 } from '../interfaces';
-import { IApplicationConfig } from '../applications/application';
-import { default as Box2 } from '../math/box2';
-export interface IMainSceneConfig extends IApplicationConfig {
-    castShadow?: boolean;
-}
-export declare class MainScene<Config extends IMainSceneConfig> extends StaticScene {
-    readonly isMainScene: boolean;
-    name: string;
-    params: IApplicationConfig;
-    featureKey: string;
-    selectable: boolean;
-    axesHelper?: AxesHelper2<any>;
-    resourcesMap: Record<string, IObject2>;
-    private _viewBox;
-    constructor(config?: Config);
-    destroy(): void;
-    initAxesHelper(): void;
-    setViewBox(box: Box2): void;
-    /** @override */
-    computeBoundingBox(): IBox2;
-    /** @override */
-    add(o: IObject2): IObject2;
-    getAssetIdsByType(assetType: string): string[];
-    setFillOrStrokeByIds(ids: string[], c: string, typ?: string): void;
-    clearFill(): void;
-    clearStroke(): void;
-    fontZoomIn(v?: number): void;
-    fontZoomOut(v?: number): void;
-    strokeMore(v?: number): void;
-    strokeLess(v?: number): void;
-}

package/lib/shapes2/actor.d.ts

@@ -1,24 +0,0 @@
-import { IShape2Config, Shape2 } from '../objects/shape2';
-import { IShape2 } from '../interfaces';
-import { Color } from '../math/color';
-export interface IActorConfig extends IShape2Config {
-    act?: ACTOR_ENUM;
-    fill?: string;
-    stroke?: string;
-}
-export declare class Actor<Config extends IActorConfig> extends Shape2 {
-    name: string;
-    isActor: boolean;
-    params: IActorConfig;
-    act: ACTOR_ENUM;
-    fill: Color;
-    constructor(config?: Config);
-    destroy(): void;
-    /** @override */
-    copy(source: IShape2, recursive?: boolean): IShape2;
-    /** @override */
-    onBeforeRender(): void;
-}
-export declare const enum ACTOR_ENUM {
-    SELECT = "SELECT"
-}

package/lib/shapes2/arrow.d.ts

@@ -1,6 +0,0 @@
-import { IPolygonConfig, Polygon } from './polygon';
-export declare class Arrow<Config extends IPolygonConfig = IPolygonConfig> extends Polygon<Config> {
-    type: string;
-    readonly isArrow: boolean;
-    constructor(config?: Config);
-}

package/lib/shapes2/axes.d.ts

@@ -1,35 +0,0 @@
-import { IShape2Config, Shape2 } from '../objects/shape2';
-export interface IAxesConfig extends IShape2Config {
-    width?: number;
-    height?: number;
-    arrowDeg?: number;
-    arrowLength?: number;
-}
-/**
- *        ^       p1
- *        │
- *        │
- * ----- p0 ───────>
- *        ╎
- *        ╎
- *
- * @Author Dio Zhu 2024.8.11
- */
-export declare class Axes<Config extends IAxesConfig> extends Shape2 {
-    name: string;
-    readonly isAxes: boolean;
-    matrixAutoUpdate: boolean;
-    matrixWorldAutoUpdate: boolean;
-    composeNode: boolean;
-    dynamically: boolean;
-    arrowLength: number;
-    arrowDeg: number;
-    stroke: string;
-    fill: string | undefined;
-    lineWidth: number;
-    xMesh: Shape2;
-    yMesh: Shape2;
-    xrMesh: Shape2;
-    yrMesh: Shape2;
-    constructor(config?: Config);
-}

package/lib/shapes2/circle.d.ts

@@ -1,10 +0,0 @@
-import { IShape2Config, Shape2 } from '../objects/shape2';
-export interface ICircleConfig extends IShape2Config {
-    radius?: number;
-}
-export declare class Circle<Config extends ICircleConfig> extends Shape2 {
-    type: string;
-    name: string;
-    readonly isCircle: boolean;
-    constructor(config?: Config);
-}

package/lib/shapes2/dummy.d.ts

@@ -1,19 +0,0 @@
-import { Shape2 } from '../objects/shape2';
-import { IBox2, IContext2D, IObject2, ITexture } from '../interfaces';
-/**
- * @TODO: 文字
- * @TODO: usedCache 开启缓存，相同 featureKey 的图形使用 texture，绘制时需先进行画布TRS
- * @TODO: separateCache 独立缓存，对于需要TRS的，保存独立 texture，渲染时直接 drawImage
- */
-export declare class Dummy extends Shape2 {
-    name: string;
-    readonly isDummy: boolean;
-    origin: IObject2;
-    texture: ITexture | undefined;
-    constructor(origin: IObject2);
-    /** overwrite */
-    computeBoundingBox(): IBox2;
-    /** overwrite */
-    render(ctx: IContext2D): void;
-    separateCache(): void;
-}

package/lib/shapes2/polygon.d.ts

@@ -1,9 +0,0 @@
-import { IShape2Config, Shape2 } from '../objects/shape2';
-export interface IPolygonConfig extends IShape2Config {
-}
-export declare class Polygon<Config extends IPolygonConfig> extends Shape2 {
-    readonly isPolygon: boolean;
-    type: string;
-    name: string;
-    constructor(config?: Config);
-}

package/lib/shapes2/svg.d.ts

@@ -1,18 +0,0 @@
-import { IContext2D, IPath2Command, IVector2 } from '../interfaces';
-import { IShape2Config, Shape2 } from '../objects/shape2';
-import { ITextMat2Config } from '../materials/text-mat2';
-export interface ISvgConfig extends IShape2Config, ITextMat2Config {
-    svg?: string;
-    size?: IVector2;
-    text?: string;
-}
-export declare class Svg<Config extends ISvgConfig> extends Shape2 {
-    readonly isSvg: boolean;
-    name: string;
-    matrixAutoUpdate: boolean;
-    composeNode: boolean;
-    alignCenter: boolean;
-    constructor(svg: string, config?: Config);
-    destroy(): void;
-    render(ctx: IContext2D, commands?: IPath2Command[]): void;
-}

package/lib/shapes2/text.d.ts

@@ -1,21 +0,0 @@
-import { default as Vector2 } from '../math/vector2';
-import { IBox2, IContext2D, IText2 } from '../interfaces';
-import { ITextMaterial2Config } from '../materials/text-material2';
-import { IShape2Config, Shape2 } from '../objects/shape2';
-import { TextMat2 } from '../materials/text-mat2';
-export interface ITextConfig extends IShape2Config, ITextMaterial2Config {
-    fixed?: boolean;
-    rotated?: number;
-}
-export declare class Text<Config extends ITextConfig> extends Shape2 implements IText2 {
-    readonly isText: boolean;
-    name: string;
-    mat: TextMat2<Config>;
-    textContent?: string;
-    size: Vector2;
-    constructor(config?: Config);
-    /** @override */
-    computeBoundingBox(): IBox2;
-    /** @override */
-    render(ctx: IContext2D): void;
-}

package/lib/svg/circle-element.d.ts

@@ -1,9 +0,0 @@
-import { Element } from './element';
-import { ISvgElement } from './interfaces';
-import { Path } from '../geometries/path';
-export declare class CircleElement extends Element {
-    type: string;
-    paths: Path[];
-    constructor(root: ISvgElement, node: any);
-    initPath(): void;
-}

package/lib/svg/defs-element.d.ts

@@ -1,6 +0,0 @@
-import { Element } from './element';
-import { ISvgElement } from './interfaces';
-export declare class DefsElement extends Element {
-    type: string;
-    constructor(root: ISvgElement, node: any);
-}

package/lib/svg/element.d.ts

@@ -1,32 +0,0 @@
-import { Property } from './property';
-import { IElement, IProperty, ISvgElement } from './interfaces';
-import { default as Matrix3 } from '../math/matrix3';
-export declare abstract class Element {
-    static readonly ignoreChildTypes: string[];
-    readonly type: string;
-    readonly definitions?: Record<string, Element>;
-    readonly attributes: Record<string, Property>;
-    styles: Record<string, Property>;
-    stylesSpecificity: Record<string, string>;
-    parent: Element | null;
-    children: Element[];
-    root: ISvgElement;
-    node: any;
-    protected constructor(root: ISvgElement | null, node: any);
-    get id(): string;
-    init(): void;
-    addAttributes(): void;
-    addStyle(): void;
-    addDefinitions(): void;
-    getStyle(name: string, createIfNotExists?: boolean, skipAncestors?: boolean): IProperty;
-    getAttribute(name: string, createIfNotExists?: boolean): Property;
-    getHrefAttribute(): IProperty;
-    add(node: Element | any): void;
-    traverse(callback: Function): void;
-    getById(id: string): IElement | undefined;
-    getByIds(ids: string[]): IElement[];
-    getByType(type: string): IElement | undefined;
-    getRotateRad(deg: number, flipX?: boolean): number;
-    getMatrix(): Matrix3;
-    protected matchesSelector(selector: string): boolean;
-}

package/lib/svg/elements.d.ts

@@ -1,25 +0,0 @@
-import { DefsElement } from './defs-element';
-import { StyleElement } from './style-element';
-import { UnknownElement } from './unknown-element';
-import { ViewElement } from './view-element';
-import { SymbolElement } from './symbol-element';
-import { PathElement } from './path-element';
-import { GElement } from './g-element';
-import { UseElement } from './use-element';
-import { CircleElement } from './circle-element';
-import { TextElement } from './text-element';
-export declare const ELEMENTS: {
-    view: typeof ViewElement;
-    defs: typeof DefsElement;
-    style: typeof StyleElement;
-    symbol: typeof SymbolElement;
-    path: typeof PathElement;
-    g: typeof GElement;
-    use: typeof UseElement;
-    circle: typeof CircleElement;
-    text: typeof TextElement;
-    unknown: typeof UnknownElement;
-};
-type SvgElements = typeof ELEMENTS;
-export type TSvgElement = SvgElements[keyof SvgElements];
-export {};

package/lib/svg/g-element.d.ts

@@ -1,6 +0,0 @@
-import { Element } from './element';
-import { ISvgElement } from './interfaces';
-export declare class GElement extends Element {
-    type: string;
-    constructor(root: ISvgElement, node: any);
-}

package/lib/svg/interfaces.d.ts

@@ -1,46 +0,0 @@
-import { SVGPathData } from 'svg-pathdata';
-import { Path } from '../geometries/path';
-import { Axis } from './property';
-import { IMatrix3 } from '../interfaces';
-export interface IProperty<T = unknown> {
-    isUrlDefinition(): boolean;
-    getDefinition<T extends IElement>(): T | undefined;
-    hasValue(zeroIsValue?: boolean): boolean;
-    split(separator?: string): IProperty[];
-    getPixels(axisOrIsFontSize?: Axis | boolean, processPercent?: boolean): number;
-    toString(def?: T): string;
-    getNumber(def?: T): number;
-}
-export interface IElement {
-    type: string;
-    attributes: Record<string, IProperty>;
-    styles: Record<string, IProperty>;
-    stylesSpecificity: Record<string, string>;
-    parent: IElement | null;
-    children: IElement[];
-    root: ISvgElement;
-    node: any;
-    add(node: IElement | any): void;
-    addStyle(): void;
-    getStyle(name: string, createIfNotExists?: boolean, skipAncestors?: boolean): IProperty;
-    getAttribute(name: string, createIfNotExists?: boolean): IProperty;
-    getHrefAttribute(): IProperty;
-    get id(): string;
-    getById(id: string): IElement | undefined;
-    getByIds(ids: string[]): IElement[];
-    getByType(type: string): IElement | undefined;
-    getMatrix(): IMatrix3;
-}
-export interface ISvgElement extends IElement {
-    definitions: Record<string, IElement>;
-    readonly rootEmSize: number;
-    readonly emSize: number;
-    createElement(node: any): IElement;
-}
-export interface IPathElement extends IElement {
-    pathData: SVGPathData;
-    paths: Path[];
-}
-export interface IUseElement extends IElement {
-    symbolId: string;
-}

package/lib/svg/path-element.d.ts

@@ -1,33 +0,0 @@
-import { Element } from './element';
-import { ISvgElement } from './interfaces';
-import { SVGPathData } from 'svg-pathdata';
-import { Path } from '../geometries/path';
-import { SVGCommand } from 'svg-pathdata/dist/types';
-import { IVector2 } from '../interfaces';
-export declare class PathElement extends Element {
-    type: string;
-    pathData?: SVGPathData;
-    paths: Path[];
-    private _i;
-    private _command?;
-    private _previousCommand?;
-    private _start;
-    private _control;
-    private _current;
-    private _ps;
-    private _angles;
-    constructor(root: ISvgElement, node: any);
-    initPaths(): void;
-    protected moveTo(out: Path): this;
-    protected lineTo(out: Path): this;
-    protected arc(out: Path): this;
-    protected closePath(out: Path): this;
-    _reset(): void;
-    _isEnd(): boolean;
-    _next(): SVGCommand;
-    _getAsCurrentPoint(xProp?: string, yProp?: string): IVector2;
-    _getPoint(xProp?: string, yProp?: string): IVector2;
-    _makeAbsolute(p: IVector2): IVector2;
-    _getAsControlPoint(xProp?: string, yProp?: string): IVector2;
-    _getReflectedControlPoint(): IVector2;
-}

package/lib/svg/property.d.ts

@@ -1,25 +0,0 @@
-import { IElement, IProperty, ISvgElement } from './interfaces';
-export declare class Property<T = unknown> implements IProperty {
-    private readonly root;
-    private readonly name;
-    private value;
-    static readonly textBaselineMapping: Record<string, string>;
-    constructor(root: ISvgElement, name: string, value: T);
-    static empty(root: ISvgElement): Property;
-    getDefinition<T extends IElement>(): T | undefined;
-    setValue(value: T): this;
-    getValue(def?: T): T;
-    hasValue(zeroIsValue?: boolean): boolean;
-    split(separator?: string): IProperty[];
-    isString(regexp?: RegExp): boolean;
-    isUrlDefinition(): boolean;
-    isPixels(): boolean;
-    getNumber(def?: T): number;
-    getPixels(axisOrIsFontSize?: Axis | boolean, processPercent?: boolean): number;
-    getDpi(): number;
-    getRem(): number;
-    getEm(): number;
-    getUnits(): string;
-    toString(def?: T): string;
-}
-export type Axis = 'x' | 'y';