tsparticles 1.40.2 → 1.41.3

package/umd/Plugins/PolygonMask/Enums/PolygonMaskMoveType.d.ts

@@ -0,0 +1,4 @@
+export declare const enum PolygonMaskMoveType {
+    path = "path",
+    radius = "radius"
+}

package/umd/Plugins/PolygonMask/Enums/PolygonMaskMoveType.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Plugins/PolygonMask/Enums/PolygonMaskType.d.ts

@@ -0,0 +1,6 @@
+export declare const enum PolygonMaskType {
+    inline = "inline",
+    inside = "inside",
+    outside = "outside",
+    none = "none"
+}

package/umd/Plugins/PolygonMask/Enums/PolygonMaskType.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Plugins/PolygonMask/Enums/index.d.ts

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

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

@@ -0,0 +1,25 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./PolygonMaskInlineArrangement", "./PolygonMaskMoveType", "./PolygonMaskType"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./PolygonMaskInlineArrangement"), exports);
+    __exportStar(require("./PolygonMaskMoveType"), exports);
+    __exportStar(require("./PolygonMaskType"), exports);
+});

package/umd/Plugins/PolygonMask/Interfaces/ISvgPath.d.ts

@@ -0,0 +1,6 @@
+import type { SVGPathElement } from "../pathseg";
+export interface ISvgPath {
+    element: SVGPathElement;
+    length: number;
+    path2d?: Path2D;
+}

package/umd/Plugins/PolygonMask/Interfaces/ISvgPath.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

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

@@ -0,0 +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 { PolygonMaskDraw } from "./PolygonMaskDraw";
+import { PolygonMaskInline } from "./PolygonMaskInline";
+import { PolygonMaskLocalSvg } from "./PolygonMaskLocalSvg";
+import { PolygonMaskMove } from "./PolygonMaskMove";
+import type { RecursivePartial } from "../../../../Types";
+export declare class PolygonMask implements IPolygonMask, IOptionLoader<IPolygonMask> {
+    get inlineArrangement(): PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    set inlineArrangement(value: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt);
+    draw: PolygonMaskDraw;
+    enable: boolean;
+    inline: PolygonMaskInline;
+    move: PolygonMaskMove;
+    position?: ICoordinates;
+    scale: number;
+    type: PolygonMaskType;
+    url?: string;
+    data?: string | PolygonMaskLocalSvg;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMask>): void;
+}

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

@@ -0,0 +1,76 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./PolygonMaskDraw", "./PolygonMaskInline", "./PolygonMaskLocalSvg", "./PolygonMaskMove", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMask = void 0;
+    const PolygonMaskDraw_1 = require("./PolygonMaskDraw");
+    const PolygonMaskInline_1 = require("./PolygonMaskInline");
+    const PolygonMaskLocalSvg_1 = require("./PolygonMaskLocalSvg");
+    const PolygonMaskMove_1 = require("./PolygonMaskMove");
+    const Utils_1 = require("../../../../Utils");
+    class PolygonMask {
+        constructor() {
+            this.draw = new PolygonMaskDraw_1.PolygonMaskDraw();
+            this.enable = false;
+            this.inline = new PolygonMaskInline_1.PolygonMaskInline();
+            this.move = new PolygonMaskMove_1.PolygonMaskMove();
+            this.scale = 1;
+            this.type = "none";
+        }
+        get inlineArrangement() {
+            return this.inline.arrangement;
+        }
+        set inlineArrangement(value) {
+            this.inline.arrangement = value;
+        }
+        load(data) {
+            var _a;
+            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.data = new PolygonMaskLocalSvg_1.PolygonMaskLocalSvg();
+                    this.data.load(data.data);
+                }
+            }
+            if (data.position !== undefined) {
+                this.position = (0, Utils_1.deepExtend)({}, data.position);
+            }
+        }
+    }
+    exports.PolygonMask = PolygonMask;
+});

package/umd/Plugins/PolygonMask/Options/Classes/PolygonMaskDraw.d.ts

@@ -0,0 +1,15 @@
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+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: PolygonMaskDrawStroke;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskDraw>): void;
+}

package/umd/Plugins/PolygonMask/Options/Classes/PolygonMaskDraw.js

@@ -0,0 +1,48 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../../../Options/Classes/OptionsColor", "./PolygonMaskDrawStroke"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMaskDraw = void 0;
+    const OptionsColor_1 = require("../../../../Options/Classes/OptionsColor");
+    const PolygonMaskDrawStroke_1 = require("./PolygonMaskDrawStroke");
+    class PolygonMaskDraw {
+        constructor() {
+            this.enable = false;
+            this.stroke = new PolygonMaskDrawStroke_1.PolygonMaskDrawStroke();
+        }
+        get lineWidth() {
+            return this.stroke.width;
+        }
+        set lineWidth(value) {
+            this.stroke.width = value;
+        }
+        get lineColor() {
+            return this.stroke.color;
+        }
+        set lineColor(value) {
+            this.stroke.color = OptionsColor_1.OptionsColor.create(this.stroke.color, value);
+        }
+        load(data) {
+            var _a;
+            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);
+        }
+    }
+    exports.PolygonMaskDraw = PolygonMaskDraw;
+});

package/umd/Plugins/PolygonMask/Options/Classes/PolygonMaskDrawStroke.d.ts

@@ -0,0 +1,11 @@
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+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<IPolygonMaskDrawStroke>): void;
+}

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

@@ -0,0 +1,39 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../../../Options/Classes/OptionsColor", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMaskDrawStroke = void 0;
+    const OptionsColor_1 = require("../../../../Options/Classes/OptionsColor");
+    const Utils_1 = require("../../../../Utils");
+    class PolygonMaskDrawStroke {
+        constructor() {
+            this.color = new OptionsColor_1.OptionsColor();
+            this.width = 0.5;
+            this.opacity = 1;
+        }
+        load(data) {
+            var _a;
+            if (!data) {
+                return;
+            }
+            this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            if (typeof this.color.value === "string") {
+                this.opacity = (_a = (0, Utils_1.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;
+            }
+        }
+    }
+    exports.PolygonMaskDrawStroke = PolygonMaskDrawStroke;
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Classes/PolygonMaskInline.js

@@ -0,0 +1,27 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMaskInline = void 0;
+    class PolygonMaskInline {
+        constructor() {
+            this.arrangement = "one-per-point";
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.arrangement !== undefined) {
+                this.arrangement = data.arrangement;
+            }
+        }
+    }
+    exports.PolygonMaskInline = PolygonMaskInline;
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Classes/PolygonMaskLocalSvg.js

@@ -0,0 +1,39 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMaskLocalSvg = void 0;
+    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;
+                }
+            }
+        }
+    }
+    exports.PolygonMaskLocalSvg = PolygonMaskLocalSvg;
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Classes/PolygonMaskMove.js

@@ -0,0 +1,31 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonMaskMove = void 0;
+    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;
+            }
+        }
+    }
+    exports.PolygonMaskMove = PolygonMaskMove;
+});

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

@@ -0,0 +1,18 @@
+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: IPolygonMaskDraw;
+    enable: boolean;
+    inline: IPolygonMaskInline;
+    inlineArrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    move: IPolygonMaskMove;
+    position?: ICoordinates;
+    scale: number;
+    type: PolygonMaskType;
+    url?: string;
+    data?: string | IPolygonMaskLocalSvg;
+}

package/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMask.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDraw.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDrawStroke.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskInline.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskLocalSvg.d.ts

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

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

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/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/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskMove.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskOptions.d.ts

@@ -0,0 +1,4 @@
+import type { IPolygonMask } from "./IPolygonMask";
+export interface IPolygonMaskOptions {
+    polygon: IPolygonMask;
+}

package/umd/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskOptions.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

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

@@ -0,0 +1,38 @@
+import type { Container, IContainerPlugin, ICoordinates, IDelta, IDimension, Particle } from "../../Core";
+import type { IPolygonMaskOptions } from "./Types";
+import type { ISvgPath } from "./Interfaces/ISvgPath";
+import { OutModeDirection } from "../../Enums";
+import { PolygonMask } from "./Options/Classes/PolygonMask";
+import type { RecursivePartial } from "../../Types";
+export declare class PolygonMaskInstance implements IContainerPlugin {
+    private readonly container;
+    redrawTimeout?: number;
+    raw?: ICoordinates[];
+    paths?: ISvgPath[];
+    dimension: IDimension;
+    offset?: ICoordinates;
+    readonly path2DSupported: boolean;
+    readonly options: PolygonMask;
+    private polygonMaskMoveRadius;
+    constructor(container: Container);
+    initAsync(options?: RecursivePartial<IPolygonMaskOptions>): Promise<void>;
+    resize(): void;
+    stop(): void;
+    particlesInitialization(): boolean;
+    particlePosition(position?: ICoordinates): ICoordinates | undefined;
+    particleBounce(particle: Particle, delta: IDelta, direction: OutModeDirection): boolean;
+    clickPositionValid(position: ICoordinates): boolean;
+    draw(context: CanvasRenderingContext2D): void;
+    private polygonBounce;
+    private checkInsidePolygon;
+    private parseSvgPath;
+    private downloadSvgPath;
+    private drawPoints;
+    private randomPoint;
+    private getRandomPoint;
+    private getRandomPointByLength;
+    private getEquidistantPointByIndex;
+    private getPointByIndex;
+    private createPath2D;
+    private initRawData;
+}