tsparticles 1.40.2 → 1.41.3

package/umd/Updaters/Life/LifeUpdater.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.LifeUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    class LifeUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init() {
+        }
+        isEnabled(particle) {
+            return !particle.destroyed;
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            const life = particle.life;
+            let justSpawned = false;
+            if (particle.spawning) {
+                life.delayTime += delta.value;
+                if (life.delayTime >= particle.life.delay) {
+                    justSpawned = true;
+                    particle.spawning = false;
+                    life.delayTime = 0;
+                    life.time = 0;
+                }
+                else {
+                    return;
+                }
+            }
+            if (life.duration === -1) {
+                return;
+            }
+            if (particle.spawning) {
+                return;
+            }
+            if (justSpawned) {
+                life.time = 0;
+            }
+            else {
+                life.time += delta.value;
+            }
+            if (life.time < life.duration) {
+                return;
+            }
+            life.time = 0;
+            if (particle.life.count > 0) {
+                particle.life.count--;
+            }
+            if (particle.life.count === 0) {
+                particle.destroy();
+                return;
+            }
+            const canvasSize = this.container.canvas.size, widthRange = (0, Utils_1.setRangeValue)(0, canvasSize.width), heightRange = (0, Utils_1.setRangeValue)(0, canvasSize.width);
+            particle.position.x = (0, Utils_1.randomInRange)(widthRange);
+            particle.position.y = (0, Utils_1.randomInRange)(heightRange);
+            particle.spawning = true;
+            life.delayTime = 0;
+            life.time = 0;
+            particle.reset();
+            const lifeOptions = particle.options.life;
+            life.delay = (0, Utils_1.getRangeValue)(lifeOptions.delay.value) * 1000;
+            life.duration = (0, Utils_1.getRangeValue)(lifeOptions.duration.value) * 1000;
+        }
+    }
+    exports.LifeUpdater = LifeUpdater;
+});

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

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

package/umd/Updaters/Life/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", "./LifeUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadLifeUpdater = void 0;
+    const LifeUpdater_1 = require("./LifeUpdater");
+    async function loadLifeUpdater(engine) {
+        await engine.addParticleUpdater("life", (container) => new LifeUpdater_1.LifeUpdater(container));
+    }
+    exports.loadLifeUpdater = loadLifeUpdater;
+});

package/umd/Updaters/Opacity/OpacityUpdater.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class OpacityUpdater 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/Opacity/OpacityUpdater.js

@@ -0,0 +1,131 @@
+(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.OpacityUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function checkDestroy(particle, value, minValue, maxValue) {
+        switch (particle.options.opacity.animation.destroy) {
+            case "max":
+                if (value >= maxValue) {
+                    particle.destroy();
+                }
+                break;
+            case "min":
+                if (value <= minValue) {
+                    particle.destroy();
+                }
+                break;
+        }
+    }
+    function updateOpacity(particle, delta) {
+        var _a, _b, _c, _d, _e;
+        if (!particle.opacity) {
+            return;
+        }
+        const minValue = particle.opacity.min;
+        const maxValue = particle.opacity.max;
+        if (particle.destroyed ||
+            !particle.opacity.enable ||
+            (((_a = particle.opacity.maxLoops) !== null && _a !== void 0 ? _a : 0) > 0 && ((_b = particle.opacity.loops) !== null && _b !== void 0 ? _b : 0) > ((_c = particle.opacity.maxLoops) !== null && _c !== void 0 ? _c : 0))) {
+            return;
+        }
+        switch (particle.opacity.status) {
+            case 0:
+                if (particle.opacity.value >= maxValue) {
+                    particle.opacity.status = 1;
+                    if (!particle.opacity.loops) {
+                        particle.opacity.loops = 0;
+                    }
+                    particle.opacity.loops++;
+                }
+                else {
+                    particle.opacity.value += ((_d = particle.opacity.velocity) !== null && _d !== void 0 ? _d : 0) * delta.factor;
+                }
+                break;
+            case 1:
+                if (particle.opacity.value <= minValue) {
+                    particle.opacity.status = 0;
+                    if (!particle.opacity.loops) {
+                        particle.opacity.loops = 0;
+                    }
+                    particle.opacity.loops++;
+                }
+                else {
+                    particle.opacity.value -= ((_e = particle.opacity.velocity) !== null && _e !== void 0 ? _e : 0) * delta.factor;
+                }
+                break;
+        }
+        checkDestroy(particle, particle.opacity.value, minValue, maxValue);
+        if (!particle.destroyed) {
+            particle.opacity.value = (0, Utils_1.clamp)(particle.opacity.value, minValue, maxValue);
+        }
+    }
+    class OpacityUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            const opacityOptions = particle.options.opacity;
+            particle.opacity = {
+                enable: opacityOptions.animation.enable,
+                max: (0, Utils_1.getRangeMax)(opacityOptions.value),
+                min: (0, Utils_1.getRangeMin)(opacityOptions.value),
+                value: (0, Utils_1.getRangeValue)(opacityOptions.value),
+                loops: 0,
+                maxLoops: opacityOptions.animation.count,
+            };
+            const opacityAnimation = opacityOptions.animation;
+            if (opacityAnimation.enable) {
+                particle.opacity.status = 0;
+                const opacityRange = opacityOptions.value;
+                particle.opacity.min = (0, Utils_1.getRangeMin)(opacityRange);
+                particle.opacity.max = (0, Utils_1.getRangeMax)(opacityRange);
+                switch (opacityAnimation.startValue) {
+                    case "min":
+                        particle.opacity.value = particle.opacity.min;
+                        particle.opacity.status = 0;
+                        break;
+                    case "random":
+                        particle.opacity.value = (0, Utils_1.randomInRange)(particle.opacity);
+                        particle.opacity.status =
+                            Math.random() >= 0.5 ? 0 : 1;
+                        break;
+                    case "max":
+                    default:
+                        particle.opacity.value = particle.opacity.max;
+                        particle.opacity.status = 1;
+                        break;
+                }
+                particle.opacity.velocity = (opacityAnimation.speed / 100) * this.container.retina.reduceFactor;
+                if (!opacityAnimation.sync) {
+                    particle.opacity.velocity *= Math.random();
+                }
+            }
+        }
+        isEnabled(particle) {
+            var _a, _b, _c, _d;
+            return (!particle.destroyed &&
+                !particle.spawning &&
+                !!particle.opacity &&
+                particle.opacity.enable &&
+                (((_a = particle.opacity.maxLoops) !== null && _a !== void 0 ? _a : 0) <= 0 ||
+                    (((_b = particle.opacity.maxLoops) !== null && _b !== void 0 ? _b : 0) > 0 &&
+                        ((_c = particle.opacity.loops) !== null && _c !== void 0 ? _c : 0) < ((_d = particle.opacity.maxLoops) !== null && _d !== void 0 ? _d : 0))));
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateOpacity(particle, delta);
+        }
+    }
+    exports.OpacityUpdater = OpacityUpdater;
+});

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

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

package/umd/Updaters/Opacity/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", "./OpacityUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadOpacityUpdater = void 0;
+    const OpacityUpdater_1 = require("./OpacityUpdater");
+    async function loadOpacityUpdater(engine) {
+        await engine.addParticleUpdater("opacity", (container) => new OpacityUpdater_1.OpacityUpdater(container));
+    }
+    exports.loadOpacityUpdater = loadOpacityUpdater;
+});

package/umd/Updaters/OutModes/IBounceData.d.ts

@@ -0,0 +1,11 @@
+import type { IBounds, ICoordinates, IDimension, Particle } from "../../Core";
+import type { OutMode, OutModeAlt, OutModeDirection } from "../../Enums";
+export interface IBounceData {
+    particle: Particle;
+    outMode: OutMode | OutModeAlt | keyof typeof OutMode;
+    direction: OutModeDirection;
+    bounds: IBounds;
+    canvasSize: IDimension;
+    offset: ICoordinates;
+    size: number;
+}

package/umd/Updaters/OutModes/IBounceData.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/Updaters/OutModes/OutOfCanvasUpdater.d.ts

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

package/umd/Updaters/OutModes/OutOfCanvasUpdater.js

@@ -0,0 +1,156 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OutOfCanvasUpdater = void 0;
+    const Utils_1 = require("./Utils");
+    const Utils_2 = require("../../Utils");
+    class OutOfCanvasUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init() {
+        }
+        isEnabled(particle) {
+            return !particle.destroyed && !particle.spawning;
+        }
+        update(particle, delta) {
+            var _a, _b, _c, _d;
+            const outModes = particle.options.move.outModes;
+            this.updateOutMode(particle, delta, (_a = outModes.bottom) !== null && _a !== void 0 ? _a : outModes.default, "bottom");
+            this.updateOutMode(particle, delta, (_b = outModes.left) !== null && _b !== void 0 ? _b : outModes.default, "left");
+            this.updateOutMode(particle, delta, (_c = outModes.right) !== null && _c !== void 0 ? _c : outModes.default, "right");
+            this.updateOutMode(particle, delta, (_d = outModes.top) !== null && _d !== void 0 ? _d : outModes.default, "top");
+        }
+        updateOutMode(particle, delta, outMode, direction) {
+            switch (outMode) {
+                case "bounce":
+                case "bounce-vertical":
+                case "bounce-horizontal":
+                case "bounceVertical":
+                case "bounceHorizontal":
+                case "split":
+                    this.bounce(particle, delta, direction, outMode);
+                    break;
+                case "destroy":
+                    this.destroy(particle, direction);
+                    break;
+                case "out":
+                    this.out(particle, direction);
+                    break;
+                case "none":
+                default:
+                    this.none(particle, direction);
+                    break;
+            }
+        }
+        destroy(particle, direction) {
+            const container = this.container;
+            if ((0, Utils_2.isPointInside)(particle.position, container.canvas.size, particle.getRadius(), direction)) {
+                return;
+            }
+            container.particles.remove(particle, undefined, true);
+        }
+        out(particle, direction) {
+            const container = this.container;
+            if ((0, Utils_2.isPointInside)(particle.position, container.canvas.size, particle.getRadius(), direction)) {
+                return;
+            }
+            const wrap = particle.options.move.warp, canvasSize = container.canvas.size, newPos = {
+                bottom: canvasSize.height + particle.getRadius() + particle.offset.y,
+                left: -particle.getRadius() - particle.offset.x,
+                right: canvasSize.width + particle.getRadius() + particle.offset.x,
+                top: -particle.getRadius() - particle.offset.y,
+            }, sizeValue = particle.getRadius(), nextBounds = (0, Utils_2.calculateBounds)(particle.position, sizeValue);
+            if (direction === "right" && nextBounds.left > canvasSize.width + particle.offset.x) {
+                particle.position.x = newPos.left;
+                particle.initialPosition.x = particle.position.x;
+                if (!wrap) {
+                    particle.position.y = Math.random() * canvasSize.height;
+                    particle.initialPosition.y = particle.position.y;
+                }
+            }
+            else if (direction === "left" && nextBounds.right < -particle.offset.x) {
+                particle.position.x = newPos.right;
+                particle.initialPosition.x = particle.position.x;
+                if (!wrap) {
+                    particle.position.y = Math.random() * canvasSize.height;
+                    particle.initialPosition.y = particle.position.y;
+                }
+            }
+            if (direction === "bottom" && nextBounds.top > canvasSize.height + particle.offset.y) {
+                if (!wrap) {
+                    particle.position.x = Math.random() * canvasSize.width;
+                    particle.initialPosition.x = particle.position.x;
+                }
+                particle.position.y = newPos.top;
+                particle.initialPosition.y = particle.position.y;
+            }
+            else if (direction === "top" && nextBounds.bottom < -particle.offset.y) {
+                if (!wrap) {
+                    particle.position.x = Math.random() * canvasSize.width;
+                    particle.initialPosition.x = particle.position.x;
+                }
+                particle.position.y = newPos.bottom;
+                particle.initialPosition.y = particle.position.y;
+            }
+        }
+        bounce(particle, delta, direction, outMode) {
+            const container = this.container;
+            let handled = false;
+            for (const [, plugin] of container.plugins) {
+                if (plugin.particleBounce !== undefined) {
+                    handled = plugin.particleBounce(particle, delta, direction);
+                }
+                if (handled) {
+                    break;
+                }
+            }
+            if (handled) {
+                return;
+            }
+            const pos = particle.getPosition(), offset = particle.offset, size = particle.getRadius(), bounds = (0, Utils_2.calculateBounds)(pos, size), canvasSize = container.canvas.size;
+            (0, Utils_1.bounceHorizontal)({ particle, outMode, direction, bounds, canvasSize, offset, size });
+            (0, Utils_1.bounceVertical)({ particle, outMode, direction, bounds, canvasSize, offset, size });
+        }
+        none(particle, direction) {
+            if ((particle.options.move.distance.horizontal &&
+                (direction === "left" || direction === "right")) ||
+                (particle.options.move.distance.vertical &&
+                    (direction === "top" || direction === "bottom"))) {
+                return;
+            }
+            const gravityOptions = particle.options.move.gravity, container = this.container;
+            const canvasSize = container.canvas.size;
+            const pRadius = particle.getRadius();
+            if (!gravityOptions.enable) {
+                if ((particle.velocity.y > 0 && particle.position.y <= canvasSize.height + pRadius) ||
+                    (particle.velocity.y < 0 && particle.position.y >= -pRadius) ||
+                    (particle.velocity.x > 0 && particle.position.x <= canvasSize.width + pRadius) ||
+                    (particle.velocity.x < 0 && particle.position.x >= -pRadius)) {
+                    return;
+                }
+                if (!(0, Utils_2.isPointInside)(particle.position, container.canvas.size, pRadius, direction)) {
+                    container.particles.remove(particle);
+                }
+            }
+            else {
+                const position = particle.position;
+                if ((!gravityOptions.inverse &&
+                    position.y > canvasSize.height + pRadius &&
+                    direction === "bottom") ||
+                    (gravityOptions.inverse && position.y < -pRadius && direction === "top")) {
+                    container.particles.remove(particle);
+                }
+            }
+        }
+    }
+    exports.OutOfCanvasUpdater = OutOfCanvasUpdater;
+});

package/umd/Updaters/OutModes/Utils.d.ts

@@ -0,0 +1,3 @@
+import type { IBounceData } from "./IBounceData";
+export declare function bounceHorizontal(data: IBounceData): void;
+export declare function bounceVertical(data: IBounceData): void;

package/umd/Updaters/OutModes/Utils.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.bounceVertical = exports.bounceHorizontal = void 0;
+    const Utils_1 = require("../../Utils");
+    function bounceHorizontal(data) {
+        if (!(data.outMode === "bounce" ||
+            data.outMode === "bounce-horizontal" ||
+            data.outMode === "bounceHorizontal" ||
+            data.outMode === "split")) {
+            return;
+        }
+        const velocity = data.particle.velocity.x;
+        let bounced = false;
+        if ((data.direction === "right" && data.bounds.right >= data.canvasSize.width && velocity > 0) ||
+            (data.direction === "left" && data.bounds.left <= 0 && velocity < 0)) {
+            const newVelocity = (0, Utils_1.getRangeValue)(data.particle.options.bounce.horizontal.value);
+            data.particle.velocity.x *= -newVelocity;
+            bounced = true;
+        }
+        if (!bounced) {
+            return;
+        }
+        const minPos = data.offset.x + data.size;
+        if (data.bounds.right >= data.canvasSize.width) {
+            data.particle.position.x = data.canvasSize.width - minPos;
+        }
+        else if (data.bounds.left <= 0) {
+            data.particle.position.x = minPos;
+        }
+        if (data.outMode === "split") {
+            data.particle.destroy();
+        }
+    }
+    exports.bounceHorizontal = bounceHorizontal;
+    function bounceVertical(data) {
+        if (data.outMode === "bounce" ||
+            data.outMode === "bounce-vertical" ||
+            data.outMode === "bounceVertical" ||
+            data.outMode === "split") {
+            const velocity = data.particle.velocity.y;
+            let bounced = false;
+            if ((data.direction === "bottom" &&
+                data.bounds.bottom >= data.canvasSize.height &&
+                velocity > 0) ||
+                (data.direction === "top" && data.bounds.top <= 0 && velocity < 0)) {
+                const newVelocity = (0, Utils_1.getRangeValue)(data.particle.options.bounce.vertical.value);
+                data.particle.velocity.y *= -newVelocity;
+                bounced = true;
+            }
+            if (!bounced) {
+                return;
+            }
+            const minPos = data.offset.y + data.size;
+            if (data.bounds.bottom >= data.canvasSize.height) {
+                data.particle.position.y = data.canvasSize.height - minPos;
+            }
+            else if (data.bounds.top <= 0) {
+                data.particle.position.y = minPos;
+            }
+            if (data.outMode === "split") {
+                data.particle.destroy();
+            }
+        }
+    }
+    exports.bounceVertical = bounceVertical;
+});

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

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

package/umd/Updaters/OutModes/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", "./OutOfCanvasUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadOutModesUpdater = void 0;
+    const OutOfCanvasUpdater_1 = require("./OutOfCanvasUpdater");
+    async function loadOutModesUpdater(engine) {
+        await engine.addParticleUpdater("outModes", (container) => new OutOfCanvasUpdater_1.OutOfCanvasUpdater(container));
+    }
+    exports.loadOutModesUpdater = loadOutModesUpdater;
+});

package/umd/Updaters/Roll/RollUpdater.d.ts

@@ -0,0 +1,6 @@
+import type { IDelta, IParticleUpdater, Particle } from "../../Core";
+export declare class RollUpdater implements IParticleUpdater {
+    init(particle: Particle): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+}

package/umd/Updaters/Roll/RollUpdater.js

@@ -0,0 +1,73 @@
+(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.RollUpdater = void 0;
+    const Utils_1 = require("../../Utils");
+    function updateRoll(particle, delta) {
+        const roll = particle.options.roll;
+        if (!particle.roll || !roll.enable) {
+            return;
+        }
+        const speed = particle.roll.speed * delta.factor;
+        const max = 2 * Math.PI;
+        particle.roll.angle += speed;
+        if (particle.roll.angle > max) {
+            particle.roll.angle -= max;
+        }
+    }
+    class RollUpdater {
+        init(particle) {
+            const rollOpt = particle.options.roll;
+            if (rollOpt.enable) {
+                particle.roll = {
+                    angle: Math.random() * Math.PI * 2,
+                    speed: (0, Utils_1.getRangeValue)(rollOpt.speed) / 360,
+                };
+                if (rollOpt.backColor) {
+                    particle.backColor = (0, Utils_1.colorToHsl)(rollOpt.backColor);
+                }
+                else if (rollOpt.darken.enable && rollOpt.enlighten.enable) {
+                    const alterType = Math.random() >= 0.5 ? "darken" : "enlighten";
+                    particle.roll.alter = {
+                        type: alterType,
+                        value: alterType === "darken" ? rollOpt.darken.value : rollOpt.enlighten.value,
+                    };
+                }
+                else if (rollOpt.darken.enable) {
+                    particle.roll.alter = {
+                        type: "darken",
+                        value: rollOpt.darken.value,
+                    };
+                }
+                else if (rollOpt.enlighten.enable) {
+                    particle.roll.alter = {
+                        type: "enlighten",
+                        value: rollOpt.enlighten.value,
+                    };
+                }
+            }
+            else {
+                particle.roll = { angle: 0, speed: 0 };
+            }
+        }
+        isEnabled(particle) {
+            const roll = particle.options.roll;
+            return !particle.destroyed && !particle.spawning && roll.enable;
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateRoll(particle, delta);
+        }
+    }
+    exports.RollUpdater = RollUpdater;
+});

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

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

package/umd/Updaters/Roll/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", "./RollUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadRollUpdater = void 0;
+    const RollUpdater_1 = require("./RollUpdater");
+    async function loadRollUpdater(engine) {
+        await engine.addParticleUpdater("roll", () => new RollUpdater_1.RollUpdater());
+    }
+    exports.loadRollUpdater = loadRollUpdater;
+});