tsparticles 1.37.6 → 1.39.2

package/esm/Plugins/PolygonMask/Enums/index.js

@@ -1,3 +1,3 @@
-export * from "./InlineArrangement";
-export * from "./MoveType";
-export * from "./Type";
+export * from "./PolygonMaskInlineArrangement";
+export * from "./PolygonMaskMoveType";
+export * from "./PolygonMaskType";

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMask.d.ts

@@ -1,24 +1,24 @@
+import { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt, PolygonMaskType } from "../../Enums";
+import type { ICoordinates } from "../../../../Core";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
 import type { IPolygonMask } from "../Interfaces/IPolygonMask";
-import { InlineArrangement, InlineArrangementAlt, Type } from "../../Enums";
-import { Draw } from "./Draw";
-import { Move } from "./Move";
-import { Inline } from "./Inline";
+import { PolygonMaskDraw } from "./PolygonMaskDraw";
+import { PolygonMaskInline } from "./PolygonMaskInline";
+import { PolygonMaskLocalSvg } from "./PolygonMaskLocalSvg";
+import { PolygonMaskMove } from "./PolygonMaskMove";
 import type { RecursivePartial } from "../../../../Types";
-import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
-import { LocalSvg } from "./LocalSvg";
-import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
 export declare class PolygonMask implements IPolygonMask, IOptionLoader<IPolygonMask> {
-    get inlineArrangement(): InlineArrangement | keyof typeof InlineArrangement | InlineArrangementAlt;
-    set inlineArrangement(value: InlineArrangement | keyof typeof InlineArrangement | InlineArrangementAlt);
-    draw: Draw;
+    get inlineArrangement(): PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    set inlineArrangement(value: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt);
+    draw: PolygonMaskDraw;
     enable: boolean;
-    inline: Inline;
-    move: Move;
+    inline: PolygonMaskInline;
+    move: PolygonMaskMove;
     position?: ICoordinates;
     scale: number;
-    type: Type;
+    type: PolygonMaskType;
     url?: string;
-    data?: string | LocalSvg;
+    data?: string | PolygonMaskLocalSvg;
     constructor();
     load(data?: RecursivePartial<IPolygonMask>): void;
 }

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMask.js

@@ -1,17 +1,16 @@
-import { Type } from "../../Enums";
-import { Draw } from "./Draw";
-import { Move } from "./Move";
-import { Inline } from "./Inline";
-import { LocalSvg } from "./LocalSvg";
+import { PolygonMaskDraw } from "./PolygonMaskDraw";
+import { PolygonMaskInline } from "./PolygonMaskInline";
+import { PolygonMaskLocalSvg } from "./PolygonMaskLocalSvg";
+import { PolygonMaskMove } from "./PolygonMaskMove";
 import { deepExtend } from "../../../../Utils";
 export class PolygonMask {
     constructor() {
-        this.draw = new Draw();
+        this.draw = new PolygonMaskDraw();
         this.enable = false;
-        this.inline = new Inline();
-        this.move = new Move();
+        this.inline = new PolygonMaskInline();
+        this.move = new PolygonMaskMove();
         this.scale = 1;
-        this.type = Type.none;
+        this.type = "none";
     }
     get inlineArrangement() {
         return this.inline.arrangement;
@@ -21,42 +20,43 @@ export class PolygonMask {
     }
     load(data) {
         var _a;
-        if (data !== undefined) {
-            this.draw.load(data.draw);
-            const inline = (_a = data.inline) !== null && _a !== void 0 ? _a : {
-                arrangement: data.inlineArrangement,
-            };
-            if (inline !== undefined) {
-                this.inline.load(inline);
-            }
-            this.move.load(data.move);
-            if (data.scale !== undefined) {
-                this.scale = data.scale;
-            }
-            if (data.type !== undefined) {
-                this.type = data.type;
-            }
-            if (data.enable !== undefined) {
-                this.enable = data.enable;
+        if (!data) {
+            return;
+        }
+        this.draw.load(data.draw);
+        const inline = (_a = data.inline) !== null && _a !== void 0 ? _a : {
+            arrangement: data.inlineArrangement,
+        };
+        if (inline !== undefined) {
+            this.inline.load(inline);
+        }
+        this.move.load(data.move);
+        if (data.scale !== undefined) {
+            this.scale = data.scale;
+        }
+        if (data.type !== undefined) {
+            this.type = data.type;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        else {
+            this.enable = this.type !== "none";
+        }
+        if (data.url !== undefined) {
+            this.url = data.url;
+        }
+        if (data.data !== undefined) {
+            if (typeof data.data === "string") {
+                this.data = data.data;
             }
             else {
-                this.enable = this.type !== Type.none;
-            }
-            if (data.url !== undefined) {
-                this.url = data.url;
-            }
-            if (data.data !== undefined) {
-                if (typeof data.data === "string") {
-                    this.data = data.data;
-                }
-                else {
-                    this.data = new LocalSvg();
-                    this.data.load(data.data);
-                }
-            }
-            if (data.position !== undefined) {
-                this.position = deepExtend({}, data.position);
+                this.data = new PolygonMaskLocalSvg();
+                this.data.load(data.data);
             }
         }
+        if (data.position !== undefined) {
+            this.position = deepExtend({}, data.position);
+        }
     }
 }

package/esm/Plugins/PolygonMask/Options/Classes/{Draw.d.ts → PolygonMaskDraw.d.ts}

@@ -1,15 +1,15 @@
-import type { IDraw } from "../Interfaces/IDraw";
-import { DrawStroke } from "./DrawStroke";
-import type { RecursivePartial } from "../../../../Types";
-import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
 import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
-export declare class Draw implements IDraw, IOptionLoader<IDraw> {
+import type { IPolygonMaskDraw } from "../Interfaces/IPolygonMaskDraw";
+import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
+import { PolygonMaskDrawStroke } from "./PolygonMaskDrawStroke";
+import type { RecursivePartial } from "../../../../Types";
+export declare class PolygonMaskDraw implements IPolygonMaskDraw, IOptionLoader<IPolygonMaskDraw> {
     get lineWidth(): number;
     set lineWidth(value: number);
     get lineColor(): string | OptionsColor;
     set lineColor(value: string | OptionsColor);
     enable: boolean;
-    stroke: DrawStroke;
+    stroke: PolygonMaskDrawStroke;
     constructor();
-    load(data?: RecursivePartial<IDraw>): void;
+    load(data?: RecursivePartial<IPolygonMaskDraw>): void;
 }

package/esm/Plugins/PolygonMask/Options/Classes/{Draw.js → PolygonMaskDraw.js}

@@ -1,9 +1,9 @@
-import { DrawStroke } from "./DrawStroke";
 import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
-export class Draw {
+import { PolygonMaskDrawStroke } from "./PolygonMaskDrawStroke";
+export class PolygonMaskDraw {
     constructor() {
         this.enable = false;
-        this.stroke = new DrawStroke();
+        this.stroke = new PolygonMaskDrawStroke();
     }
     get lineWidth() {
         return this.stroke.width;
@@ -19,15 +19,16 @@ export class Draw {
     }
     load(data) {
         var _a;
-        if (data !== undefined) {
-            if (data.enable !== undefined) {
-                this.enable = data.enable;
-            }
-            const stroke = (_a = data.stroke) !== null && _a !== void 0 ? _a : {
-                color: data.lineColor,
-                width: data.lineWidth,
-            };
-            this.stroke.load(stroke);
+        if (!data) {
+            return;
         }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        const stroke = (_a = data.stroke) !== null && _a !== void 0 ? _a : {
+            color: data.lineColor,
+            width: data.lineWidth,
+        };
+        this.stroke.load(stroke);
     }
 }

package/esm/Plugins/PolygonMask/Options/Classes/{DrawStroke.d.ts → PolygonMaskDrawStroke.d.ts}

@@ -1,11 +1,11 @@
-import type { IDrawStroke } from "../Interfaces/IDrawStroke";
-import type { RecursivePartial } from "../../../../Types";
-import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
 import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
-export declare class DrawStroke implements IDrawStroke, IOptionLoader<IDrawStroke> {
+import type { IPolygonMaskDrawStroke } from "../Interfaces/IPolygonMaskDrawStroke";
+import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
+import type { RecursivePartial } from "../../../../Types";
+export declare class PolygonMaskDrawStroke implements IPolygonMaskDrawStroke, IOptionLoader<IPolygonMaskDrawStroke> {
     color: OptionsColor;
     width: number;
     opacity: number;
     constructor();
-    load(data?: RecursivePartial<IDrawStroke>): void;
+    load(data?: RecursivePartial<IPolygonMaskDrawStroke>): void;
 }

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskDrawStroke.js

@@ -0,0 +1,25 @@
+import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
+import { stringToAlpha } from "../../../../Utils";
+export class PolygonMaskDrawStroke {
+    constructor() {
+        this.color = new OptionsColor();
+        this.width = 0.5;
+        this.opacity = 1;
+    }
+    load(data) {
+        var _a;
+        if (!data) {
+            return;
+        }
+        this.color = OptionsColor.create(this.color, data.color);
+        if (typeof this.color.value === "string") {
+            this.opacity = (_a = stringToAlpha(this.color.value)) !== null && _a !== void 0 ? _a : this.opacity;
+        }
+        if (data.opacity !== undefined) {
+            this.opacity = data.opacity;
+        }
+        if (data.width !== undefined) {
+            this.width = data.width;
+        }
+    }
+}

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskInline.d.ts

@@ -0,0 +1,9 @@
+import { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt } from "../../Enums";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { IPolygonMaskInline } from "../Interfaces/IPolygonMaskInline";
+import type { RecursivePartial } from "../../../../Types";
+export declare class PolygonMaskInline implements IPolygonMaskInline, IOptionLoader<IPolygonMaskInline> {
+    arrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskInline>): void;
+}

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskInline.js

@@ -0,0 +1,13 @@
+export class PolygonMaskInline {
+    constructor() {
+        this.arrangement = "one-per-point";
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.arrangement !== undefined) {
+            this.arrangement = data.arrangement;
+        }
+    }
+}

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskLocalSvg.d.ts

@@ -0,0 +1,11 @@
+import type { IDimension } from "../../../../Core";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { IPolygonMaskLocalSvg } from "../Interfaces/IPolygonMaskLocalSvg";
+import type { RecursivePartial } from "../../../../Types";
+import type { SingleOrMultiple } from "../../../../Types";
+export declare class PolygonMaskLocalSvg implements IPolygonMaskLocalSvg, IOptionLoader<IPolygonMaskLocalSvg> {
+    path: SingleOrMultiple<string>;
+    size: IDimension;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskLocalSvg>): void;
+}

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskLocalSvg.js

@@ -0,0 +1,25 @@
+export class PolygonMaskLocalSvg {
+    constructor() {
+        this.path = [];
+        this.size = {
+            height: 0,
+            width: 0,
+        };
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.path !== undefined) {
+            this.path = data.path;
+        }
+        if (data.size !== undefined) {
+            if (data.size.width !== undefined) {
+                this.size.width = data.size.width;
+            }
+            if (data.size.height !== undefined) {
+                this.size.height = data.size.height;
+            }
+        }
+    }
+}

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskMove.d.ts

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { IPolygonMaskMove } from "../Interfaces/IPolygonMaskMove";
+import { PolygonMaskMoveType } from "../../Enums";
+import type { RecursivePartial } from "../../../../Types";
+export declare class PolygonMaskMove implements IPolygonMaskMove, IOptionLoader<IPolygonMaskMove> {
+    radius: number;
+    type: PolygonMaskMoveType | keyof typeof PolygonMaskMoveType;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskMove>): void;
+}

package/esm/Plugins/PolygonMask/Options/Classes/PolygonMaskMove.js

@@ -0,0 +1,17 @@
+export class PolygonMaskMove {
+    constructor() {
+        this.radius = 10;
+        this.type = "path";
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.radius !== undefined) {
+            this.radius = data.radius;
+        }
+        if (data.type !== undefined) {
+            this.type = data.type;
+        }
+    }
+}

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMask.d.ts

@@ -1,19 +1,18 @@
-import type { IDraw } from "./IDraw";
-import type { IMove } from "./IMove";
-import type { InlineArrangement, InlineArrangementAlt } from "../../Enums";
-import type { IInline } from "./IInline";
-import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
-import type { ILocalSvg } from "./ILocalSvg";
-import { Type } from "../../Enums";
+import type { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt, PolygonMaskType } from "../../Enums";
+import type { ICoordinates } from "../../../../Core";
+import type { IPolygonMaskDraw } from "./IPolygonMaskDraw";
+import type { IPolygonMaskInline } from "./IPolygonMaskInline";
+import type { IPolygonMaskLocalSvg } from "./IPolygonMaskLocalSvg";
+import type { IPolygonMaskMove } from "./IPolygonMaskMove";
 export interface IPolygonMask {
-    draw: IDraw;
+    draw: IPolygonMaskDraw;
     enable: boolean;
-    inline: IInline;
-    inlineArrangement: InlineArrangement | keyof typeof InlineArrangement | InlineArrangementAlt;
-    move: IMove;
+    inline: IPolygonMaskInline;
+    inlineArrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    move: IPolygonMaskMove;
     position?: ICoordinates;
     scale: number;
-    type: Type;
+    type: PolygonMaskType;
     url?: string;
-    data?: string | ILocalSvg;
+    data?: string | IPolygonMaskLocalSvg;
 }

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDraw.d.ts

@@ -0,0 +1,8 @@
+import type { IColor } from "../../../../Core";
+import type { IPolygonMaskDrawStroke } from "./IPolygonMaskDrawStroke";
+export interface IPolygonMaskDraw {
+    enable: boolean;
+    lineColor: string | IColor;
+    lineWidth: number;
+    stroke: IPolygonMaskDrawStroke;
+}

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDraw.js

@@ -0,0 +1 @@
+export {};

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDrawStroke.d.ts

@@ -0,0 +1,6 @@
+import type { IColor } from "../../../../Core";
+export interface IPolygonMaskDrawStroke {
+    color: string | IColor;
+    width: number;
+    opacity: number;
+}

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDrawStroke.js

@@ -0,0 +1 @@
+export {};

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskInline.d.ts

@@ -0,0 +1,4 @@
+import type { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt } from "../../Enums";
+export interface IPolygonMaskInline {
+    arrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+}

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskInline.js

@@ -0,0 +1 @@
+export {};

package/esm/Plugins/PolygonMask/Options/Interfaces/{ILocalSvg.d.ts → IPolygonMaskLocalSvg.d.ts}

@@ -1,6 +1,6 @@
+import type { IDimension } from "../../../../Core";
 import type { SingleOrMultiple } from "../../../../Types";
-import type { IDimension } from "../../../../Core/Interfaces/IDimension";
-export interface ILocalSvg {
+export interface IPolygonMaskLocalSvg {
     path: SingleOrMultiple<string>;
     size: IDimension;
 }

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskLocalSvg.js

@@ -0,0 +1 @@
+export {};

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskMove.d.ts

@@ -0,0 +1,5 @@
+import type { PolygonMaskMoveType } from "../../Enums";
+export interface IPolygonMaskMove {
+    radius: number;
+    type: PolygonMaskMoveType | keyof typeof PolygonMaskMoveType;
+}

package/esm/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskMove.js

@@ -0,0 +1 @@
+export {};

package/esm/Plugins/PolygonMask/PolygonMaskInstance.d.ts

@@ -1,11 +1,9 @@
-import type { Container } from "../../Core/Container";
-import type { IContainerPlugin, ICoordinates, IDelta, IDimension } from "../../Core/Interfaces";
-import { Particle } from "../../Core/Particle";
+import type { Container, IContainerPlugin, ICoordinates, IDelta, IDimension, Particle } from "../../Core";
+import type { IPolygonMaskOptions } from "./Types";
 import type { ISvgPath } from "./Interfaces/ISvgPath";
-import type { RecursivePartial } from "../../Types";
-import { PolygonMask } from "./Options/Classes/PolygonMask";
 import { OutModeDirection } from "../../Enums";
-import type { IPolygonMaskOptions } from "./types";
+import { PolygonMask } from "./Options/Classes/PolygonMask";
+import type { RecursivePartial } from "../../Types";
 export declare class PolygonMaskInstance implements IContainerPlugin {
     private readonly container;
     redrawTimeout?: number;

package/esm/Plugins/PolygonMask/PolygonMaskInstance.js

@@ -1,8 +1,7 @@
-import { InlineArrangement, Type } from "./Enums";
-import { Constants, deepExtend, getDistance, getDistances, itemFromArray } from "../../Utils";
+import { calcClosestPtOnSegment, drawPolygonMask, drawPolygonMaskPath, parsePaths, segmentBounce } from "./Utils";
+import { deepExtend, getDistance, getDistances, itemFromArray } from "../../Utils";
+import { Constants } from "../../Core";
 import { PolygonMask } from "./Options/Classes/PolygonMask";
-import { OutModeDirection } from "../../Enums";
-import { calcClosestPtOnSegment, drawPolygonMask, drawPolygonMaskPath, parsePaths, segmentBounce } from "./utils";
 export class PolygonMaskInstance {
     constructor(container) {
         this.container = container;
@@ -25,7 +24,7 @@ export class PolygonMaskInstance {
     resize() {
         const container = this.container;
         const options = this.options;
-        if (!(options.enable && options.type !== Type.none)) {
+        if (!(options.enable && options.type !== "none")) {
             return;
         }
         if (this.redrawTimeout) {
@@ -43,9 +42,9 @@ export class PolygonMaskInstance {
     particlesInitialization() {
         const options = this.options;
         if (options.enable &&
-            options.type === Type.inline &&
-            (options.inline.arrangement === InlineArrangement.onePerPoint ||
-                options.inline.arrangement === InlineArrangement.perPoint)) {
+            options.type === "inline" &&
+            (options.inline.arrangement === "one-per-point" ||
+                options.inline.arrangement === "per-point")) {
             this.drawPoints();
             return true;
         }
@@ -65,8 +64,8 @@ export class PolygonMaskInstance {
     clickPositionValid(position) {
         const options = this.options;
         return (options.enable &&
-            options.type !== Type.none &&
-            options.type !== Type.inline &&
+            options.type !== "none" &&
+            options.type !== "inline" &&
             this.checkInsidePolygon(position));
     }
     draw(context) {
@@ -96,10 +95,10 @@ export class PolygonMaskInstance {
     }
     polygonBounce(particle, _delta, direction) {
         const options = this.options;
-        if (!this.raw || !options.enable || direction !== OutModeDirection.top) {
+        if (!this.raw || !options.enable || direction !== "top") {
             return false;
         }
-        if (options.type === Type.inside || options.type === Type.outside) {
+        if (options.type === "inside" || options.type === "outside") {
             let closest, dx, dy;
             const pos = particle.getPosition(), radius = particle.getRadius();
             for (let i = 0, j = this.raw.length - 1; i < this.raw.length; j = i++) {
@@ -126,7 +125,7 @@ export class PolygonMaskInstance {
                 return true;
             }
         }
-        else if (options.type === Type.inline && particle.initialPosition) {
+        else if (options.type === "inline" && particle.initialPosition) {
             const dist = getDistance(particle.initialPosition, particle.getPosition());
             if (dist > this.polygonMaskMoveRadius) {
                 particle.velocity.x = particle.velocity.y / 2 - particle.velocity.x;
@@ -140,7 +139,7 @@ export class PolygonMaskInstance {
         var _a, _b;
         const container = this.container;
         const options = this.options;
-        if (!options.enable || options.type === Type.none || options.type === Type.inline) {
+        if (!options.enable || options.type === "none" || options.type === "inline") {
             return true;
         }
         if (!this.raw) {
@@ -158,7 +157,11 @@ export class PolygonMaskInstance {
                 inside = !inside;
             }
         }
-        return options.type === Type.inside ? inside : options.type === Type.outside ? !inside : false;
+        return options.type === "inside"
+            ? inside
+            : options.type === "outside"
+                ? !inside
+                : false;
     }
     parseSvgPath(xml, force) {
         var _a, _b, _c;
@@ -227,19 +230,19 @@ export class PolygonMaskInstance {
         const container = this.container;
         const options = this.options;
         let position;
-        if (options.type === Type.inline) {
+        if (options.type === "inline") {
             switch (options.inline.arrangement) {
-                case InlineArrangement.randomPoint:
+                case "random-point":
                     position = this.getRandomPoint();
                     break;
-                case InlineArrangement.randomLength:
+                case "random-length":
                     position = this.getRandomPointByLength();
                     break;
-                case InlineArrangement.equidistant:
+                case "equidistant":
                     position = this.getEquidistantPointByIndex(container.particles.count);
                     break;
-                case InlineArrangement.onePerPoint:
-                case InlineArrangement.perPoint:
+                case "one-per-point":
+                case "per-point":
                 default:
                     position = this.getPointByIndex(container.particles.count);
             }

package/{browser/Plugins/PolygonMask/types.d.ts → esm/Plugins/PolygonMask/Types.d.ts}

@@ -1,6 +1,6 @@
+import type { SVGPathSegArcAbs, SVGPathSegArcRel, SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicRel, SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoCubicSmoothRel, SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticRel, SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegCurvetoQuadraticSmoothRel, SVGPathSegLinetoAbs, SVGPathSegLinetoRel, SVGPathSegMovetoAbs, SVGPathSegMovetoRel } from "./pathseg";
 import type { IOptions } from "../../Options/Interfaces/IOptions";
 import type { IPolygonMask } from "./Options/Interfaces/IPolygonMask";
-import type { SVGPathSegArcAbs, SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegLinetoAbs, SVGPathSegMovetoAbs, SVGPathSegArcRel, SVGPathSegCurvetoCubicRel, SVGPathSegCurvetoCubicSmoothRel, SVGPathSegCurvetoQuadraticRel, SVGPathSegCurvetoQuadraticSmoothRel, SVGPathSegLinetoRel, SVGPathSegMovetoRel } from "./pathseg";
 export declare type SvgAbsoluteCoordinatesTypes = SVGPathSegArcAbs | SVGPathSegCurvetoCubicAbs | SVGPathSegCurvetoCubicSmoothAbs | SVGPathSegCurvetoQuadraticAbs | SVGPathSegCurvetoQuadraticSmoothAbs | SVGPathSegLinetoAbs | SVGPathSegMovetoAbs;
 export declare type SvgRelativeCoordinatesTypes = SVGPathSegArcRel | SVGPathSegCurvetoCubicRel | SVGPathSegCurvetoCubicSmoothRel | SVGPathSegCurvetoQuadraticRel | SVGPathSegCurvetoQuadraticSmoothRel | SVGPathSegLinetoRel | SVGPathSegMovetoRel;
 export declare type IPolygonMaskOptions = IOptions & {

package/esm/Plugins/PolygonMask/Types.js

@@ -0,0 +1 @@
+export {};

package/{browser/Plugins/PolygonMask/utils.d.ts → esm/Plugins/PolygonMask/Utils.d.ts}

@@ -1,9 +1,9 @@
-import type { ICoordinates } from "../../Core/Interfaces";
-import type { IDrawStroke } from "./Options/Interfaces/IDrawStroke";
+import type { ICoordinates } from "../../Core";
+import type { IPolygonMaskDrawStroke } from "./Options/Interfaces/IPolygonMaskDrawStroke";
 import type { ISvgPath } from "./Interfaces/ISvgPath";
-import { Vector } from "../../Core/Particle/Vector";
-export declare function drawPolygonMask(context: CanvasRenderingContext2D, rawData: ICoordinates[], stroke: IDrawStroke): void;
-export declare function drawPolygonMaskPath(context: CanvasRenderingContext2D, path: Path2D, stroke: IDrawStroke, position: ICoordinates): void;
+import { Vector } from "../../Core";
+export declare function drawPolygonMask(context: CanvasRenderingContext2D, rawData: ICoordinates[], stroke: IPolygonMaskDrawStroke): void;
+export declare function drawPolygonMaskPath(context: CanvasRenderingContext2D, path: Path2D, stroke: IPolygonMaskDrawStroke, position: ICoordinates): void;
 export declare function parsePaths(paths: ISvgPath[], scale: number, offset: ICoordinates): ICoordinates[];
 export declare function calcClosestPtOnSegment(s1: ICoordinates, s2: ICoordinates, pos: ICoordinates): ICoordinates & {
     isOnSegment: boolean;