tsparticles 1.40.2 → 1.41.3

package/umd/Shapes/Square/index.js

@@ -0,0 +1,20 @@
+(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", "./SquareDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadSquareShape = void 0;
+    const SquareDrawer_1 = require("./SquareDrawer");
+    async function loadSquareShape(engine) {
+        const drawer = new SquareDrawer_1.SquareDrawer();
+        await engine.addShape("edge", drawer);
+        await engine.addShape("square", drawer);
+    }
+    exports.loadSquareShape = loadSquareShape;
+});

package/umd/Shapes/Star/StarDrawer.d.ts

@@ -0,0 +1,5 @@
+import type { IParticle, IShapeDrawer } from "../../Core";
+export declare class StarDrawer implements IShapeDrawer {
+    getSidesCount(particle: IParticle): number;
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}

package/umd/Shapes/Star/StarDrawer.js

@@ -0,0 +1,34 @@
+(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.StarDrawer = void 0;
+    class StarDrawer {
+        getSidesCount(particle) {
+            var _a, _b;
+            const star = particle.shapeData;
+            return (_b = (_a = star === null || star === void 0 ? void 0 : star.sides) !== null && _a !== void 0 ? _a : star === null || star === void 0 ? void 0 : star.nb_sides) !== null && _b !== void 0 ? _b : 5;
+        }
+        draw(context, particle, radius) {
+            var _a;
+            const star = particle.shapeData;
+            const sides = this.getSidesCount(particle);
+            const inset = (_a = star === null || star === void 0 ? void 0 : star.inset) !== null && _a !== void 0 ? _a : 2;
+            context.moveTo(0, 0 - radius);
+            for (let i = 0; i < sides; i++) {
+                context.rotate(Math.PI / sides);
+                context.lineTo(0, 0 - radius * inset);
+                context.rotate(Math.PI / sides);
+                context.lineTo(0, 0 - radius);
+            }
+        }
+    }
+    exports.StarDrawer = StarDrawer;
+});

package/umd/Shapes/Star/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadStarShape(engine: Engine): Promise<void>;

package/umd/Shapes/Star/index.js

@@ -0,0 +1,18 @@
+(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", "./StarDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadStarShape = void 0;
+    const StarDrawer_1 = require("./StarDrawer");
+    async function loadStarShape(engine) {
+        await engine.addShape("star", new StarDrawer_1.StarDrawer());
+    }
+    exports.loadStarShape = loadStarShape;
+});

package/umd/Shapes/Text/TextDrawer.d.ts

@@ -0,0 +1,7 @@
+import type { Container, IParticle, IShapeDrawer } from "../../Core";
+export declare const validTypes: string[];
+export declare class TextDrawer implements IShapeDrawer {
+    getSidesCount(): number;
+    init(container: Container): Promise<void>;
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number, opacity: number): void;
+}

package/umd/Shapes/Text/TextDrawer.js

@@ -0,0 +1,75 @@
+(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.TextDrawer = exports.validTypes = void 0;
+    const Utils_1 = require("../../Utils");
+    exports.validTypes = ["text", "character", "char"];
+    class TextDrawer {
+        getSidesCount() {
+            return 12;
+        }
+        async init(container) {
+            const options = container.actualOptions;
+            if (exports.validTypes.find((t) => (0, Utils_1.isInArray)(t, options.particles.shape.type))) {
+                const shapeOptions = exports.validTypes.map((t) => options.particles.shape.options[t]).find((t) => !!t);
+                if (shapeOptions instanceof Array) {
+                    const promises = [];
+                    for (const character of shapeOptions) {
+                        promises.push((0, Utils_1.loadFont)(character));
+                    }
+                    await Promise.allSettled(promises);
+                }
+                else {
+                    if (shapeOptions !== undefined) {
+                        await (0, Utils_1.loadFont)(shapeOptions);
+                    }
+                }
+            }
+        }
+        draw(context, particle, radius, opacity) {
+            var _a, _b, _c;
+            const character = particle.shapeData;
+            if (character === undefined) {
+                return;
+            }
+            const textData = character.value;
+            if (textData === undefined) {
+                return;
+            }
+            const textParticle = particle;
+            if (textParticle.text === undefined) {
+                textParticle.text =
+                    textData instanceof Array ? (0, Utils_1.itemFromArray)(textData, particle.randomIndexData) : textData;
+            }
+            const text = textParticle.text;
+            const style = (_a = character.style) !== null && _a !== void 0 ? _a : "";
+            const weight = (_b = character.weight) !== null && _b !== void 0 ? _b : "400";
+            const size = Math.round(radius) * 2;
+            const font = (_c = character.font) !== null && _c !== void 0 ? _c : "Verdana";
+            const fill = particle.fill;
+            const offsetX = (text.length * radius) / 2;
+            context.font = `${style} ${weight} ${size}px "${font}"`;
+            const pos = {
+                x: -offsetX,
+                y: radius / 2,
+            };
+            context.globalAlpha = opacity;
+            if (fill) {
+                context.fillText(text, pos.x, pos.y);
+            }
+            else {
+                context.strokeText(text, pos.x, pos.y);
+            }
+            context.globalAlpha = 1;
+        }
+    }
+    exports.TextDrawer = TextDrawer;
+});

package/umd/Shapes/Text/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadTextShape(engine: Engine): Promise<void>;

package/umd/Shapes/Text/index.js

@@ -0,0 +1,21 @@
+(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", "./TextDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadTextShape = void 0;
+    const TextDrawer_1 = require("./TextDrawer");
+    async function loadTextShape(engine) {
+        const drawer = new TextDrawer_1.TextDrawer();
+        for (const type of TextDrawer_1.validTypes) {
+            await engine.addShape(type, drawer);
+        }
+    }
+    exports.loadTextShape = loadTextShape;
+});

package/umd/Types/ParticlesGroups.d.ts

@@ -0,0 +1,4 @@
+import type { IParticles } from "../Options/Interfaces/Particles/IParticles";
+export declare type ParticlesGroups = {
+    [name: string]: IParticles;
+};

package/umd/Types/ParticlesGroups.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/Types/PathOptions.d.ts

@@ -0,0 +1,3 @@
+export declare type PathOptions = {
+    [key: string]: unknown;
+};

package/umd/Types/PathOptions.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/Types/RangeValue.d.ts

@@ -0,0 +1,2 @@
+import type { IRangeValue } from "../Core/Interfaces/IRangeValue";
+export declare type RangeValue = number | IRangeValue;

package/umd/Types/RangeValue.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/Types/RecursivePartial.d.ts

@@ -0,0 +1,3 @@
+export declare type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P];
+};

package/umd/Types/RecursivePartial.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/Types/ShapeData.d.ts

@@ -0,0 +1,5 @@
+import type { IShapeValues } from "../Options/Interfaces/Particles/Shape/IShapeValues";
+import type { SingleOrMultiple } from "./SingleOrMultiple";
+export declare type ShapeData = {
+    [type: string]: SingleOrMultiple<IShapeValues>;
+};

package/umd/Types/ShapeData.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/Types/ShapeDrawerFunctions.d.ts

@@ -0,0 +1,11 @@
+import type { Container } from "../Core/Container";
+import type { IDelta } from "../Core/Interfaces/IDelta";
+import type { IParticle } from "../Core/Interfaces/IParticle";
+import { Particle } from "../Core/Particle";
+export declare type ShapeDrawerDrawFunction = (context: CanvasRenderingContext2D, particle: IParticle, radius: number, opacity: number, delta: IDelta, pixelRatio: number) => void;
+export declare type ShapeDrawerInitFunction = (container: Container) => Promise<void>;
+export declare type ShapeDrawerParticleInitFunction = (container: Container, particle: IParticle) => void;
+export declare type ShapeDrawerAfterEffectFunction = (context: CanvasRenderingContext2D, particle: IParticle, radius: number, opacity: number, delta: IDelta, pixelRatio: number) => void;
+export declare type ShapeDrawerDestroyFunction = (container: Container) => void;
+export declare type ShapeDrawerSidesCountFunction = (particle: IParticle) => number;
+export declare type ShapeDrawerLoadFunction = (particle: Particle) => void;

package/umd/Types/ShapeDrawerFunctions.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/Types/SingleOrMultiple.d.ts

@@ -0,0 +1 @@
+export declare type SingleOrMultiple<T> = T | T[];

package/umd/Types/SingleOrMultiple.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/Types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./RangeValue";
+export * from "./RecursivePartial";
+export * from "./ShapeData";
+export * from "./ShapeDrawerFunctions";
+export * from "./SingleOrMultiple";
+export * from "./PathOptions";

package/umd/Types/index.js

@@ -0,0 +1,28 @@
+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", "./RangeValue", "./RecursivePartial", "./ShapeData", "./ShapeDrawerFunctions", "./SingleOrMultiple", "./PathOptions"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./RangeValue"), exports);
+    __exportStar(require("./RecursivePartial"), exports);
+    __exportStar(require("./ShapeData"), exports);
+    __exportStar(require("./ShapeDrawerFunctions"), exports);
+    __exportStar(require("./SingleOrMultiple"), exports);
+    __exportStar(require("./PathOptions"), exports);
+});

package/umd/Updaters/Angle/AngleUpdater.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class AngleUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/umd/Updaters/Angle/AngleUpdater.js

@@ -0,0 +1,88 @@
+(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.AngleUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function updateAngle(particle, delta) {
+        var _a;
+        const rotate = particle.rotate;
+        if (!rotate) {
+            return;
+        }
+        const rotateOptions = particle.options.rotate;
+        const rotateAnimation = rotateOptions.animation;
+        const speed = ((_a = rotate.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor;
+        const max = 2 * Math.PI;
+        if (!rotateAnimation.enable) {
+            return;
+        }
+        switch (rotate.status) {
+            case 0:
+                rotate.value += speed;
+                if (rotate.value > max) {
+                    rotate.value -= max;
+                }
+                break;
+            case 1:
+            default:
+                rotate.value -= speed;
+                if (rotate.value < 0) {
+                    rotate.value += max;
+                }
+                break;
+        }
+    }
+    class AngleUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            const rotateOptions = particle.options.rotate;
+            particle.rotate = {
+                enable: rotateOptions.animation.enable,
+                value: ((0, Utils_1.getRangeValue)(rotateOptions.value) * Math.PI) / 180,
+            };
+            let rotateDirection = rotateOptions.direction;
+            if (rotateDirection === "random") {
+                const index = Math.floor(Math.random() * 2);
+                rotateDirection = index > 0 ? "counter-clockwise" : "clockwise";
+            }
+            switch (rotateDirection) {
+                case "counter-clockwise":
+                case "counterClockwise":
+                    particle.rotate.status = 1;
+                    break;
+                case "clockwise":
+                    particle.rotate.status = 0;
+                    break;
+            }
+            const rotateAnimation = particle.options.rotate.animation;
+            if (rotateAnimation.enable) {
+                particle.rotate.velocity = (rotateAnimation.speed / 360) * this.container.retina.reduceFactor;
+                if (!rotateAnimation.sync) {
+                    particle.rotate.velocity *= Math.random();
+                }
+            }
+        }
+        isEnabled(particle) {
+            const rotate = particle.options.rotate;
+            const rotateAnimation = rotate.animation;
+            return !particle.destroyed && !particle.spawning && !rotate.path && rotateAnimation.enable;
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateAngle(particle, delta);
+        }
+    }
+    exports.AngleUpdater = AngleUpdater;
+});

package/umd/Updaters/Angle/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadAngleUpdater(engine: Engine): Promise<void>;

package/umd/Updaters/Angle/index.js

@@ -0,0 +1,18 @@
+(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", "./AngleUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadAngleUpdater = void 0;
+    const AngleUpdater_1 = require("./AngleUpdater");
+    async function loadAngleUpdater(engine) {
+        await engine.addParticleUpdater("angle", (container) => new AngleUpdater_1.AngleUpdater(container));
+    }
+    exports.loadAngleUpdater = loadAngleUpdater;
+});

package/umd/Updaters/Color/ColorUpdater.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class ColorUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/umd/Updaters/Color/ColorUpdater.js

@@ -0,0 +1,77 @@
+(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.ColorUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function updateColorValue(delta, value, valueAnimation, max, decrease) {
+        var _a;
+        const colorValue = value;
+        if (!colorValue || !valueAnimation.enable) {
+            return;
+        }
+        const offset = (0, Utils_1.randomInRange)(valueAnimation.offset);
+        const velocity = ((_a = value.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor + offset * 3.6;
+        if (!decrease || colorValue.status === 0) {
+            colorValue.value += velocity;
+            if (decrease && colorValue.value > max) {
+                colorValue.status = 1;
+                colorValue.value -= colorValue.value % max;
+            }
+        }
+        else {
+            colorValue.value -= velocity;
+            if (colorValue.value < 0) {
+                colorValue.status = 0;
+                colorValue.value += colorValue.value;
+            }
+        }
+        if (colorValue.value > max) {
+            colorValue.value %= max;
+        }
+    }
+    function updateColor(particle, delta) {
+        var _a, _b, _c;
+        const animationOptions = particle.options.color.animation;
+        if (((_a = particle.color) === null || _a === void 0 ? void 0 : _a.h) !== undefined) {
+            updateColorValue(delta, particle.color.h, animationOptions.h, 360, false);
+        }
+        if (((_b = particle.color) === null || _b === void 0 ? void 0 : _b.s) !== undefined) {
+            updateColorValue(delta, particle.color.s, animationOptions.s, 100, true);
+        }
+        if (((_c = particle.color) === null || _c === void 0 ? void 0 : _c.l) !== undefined) {
+            updateColorValue(delta, particle.color.l, animationOptions.l, 100, true);
+        }
+    }
+    class ColorUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            const hslColor = (0, Utils_1.colorToHsl)(particle.options.color, particle.id, particle.options.reduceDuplicates);
+            if (hslColor) {
+                particle.color = (0, Utils_1.getHslAnimationFromHsl)(hslColor, particle.options.color.animation, this.container.retina.reduceFactor);
+            }
+        }
+        isEnabled(particle) {
+            var _a, _b, _c;
+            const animationOptions = particle.options.color.animation;
+            return (!particle.destroyed &&
+                !particle.spawning &&
+                ((((_a = particle.color) === null || _a === void 0 ? void 0 : _a.h.value) !== undefined && animationOptions.h.enable) ||
+                    (((_b = particle.color) === null || _b === void 0 ? void 0 : _b.s.value) !== undefined && animationOptions.s.enable) ||
+                    (((_c = particle.color) === null || _c === void 0 ? void 0 : _c.l.value) !== undefined && animationOptions.l.enable)));
+        }
+        update(particle, delta) {
+            updateColor(particle, delta);
+        }
+    }
+    exports.ColorUpdater = ColorUpdater;
+});

package/umd/Updaters/Color/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadColorUpdater(engine: Engine): Promise<void>;

package/umd/Updaters/Color/index.js

@@ -0,0 +1,18 @@
+(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", "./ColorUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadColorUpdater = void 0;
+    const ColorUpdater_1 = require("./ColorUpdater");
+    async function loadColorUpdater(engine) {
+        await engine.addParticleUpdater("color", (container) => new ColorUpdater_1.ColorUpdater(container));
+    }
+    exports.loadColorUpdater = loadColorUpdater;
+});

package/umd/Updaters/Life/LifeUpdater.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class LifeUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}