tsparticles 1.40.2 → 1.41.0

package/umd/Plugins/Emitters/Options/Classes/Emitter.js

@@ -0,0 +1,74 @@
+(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/AnimatableColor", "./EmitterLife", "./EmitterRate", "./EmitterSize", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Emitter = void 0;
+    const AnimatableColor_1 = require("../../../../Options/Classes/AnimatableColor");
+    const EmitterLife_1 = require("./EmitterLife");
+    const EmitterRate_1 = require("./EmitterRate");
+    const EmitterSize_1 = require("./EmitterSize");
+    const Utils_1 = require("../../../../Utils");
+    class Emitter {
+        constructor() {
+            this.autoPlay = true;
+            this.fill = true;
+            this.life = new EmitterLife_1.EmitterLife();
+            this.rate = new EmitterRate_1.EmitterRate();
+            this.shape = "square";
+            this.startCount = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.autoPlay !== undefined) {
+                this.autoPlay = data.autoPlay;
+            }
+            if (data.size !== undefined) {
+                if (this.size === undefined) {
+                    this.size = new EmitterSize_1.EmitterSize();
+                }
+                this.size.load(data.size);
+            }
+            if (data.direction !== undefined) {
+                this.direction = data.direction;
+            }
+            this.domId = data.domId;
+            if (data.fill !== undefined) {
+                this.fill = data.fill;
+            }
+            this.life.load(data.life);
+            this.name = data.name;
+            if (data.particles !== undefined) {
+                this.particles = (0, Utils_1.deepExtend)({}, data.particles);
+            }
+            this.rate.load(data.rate);
+            if (data.shape !== undefined) {
+                this.shape = data.shape;
+            }
+            if (data.position !== undefined) {
+                this.position = {
+                    x: data.position.x,
+                    y: data.position.y,
+                };
+            }
+            if (data.spawnColor !== undefined) {
+                if (this.spawnColor === undefined) {
+                    this.spawnColor = new AnimatableColor_1.AnimatableColor();
+                }
+                this.spawnColor.load(data.spawnColor);
+            }
+            if (data.startCount !== undefined) {
+                this.startCount = data.startCount;
+            }
+        }
+    }
+    exports.Emitter = Emitter;
+});

package/umd/Plugins/Emitters/Options/Classes/EmitterLife.d.ts

@@ -0,0 +1,11 @@
+import type { IEmitterLife } from "../Interfaces/IEmitterLife";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class EmitterLife implements IEmitterLife, IOptionLoader<IEmitterLife> {
+    count?: number;
+    delay?: number;
+    duration?: number;
+    wait: boolean;
+    constructor();
+    load(data?: RecursivePartial<IEmitterLife>): void;
+}

package/umd/Plugins/Emitters/Options/Classes/EmitterLife.js

@@ -0,0 +1,36 @@
+(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.EmitterLife = void 0;
+    class EmitterLife {
+        constructor() {
+            this.wait = false;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.count !== undefined) {
+                this.count = data.count;
+            }
+            if (data.delay !== undefined) {
+                this.delay = data.delay;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.wait !== undefined) {
+                this.wait = data.wait;
+            }
+        }
+    }
+    exports.EmitterLife = EmitterLife;
+});

package/umd/Plugins/Emitters/Options/Classes/EmitterRate.d.ts

@@ -0,0 +1,9 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
+import type { IEmitterRate } from "../Interfaces/IEmitterRate";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+export declare class EmitterRate implements IEmitterRate, IOptionLoader<IEmitterRate> {
+    quantity: RangeValue;
+    delay: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IEmitterRate>): void;
+}

package/umd/Plugins/Emitters/Options/Classes/EmitterRate.js

@@ -0,0 +1,32 @@
+(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", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EmitterRate = void 0;
+    const Utils_1 = require("../../../../Utils");
+    class EmitterRate {
+        constructor() {
+            this.quantity = 1;
+            this.delay = 0.1;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.quantity !== undefined) {
+                this.quantity = (0, Utils_1.setRangeValue)(data.quantity);
+            }
+            if (data.delay !== undefined) {
+                this.delay = (0, Utils_1.setRangeValue)(data.delay);
+            }
+        }
+    }
+    exports.EmitterRate = EmitterRate;
+});

package/umd/Plugins/Emitters/Options/Classes/EmitterSize.d.ts

@@ -0,0 +1,11 @@
+import type { IEmitterSize } from "../Interfaces/IEmitterSize";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+import { SizeMode } from "../../../../Enums";
+export declare class EmitterSize implements IEmitterSize, IOptionLoader<IEmitterSize> {
+    mode: SizeMode | keyof typeof SizeMode;
+    height: number;
+    width: number;
+    constructor();
+    load(data?: RecursivePartial<IEmitterSize>): void;
+}

package/umd/Plugins/Emitters/Options/Classes/EmitterSize.js

@@ -0,0 +1,35 @@
+(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.EmitterSize = void 0;
+    class EmitterSize {
+        constructor() {
+            this.mode = "percent";
+            this.height = 0;
+            this.width = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+            if (data.height !== undefined) {
+                this.height = data.height;
+            }
+            if (data.width !== undefined) {
+                this.width = data.width;
+            }
+        }
+    }
+    exports.EmitterSize = EmitterSize;
+});

package/umd/Plugins/Emitters/Options/Interfaces/IEmitter.d.ts

@@ -0,0 +1,24 @@
+import type { MoveDirection, MoveDirectionAlt } from "../../../../Enums";
+import type { EmitterShapeType } from "../../Enums";
+import type { IAnimatableColor } from "../../../../Options/Interfaces/IAnimatableColor";
+import type { ICoordinates } from "../../../../Core";
+import type { IEmitterLife } from "./IEmitterLife";
+import type { IEmitterRate } from "./IEmitterRate";
+import type { IEmitterSize } from "./IEmitterSize";
+import type { IParticles } from "../../../../Options/Interfaces/Particles/IParticles";
+import type { RecursivePartial } from "../../../../Types";
+export interface IEmitter {
+    autoPlay: boolean;
+    size?: IEmitterSize;
+    direction?: MoveDirection | keyof typeof MoveDirection | MoveDirectionAlt | number;
+    domId?: string;
+    fill: boolean;
+    life: IEmitterLife;
+    name?: string;
+    particles?: RecursivePartial<IParticles>;
+    position?: RecursivePartial<ICoordinates>;
+    rate: IEmitterRate;
+    shape: EmitterShapeType | keyof typeof EmitterShapeType;
+    spawnColor?: IAnimatableColor;
+    startCount: number;
+}

package/umd/Plugins/Emitters/Options/Interfaces/IEmitter.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/Emitters/Options/Interfaces/IEmitterLife.d.ts

@@ -0,0 +1,6 @@
+export interface IEmitterLife {
+    count?: number;
+    duration?: number;
+    delay?: number;
+    wait: boolean;
+}

package/umd/Plugins/Emitters/Options/Interfaces/IEmitterLife.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/Emitters/Options/Interfaces/IEmitterOptions.d.ts

@@ -0,0 +1,12 @@
+import type { IEmitter } from "./IEmitter";
+import type { IInteractivity } from "../../../../Options/Interfaces/Interactivity/IInteractivity";
+import type { IModes } from "../../../../Options/Interfaces/Interactivity/Modes/IModes";
+import type { SingleOrMultiple } from "../../../../Types";
+export interface IEmitterOptions {
+    emitters: SingleOrMultiple<IEmitter>;
+    interactivity: IInteractivity & {
+        modes: IModes & {
+            emitters: SingleOrMultiple<IEmitter>;
+        };
+    };
+}

package/umd/Plugins/Emitters/Options/Interfaces/IEmitterOptions.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/Emitters/Options/Interfaces/IEmitterRate.d.ts

@@ -0,0 +1,5 @@
+import type { RangeValue } from "../../../../Types";
+export interface IEmitterRate {
+    delay: RangeValue;
+    quantity: RangeValue;
+}

package/umd/Plugins/Emitters/Options/Interfaces/IEmitterRate.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/Emitters/Options/Interfaces/IEmitterSize.d.ts

@@ -0,0 +1,5 @@
+import type { IDimension } from "../../../../Core/Interfaces/IDimension";
+import type { SizeMode } from "../../../../Enums";
+export interface IEmitterSize extends IDimension {
+    mode: SizeMode | keyof typeof SizeMode;
+}

package/umd/Plugins/Emitters/Options/Interfaces/IEmitterSize.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/Emitters/ShapeManager.d.ts

@@ -0,0 +1,9 @@
+import type { Engine } from "../../engine";
+import type { IEmitterShape } from "./IEmitterShape";
+export declare class ShapeManager {
+    #private;
+    constructor(engine: Engine);
+    addShape(name: string, drawer: IEmitterShape): void;
+    getShape(name: string): IEmitterShape | undefined;
+    getSupportedShapes(): IterableIterator<string>;
+}

package/umd/Plugins/Emitters/ShapeManager.js

@@ -0,0 +1,40 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+(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";
+    var _ShapeManager_engine;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ShapeManager = void 0;
+    const shapes = new Map();
+    class ShapeManager {
+        constructor(engine) {
+            _ShapeManager_engine.set(this, void 0);
+            __classPrivateFieldSet(this, _ShapeManager_engine, engine, "f");
+        }
+        addShape(name, drawer) {
+            if (!this.getShape(name)) {
+                shapes.set(name, drawer);
+            }
+        }
+        getShape(name) {
+            return shapes.get(name);
+        }
+        getSupportedShapes() {
+            return shapes.keys();
+        }
+    }
+    exports.ShapeManager = ShapeManager;
+    _ShapeManager_engine = new WeakMap();
+});

package/umd/Plugins/Emitters/Shapes/Circle/CircleShape.d.ts

@@ -0,0 +1,5 @@
+import type { ICoordinates, IDimension } from "../../../../Core";
+import type { IEmitterShape } from "../../IEmitterShape";
+export declare class CircleShape implements IEmitterShape {
+    randomPosition(position: ICoordinates, size: IDimension, fill: boolean): ICoordinates;
+}

package/umd/Plugins/Emitters/Shapes/Circle/CircleShape.js

@@ -0,0 +1,42 @@
+(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.CircleShape = void 0;
+    class CircleShape {
+        randomPosition(position, size, fill) {
+            const generateTheta = (x, y) => {
+                const u = Math.random() / 4.0;
+                const theta = Math.atan((y / x) * Math.tan(2 * Math.PI * u));
+                const v = Math.random();
+                if (v < 0.25) {
+                    return theta;
+                }
+                else if (v < 0.5) {
+                    return Math.PI - theta;
+                }
+                else if (v < 0.75) {
+                    return Math.PI + theta;
+                }
+                else {
+                    return -theta;
+                }
+            };
+            const radius = (x, y, theta) => (x * y) / Math.sqrt((y * Math.cos(theta)) ** 2 + (x * Math.sin(theta)) ** 2);
+            const [a, b] = [size.width / 2, size.height / 2];
+            const randomTheta = generateTheta(a, b), maxRadius = radius(a, b, randomTheta), randomRadius = fill ? maxRadius * Math.sqrt(Math.random()) : maxRadius;
+            return {
+                x: position.x + randomRadius * Math.cos(randomTheta),
+                y: position.y + randomRadius * Math.sin(randomTheta),
+            };
+        }
+    }
+    exports.CircleShape = CircleShape;
+});

package/umd/Plugins/Emitters/Shapes/Square/SquareShape.d.ts

@@ -0,0 +1,5 @@
+import type { ICoordinates, IDimension } from "../../../../Core";
+import type { IEmitterShape } from "../../IEmitterShape";
+export declare class SquareShape implements IEmitterShape {
+    randomPosition(position: ICoordinates, size: IDimension, fill: boolean): ICoordinates;
+}

package/umd/Plugins/Emitters/Shapes/Square/SquareShape.js

@@ -0,0 +1,53 @@
+(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.SquareShape = void 0;
+    function randomSquareCoordinate(position, offset) {
+        return position + offset * (Math.random() - 0.5);
+    }
+    class SquareShape {
+        randomPosition(position, size, fill) {
+            if (fill) {
+                return {
+                    x: randomSquareCoordinate(position.x, size.width),
+                    y: randomSquareCoordinate(position.y, size.height),
+                };
+            }
+            else {
+                const halfW = size.width / 2, halfH = size.height / 2, side = Math.floor(Math.random() * 4), v = (Math.random() - 0.5) * 2;
+                switch (side) {
+                    case 0:
+                        return {
+                            x: position.x + v * halfW,
+                            y: position.y - halfH,
+                        };
+                    case 1:
+                        return {
+                            x: position.x - halfW,
+                            y: position.y + v * halfH,
+                        };
+                    case 2:
+                        return {
+                            x: position.x + v * halfW,
+                            y: position.y + halfH,
+                        };
+                    case 3:
+                    default:
+                        return {
+                            x: position.x + halfW,
+                            y: position.y + v * halfH,
+                        };
+                }
+            }
+        }
+    }
+    exports.SquareShape = SquareShape;
+});

package/umd/Plugins/Emitters/index.d.ts

@@ -0,0 +1,3 @@
+import { EmittersEngine } from "./EmittersEngine";
+export declare function loadEmittersPlugin(engine: EmittersEngine): Promise<void>;
+export * from "./EmittersEngine";

package/umd/Plugins/Emitters/index.js

@@ -0,0 +1,120 @@
+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);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+(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", "./Shapes/Circle/CircleShape", "./Options/Classes/Emitter", "./Emitters", "./ShapeManager", "./Shapes/Square/SquareShape", "../../Utils", "./EmittersEngine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var _EmittersPlugin_engine;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadEmittersPlugin = void 0;
+    const CircleShape_1 = require("./Shapes/Circle/CircleShape");
+    const Emitter_1 = require("./Options/Classes/Emitter");
+    const Emitters_1 = require("./Emitters");
+    const ShapeManager_1 = require("./ShapeManager");
+    const SquareShape_1 = require("./Shapes/Square/SquareShape");
+    const Utils_1 = require("../../Utils");
+    class EmittersPlugin {
+        constructor(engine) {
+            _EmittersPlugin_engine.set(this, void 0);
+            __classPrivateFieldSet(this, _EmittersPlugin_engine, engine, "f");
+            this.id = "emitters";
+        }
+        getPlugin(container) {
+            return new Emitters_1.Emitters(__classPrivateFieldGet(this, _EmittersPlugin_engine, "f"), container);
+        }
+        needsPlugin(options) {
+            var _a, _b, _c;
+            if (options === undefined) {
+                return false;
+            }
+            const emitters = options.emitters;
+            return ((emitters instanceof Array && !!emitters.length) ||
+                emitters !== undefined ||
+                (!!((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+                    (0, Utils_1.isInArray)("emitter", options.interactivity.events.onClick.mode)));
+        }
+        loadOptions(options, source) {
+            var _a, _b;
+            if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+                return;
+            }
+            const optionsCast = options;
+            if (source === null || source === void 0 ? void 0 : source.emitters) {
+                if ((source === null || source === void 0 ? void 0 : source.emitters) instanceof Array) {
+                    optionsCast.emitters = source === null || source === void 0 ? void 0 : source.emitters.map((s) => {
+                        const tmp = new Emitter_1.Emitter();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    let emitterOptions = optionsCast.emitters;
+                    if ((emitterOptions === null || emitterOptions === void 0 ? void 0 : emitterOptions.load) === undefined) {
+                        optionsCast.emitters = emitterOptions = new Emitter_1.Emitter();
+                    }
+                    emitterOptions.load(source === null || source === void 0 ? void 0 : source.emitters);
+                }
+            }
+            const interactivityEmitters = (_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.emitters;
+            if (interactivityEmitters) {
+                if (interactivityEmitters instanceof Array) {
+                    optionsCast.interactivity.modes.emitters = interactivityEmitters.map((s) => {
+                        const tmp = new Emitter_1.Emitter();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    let emitterOptions = optionsCast.interactivity.modes.emitters;
+                    if ((emitterOptions === null || emitterOptions === void 0 ? void 0 : emitterOptions.load) === undefined) {
+                        optionsCast.interactivity.modes.emitters = emitterOptions = new Emitter_1.Emitter();
+                    }
+                    emitterOptions.load(interactivityEmitters);
+                }
+            }
+        }
+    }
+    _EmittersPlugin_engine = new WeakMap();
+    async function loadEmittersPlugin(engine) {
+        if (!engine.emitterShapeManager) {
+            engine.emitterShapeManager = new ShapeManager_1.ShapeManager(engine);
+        }
+        if (!engine.addEmitterShape) {
+            engine.addEmitterShape = (name, shape) => {
+                var _a;
+                (_a = engine.emitterShapeManager) === null || _a === void 0 ? void 0 : _a.addShape(name, shape);
+            };
+        }
+        const plugin = new EmittersPlugin(engine);
+        await engine.addPlugin(plugin);
+        engine.addEmitterShape("circle", new CircleShape_1.CircleShape());
+        engine.addEmitterShape("square", new SquareShape_1.SquareShape());
+    }
+    exports.loadEmittersPlugin = loadEmittersPlugin;
+    __exportStar(require("./EmittersEngine"), exports);
+});

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

@@ -0,0 +1,8 @@
+export declare const enum PolygonMaskInlineArrangement {
+    equidistant = "equidistant",
+    onePerPoint = "one-per-point",
+    perPoint = "per-point",
+    randomLength = "random-length",
+    randomPoint = "random-point"
+}
+export declare type PolygonMaskInlineArrangementAlt = "one-per-point" | "per-point" | "random-length" | "random-point";

package/umd/Plugins/PolygonMask/Enums/PolygonMaskInlineArrangement.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 });
+});