tsparticles 1.42.2 → 1.43.0

package/cjs/Core/Particle.js

@@ -0,0 +1,367 @@
+"use strict";
+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);
+};
+var _Particle_engine;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Particle = void 0;
+const NumberUtils_1 = require("../Utils/NumberUtils");
+const ColorUtils_1 = require("../Utils/ColorUtils");
+const Utils_1 = require("../Utils/Utils");
+const ParticlesOptions_1 = require("../Options/Classes/Particles/ParticlesOptions");
+const Shape_1 = require("../Options/Classes/Particles/Shape/Shape");
+const Vector_1 = require("./Utils/Vector");
+const Vector3d_1 = require("./Utils/Vector3d");
+const CanvasUtils_1 = require("../Utils/CanvasUtils");
+const fixOutMode = (data) => {
+    if (!((0, Utils_1.isInArray)(data.outMode, data.checkModes) || (0, Utils_1.isInArray)(data.outMode, data.checkModes))) {
+        return;
+    }
+    if (data.coord > data.maxCoord - data.radius * 2) {
+        data.setCb(-data.radius);
+    }
+    else if (data.coord < data.radius * 2) {
+        data.setCb(data.radius);
+    }
+};
+class Particle {
+    constructor(engine, id, container, position, overrideOptions, group) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.id = id;
+        this.container = container;
+        this.group = group;
+        _Particle_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Particle_engine, engine, "f");
+        this.fill = true;
+        this.close = true;
+        this.lastPathTime = 0;
+        this.destroyed = false;
+        this.unbreakable = false;
+        this.splitCount = 0;
+        this.misplaced = false;
+        this.retina = {
+            maxDistance: {},
+        };
+        this.ignoresResizeRatio = true;
+        const pxRatio = container.retina.pixelRatio, mainOptions = container.actualOptions, particlesOptions = new ParticlesOptions_1.ParticlesOptions();
+        particlesOptions.load(mainOptions.particles);
+        const shapeType = particlesOptions.shape.type, reduceDuplicates = particlesOptions.reduceDuplicates;
+        this.shape = shapeType instanceof Array ? (0, Utils_1.itemFromArray)(shapeType, this.id, reduceDuplicates) : shapeType;
+        if (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.shape) {
+            if (overrideOptions.shape.type) {
+                const overrideShapeType = overrideOptions.shape.type;
+                this.shape =
+                    overrideShapeType instanceof Array
+                        ? (0, Utils_1.itemFromArray)(overrideShapeType, this.id, reduceDuplicates)
+                        : overrideShapeType;
+            }
+            const shapeOptions = new Shape_1.Shape();
+            shapeOptions.load(overrideOptions.shape);
+            if (this.shape) {
+                this.shapeData = this.loadShapeData(shapeOptions, reduceDuplicates);
+            }
+        }
+        else {
+            this.shapeData = this.loadShapeData(particlesOptions.shape, reduceDuplicates);
+        }
+        if (overrideOptions !== undefined) {
+            particlesOptions.load(overrideOptions);
+        }
+        if (((_a = this.shapeData) === null || _a === void 0 ? void 0 : _a.particles) !== undefined) {
+            particlesOptions.load((_b = this.shapeData) === null || _b === void 0 ? void 0 : _b.particles);
+        }
+        this.fill = (_d = (_c = this.shapeData) === null || _c === void 0 ? void 0 : _c.fill) !== null && _d !== void 0 ? _d : this.fill;
+        this.close = (_f = (_e = this.shapeData) === null || _e === void 0 ? void 0 : _e.close) !== null && _f !== void 0 ? _f : this.close;
+        this.options = particlesOptions;
+        this.pathDelay = (0, NumberUtils_1.getValue)(this.options.move.path.delay) * 1000;
+        const zIndexValue = (0, NumberUtils_1.getRangeValue)(this.options.zIndex.value);
+        container.retina.initParticle(this);
+        const sizeOptions = this.options.size, sizeRange = sizeOptions.value;
+        this.size = {
+            enable: sizeOptions.animation.enable,
+            value: (0, NumberUtils_1.getValue)(sizeOptions) * container.retina.pixelRatio,
+            max: (0, NumberUtils_1.getRangeMax)(sizeRange) * pxRatio,
+            min: (0, NumberUtils_1.getRangeMin)(sizeRange) * pxRatio,
+            loops: 0,
+            maxLoops: (0, NumberUtils_1.getRangeValue)(sizeOptions.animation.count),
+        };
+        const sizeAnimation = sizeOptions.animation;
+        if (sizeAnimation.enable) {
+            this.size.status = 0;
+            switch (sizeAnimation.startValue) {
+                case "min":
+                    this.size.value = this.size.min;
+                    this.size.status = 0;
+                    break;
+                case "random":
+                    this.size.value = (0, NumberUtils_1.randomInRange)(this.size) * pxRatio;
+                    this.size.status = Math.random() >= 0.5 ? 0 : 1;
+                    break;
+                case "max":
+                default:
+                    this.size.value = this.size.max;
+                    this.size.status = 1;
+                    break;
+            }
+            this.size.velocity =
+                (((_g = this.retina.sizeAnimationSpeed) !== null && _g !== void 0 ? _g : container.retina.sizeAnimationSpeed) / 100) *
+                    container.retina.reduceFactor;
+            if (!sizeAnimation.sync) {
+                this.size.velocity *= Math.random();
+            }
+        }
+        this.direction = (0, NumberUtils_1.getParticleDirectionAngle)(this.options.move.direction);
+        this.bubble = {
+            inRange: false,
+        };
+        this.initialVelocity = this.calculateVelocity();
+        this.velocity = this.initialVelocity.copy();
+        this.moveDecay = 1 - (0, NumberUtils_1.getRangeValue)(this.options.move.decay);
+        const gravityOptions = this.options.move.gravity;
+        this.gravity = {
+            enable: gravityOptions.enable,
+            acceleration: (0, NumberUtils_1.getRangeValue)(gravityOptions.acceleration),
+            inverse: gravityOptions.inverse,
+        };
+        this.position = this.calcPosition(container, position, (0, NumberUtils_1.clamp)(zIndexValue, 0, container.zLayers));
+        this.initialPosition = this.position.copy();
+        this.offset = Vector_1.Vector.origin;
+        const particles = container.particles;
+        particles.needsSort = particles.needsSort || particles.lastZIndex < this.position.z;
+        particles.lastZIndex = this.position.z;
+        this.zIndexFactor = this.position.z / container.zLayers;
+        this.sides = 24;
+        let drawer = container.drawers.get(this.shape);
+        if (!drawer) {
+            drawer = __classPrivateFieldGet(this, _Particle_engine, "f").plugins.getShapeDrawer(this.shape);
+            if (drawer) {
+                container.drawers.set(this.shape, drawer);
+            }
+        }
+        if (drawer === null || drawer === void 0 ? void 0 : drawer.loadShape) {
+            drawer === null || drawer === void 0 ? void 0 : drawer.loadShape(this);
+        }
+        const sideCountFunc = drawer === null || drawer === void 0 ? void 0 : drawer.getSidesCount;
+        if (sideCountFunc) {
+            this.sides = sideCountFunc(this);
+        }
+        this.life = this.loadLife();
+        this.spawning = this.life.delay > 0;
+        this.shadowColor = (0, ColorUtils_1.colorToRgb)(this.options.shadow.color);
+        for (const updater of container.particles.updaters) {
+            if (updater.init) {
+                updater.init(this);
+            }
+        }
+        if (drawer && drawer.particleInit) {
+            drawer.particleInit(container, this);
+        }
+        for (const [, plugin] of container.plugins) {
+            if (plugin.particleCreated) {
+                plugin.particleCreated(this);
+            }
+        }
+    }
+    isVisible() {
+        return !this.destroyed && !this.spawning && this.isInsideCanvas();
+    }
+    isInsideCanvas() {
+        const radius = this.getRadius(), canvasSize = this.container.canvas.size;
+        return (this.position.x >= -radius &&
+            this.position.y >= -radius &&
+            this.position.y <= canvasSize.height + radius &&
+            this.position.x <= canvasSize.width + radius);
+    }
+    draw(delta) {
+        const container = this.container;
+        for (const [, plugin] of container.plugins) {
+            container.canvas.drawParticlePlugin(plugin, this, delta);
+        }
+        container.canvas.drawParticle(this, delta);
+    }
+    getPosition() {
+        return {
+            x: this.position.x + this.offset.x,
+            y: this.position.y + this.offset.y,
+            z: this.position.z,
+        };
+    }
+    getRadius() {
+        var _a;
+        return (_a = this.bubble.radius) !== null && _a !== void 0 ? _a : this.size.value;
+    }
+    getMass() {
+        return (this.getRadius() ** 2 * Math.PI) / 2;
+    }
+    getFillColor() {
+        var _a, _b;
+        const color = (_a = this.bubble.color) !== null && _a !== void 0 ? _a : (0, ColorUtils_1.getHslFromAnimation)(this.color);
+        if (color && this.roll && (this.backColor || this.roll.alter)) {
+            const backFactor = this.options.roll.mode === "both" ? 2 : 1, backSum = this.options.roll.mode === "horizontal" ? Math.PI / 2 : 0, rolled = Math.floor((((_b = this.roll.angle) !== null && _b !== void 0 ? _b : 0) + backSum) / (Math.PI / backFactor)) % 2;
+            if (rolled) {
+                if (this.backColor) {
+                    return this.backColor;
+                }
+                if (this.roll.alter) {
+                    return (0, CanvasUtils_1.alterHsl)(color, this.roll.alter.type, this.roll.alter.value);
+                }
+            }
+        }
+        return color;
+    }
+    getStrokeColor() {
+        var _a, _b;
+        return (_b = (_a = this.bubble.color) !== null && _a !== void 0 ? _a : (0, ColorUtils_1.getHslFromAnimation)(this.strokeColor)) !== null && _b !== void 0 ? _b : this.getFillColor();
+    }
+    destroy(override) {
+        this.destroyed = true;
+        this.bubble.inRange = false;
+        if (this.unbreakable) {
+            return;
+        }
+        this.destroyed = true;
+        this.bubble.inRange = false;
+        for (const [, plugin] of this.container.plugins) {
+            if (plugin.particleDestroyed) {
+                plugin.particleDestroyed(this, override);
+            }
+        }
+        if (override) {
+            return;
+        }
+        const destroyOptions = this.options.destroy;
+        if (destroyOptions.mode === "split") {
+            this.split();
+        }
+    }
+    reset() {
+        if (this.opacity) {
+            this.opacity.loops = 0;
+        }
+        this.size.loops = 0;
+    }
+    split() {
+        const splitOptions = this.options.destroy.split;
+        if (splitOptions.count >= 0 && this.splitCount++ > splitOptions.count) {
+            return;
+        }
+        const rate = (0, NumberUtils_1.getRangeValue)(splitOptions.rate.value);
+        for (let i = 0; i < rate; i++) {
+            this.container.particles.addSplitParticle(this);
+        }
+    }
+    calcPosition(container, position, zIndex, tryCount = 0) {
+        var _a, _b, _c, _d;
+        for (const [, plugin] of container.plugins) {
+            const pluginPos = plugin.particlePosition !== undefined ? plugin.particlePosition(position, this) : undefined;
+            if (pluginPos !== undefined) {
+                return Vector3d_1.Vector3d.create(pluginPos.x, pluginPos.y, zIndex);
+            }
+        }
+        const canvasSize = container.canvas.size, exactPosition = (0, NumberUtils_1.calcExactPositionOrRandomFromSize)({
+            size: canvasSize,
+            position: position,
+        }), pos = Vector3d_1.Vector3d.create(exactPosition.x, exactPosition.y, zIndex), radius = this.getRadius(), outModes = this.options.move.outModes, fixHorizontal = (outMode) => {
+            fixOutMode({
+                outMode,
+                checkModes: ["bounce", "bounce-horizontal"],
+                coord: pos.x,
+                maxCoord: container.canvas.size.width,
+                setCb: (value) => (pos.x += value),
+                radius,
+            });
+        }, fixVertical = (outMode) => {
+            fixOutMode({
+                outMode,
+                checkModes: ["bounce", "bounce-vertical"],
+                coord: pos.y,
+                maxCoord: container.canvas.size.height,
+                setCb: (value) => (pos.y += value),
+                radius,
+            });
+        };
+        fixHorizontal((_a = outModes.left) !== null && _a !== void 0 ? _a : outModes.default);
+        fixHorizontal((_b = outModes.right) !== null && _b !== void 0 ? _b : outModes.default);
+        fixVertical((_c = outModes.top) !== null && _c !== void 0 ? _c : outModes.default);
+        fixVertical((_d = outModes.bottom) !== null && _d !== void 0 ? _d : outModes.default);
+        if (this.checkOverlap(pos, tryCount)) {
+            return this.calcPosition(container, undefined, zIndex, tryCount + 1);
+        }
+        return pos;
+    }
+    checkOverlap(pos, tryCount = 0) {
+        const collisionsOptions = this.options.collisions, radius = this.getRadius();
+        if (!collisionsOptions.enable) {
+            return false;
+        }
+        const overlapOptions = collisionsOptions.overlap;
+        if (overlapOptions.enable) {
+            return false;
+        }
+        const retries = overlapOptions.retries;
+        if (retries >= 0 && tryCount > retries) {
+            throw new Error("Particle is overlapping and can't be placed");
+        }
+        let overlaps = false;
+        for (const particle of this.container.particles.array) {
+            if ((0, NumberUtils_1.getDistance)(pos, particle.position) < radius + particle.getRadius()) {
+                overlaps = true;
+                break;
+            }
+        }
+        return overlaps;
+    }
+    calculateVelocity() {
+        const baseVelocity = (0, NumberUtils_1.getParticleBaseVelocity)(this.direction), res = baseVelocity.copy(), moveOptions = this.options.move, rad = (Math.PI / 180) * (0, NumberUtils_1.getRangeValue)(moveOptions.angle.value), radOffset = (Math.PI / 180) * (0, NumberUtils_1.getRangeValue)(moveOptions.angle.offset), range = {
+            left: radOffset - rad / 2,
+            right: radOffset + rad / 2,
+        };
+        if (!moveOptions.straight) {
+            res.angle += (0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(range.left, range.right));
+        }
+        if (moveOptions.random && typeof moveOptions.speed === "number") {
+            res.length *= Math.random();
+        }
+        return res;
+    }
+    loadShapeData(shapeOptions, reduceDuplicates) {
+        const shapeData = shapeOptions.options[this.shape];
+        if (shapeData) {
+            return (0, Utils_1.deepExtend)({}, shapeData instanceof Array ? (0, Utils_1.itemFromArray)(shapeData, this.id, reduceDuplicates) : shapeData);
+        }
+    }
+    loadLife() {
+        const container = this.container, particlesOptions = this.options, lifeOptions = particlesOptions.life, life = {
+            delay: container.retina.reduceFactor
+                ? (((0, NumberUtils_1.getRangeValue)(lifeOptions.delay.value) * (lifeOptions.delay.sync ? 1 : Math.random())) /
+                    container.retina.reduceFactor) *
+                    1000
+                : 0,
+            delayTime: 0,
+            duration: container.retina.reduceFactor
+                ? (((0, NumberUtils_1.getRangeValue)(lifeOptions.duration.value) * (lifeOptions.duration.sync ? 1 : Math.random())) /
+                    container.retina.reduceFactor) *
+                    1000
+                : 0,
+            time: 0,
+            count: particlesOptions.life.count,
+        };
+        if (life.duration <= 0) {
+            life.duration = -1;
+        }
+        if (life.count <= 0) {
+            life.count = -1;
+        }
+        return life;
+    }
+}
+exports.Particle = Particle;
+_Particle_engine = new WeakMap();

package/cjs/Core/Particles.js

@@ -0,0 +1,320 @@
+"use strict";
+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);
+};
+var _Particles_engine;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Particles = void 0;
+const NumberUtils_1 = require("../Utils/NumberUtils");
+const InteractionManager_1 = require("./Utils/InteractionManager");
+const Particle_1 = require("./Particle");
+const ParticlesOptions_1 = require("../Options/Classes/Particles/ParticlesOptions");
+const Point_1 = require("./Utils/Point");
+const QuadTree_1 = require("./Utils/QuadTree");
+const Rectangle_1 = require("./Utils/Rectangle");
+class Particles {
+    constructor(engine, container) {
+        this.container = container;
+        _Particles_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Particles_engine, engine, "f");
+        this.nextId = 0;
+        this.array = [];
+        this.zArray = [];
+        this.limit = 0;
+        this.needsSort = false;
+        this.lastZIndex = 0;
+        this.freqs = {
+            links: new Map(),
+            triangles: new Map(),
+        };
+        this.interactionManager = new InteractionManager_1.InteractionManager(__classPrivateFieldGet(this, _Particles_engine, "f"), container);
+        const canvasSize = this.container.canvas.size;
+        this.linksColors = new Map();
+        this.quadTree = new QuadTree_1.QuadTree(new Rectangle_1.Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
+        this.movers = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getMovers(container, true);
+        this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
+    }
+    get count() {
+        return this.array.length;
+    }
+    init() {
+        var _a;
+        const container = this.container, options = container.actualOptions;
+        this.lastZIndex = 0;
+        this.needsSort = false;
+        this.freqs.links = new Map();
+        this.freqs.triangles = new Map();
+        let handled = false;
+        this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
+        this.interactionManager.init();
+        for (const [, plugin] of container.plugins) {
+            if (plugin.particlesInitialization !== undefined) {
+                handled = plugin.particlesInitialization();
+            }
+            if (handled) {
+                break;
+            }
+        }
+        this.addManualParticles();
+        if (!handled) {
+            for (const group in options.particles.groups) {
+                const groupOptions = options.particles.groups[group];
+                for (let i = this.count, j = 0; j < ((_a = groupOptions.number) === null || _a === void 0 ? void 0 : _a.value) && i < options.particles.number.value; i++, j++) {
+                    this.addParticle(undefined, groupOptions, group);
+                }
+            }
+            for (let i = this.count; i < options.particles.number.value; i++) {
+                this.addParticle();
+            }
+        }
+        container.pathGenerator.init(container);
+    }
+    async redraw() {
+        this.clear();
+        this.init();
+        await this.draw({ value: 0, factor: 0 });
+    }
+    removeAt(index, quantity = 1, group, override) {
+        if (!(index >= 0 && index <= this.count)) {
+            return;
+        }
+        let deleted = 0;
+        for (let i = index; deleted < quantity && i < this.count; i++) {
+            const particle = this.array[i];
+            if (!particle || particle.group !== group) {
+                continue;
+            }
+            particle.destroy(override);
+            this.array.splice(i--, 1);
+            const zIdx = this.zArray.indexOf(particle);
+            this.zArray.splice(zIdx, 1);
+            deleted++;
+        }
+    }
+    remove(particle, group, override) {
+        this.removeAt(this.array.indexOf(particle), undefined, group, override);
+    }
+    async update(delta) {
+        const container = this.container, particlesToDelete = [];
+        container.pathGenerator.update();
+        for (const [, plugin] of container.plugins) {
+            if (plugin.update !== undefined) {
+                plugin.update(delta);
+            }
+        }
+        for (const particle of this.array) {
+            const resizeFactor = container.canvas.resizeFactor;
+            if (resizeFactor && !particle.ignoresResizeRatio) {
+                particle.position.x *= resizeFactor.width;
+                particle.position.y *= resizeFactor.height;
+            }
+            particle.ignoresResizeRatio = false;
+            particle.bubble.inRange = false;
+            for (const [, plugin] of this.container.plugins) {
+                if (particle.destroyed) {
+                    break;
+                }
+                if (plugin.particleUpdate) {
+                    plugin.particleUpdate(particle, delta);
+                }
+            }
+            for (const mover of this.movers) {
+                if (mover.isEnabled(particle)) {
+                    mover.move(particle, delta);
+                }
+            }
+            if (particle.destroyed) {
+                particlesToDelete.push(particle);
+                continue;
+            }
+            this.quadTree.insert(new Point_1.Point(particle.getPosition(), particle));
+        }
+        for (const particle of particlesToDelete) {
+            this.remove(particle);
+        }
+        await this.interactionManager.externalInteract(delta);
+        for (const particle of container.particles.array) {
+            for (const updater of this.updaters) {
+                updater.update(particle, delta);
+            }
+            if (!particle.destroyed && !particle.spawning) {
+                await this.interactionManager.particlesInteract(particle, delta);
+            }
+        }
+        delete container.canvas.resizeFactor;
+    }
+    async draw(delta) {
+        const container = this.container, canvasSize = this.container.canvas.size;
+        this.quadTree = new QuadTree_1.QuadTree(new Rectangle_1.Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
+        container.canvas.clear();
+        await this.update(delta);
+        if (this.needsSort) {
+            this.zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
+            this.lastZIndex = this.zArray[this.zArray.length - 1].position.z;
+            this.needsSort = false;
+        }
+        for (const [, plugin] of container.plugins) {
+            container.canvas.drawPlugin(plugin, delta);
+        }
+        for (const p of this.zArray) {
+            p.draw(delta);
+        }
+    }
+    clear() {
+        this.array = [];
+        this.zArray = [];
+    }
+    push(nb, mouse, overrideOptions, group) {
+        this.pushing = true;
+        for (let i = 0; i < nb; i++) {
+            this.addParticle(mouse === null || mouse === void 0 ? void 0 : mouse.position, overrideOptions, group);
+        }
+        this.pushing = false;
+    }
+    addParticle(position, overrideOptions, group) {
+        const container = this.container, options = container.actualOptions, limit = options.particles.number.limit * container.density;
+        if (limit > 0) {
+            const countToRemove = this.count + 1 - limit;
+            if (countToRemove > 0) {
+                this.removeQuantity(countToRemove);
+            }
+        }
+        return this.pushParticle(position, overrideOptions, group);
+    }
+    addSplitParticle(parent) {
+        const splitOptions = parent.options.destroy.split, options = new ParticlesOptions_1.ParticlesOptions();
+        options.load(parent.options);
+        const factor = (0, NumberUtils_1.getRangeValue)(splitOptions.factor.value);
+        options.color.load({
+            value: {
+                hsl: parent.getFillColor(),
+            },
+        });
+        if (typeof options.size.value === "number") {
+            options.size.value /= factor;
+        }
+        else {
+            options.size.value.min /= factor;
+            options.size.value.max /= factor;
+        }
+        options.load(splitOptions.particles);
+        const offset = splitOptions.sizeOffset ? (0, NumberUtils_1.setRangeValue)(-parent.size.value, parent.size.value) : 0, position = {
+            x: parent.position.x + (0, NumberUtils_1.randomInRange)(offset),
+            y: parent.position.y + (0, NumberUtils_1.randomInRange)(offset),
+        };
+        return this.pushParticle(position, options, parent.group, (particle) => {
+            if (particle.size.value < 0.5) {
+                return false;
+            }
+            particle.velocity.length = (0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(parent.velocity.length, particle.velocity.length));
+            particle.splitCount = parent.splitCount + 1;
+            particle.unbreakable = true;
+            setTimeout(() => {
+                particle.unbreakable = false;
+            }, 500);
+            return true;
+        });
+    }
+    removeQuantity(quantity, group) {
+        this.removeAt(0, quantity, group);
+    }
+    getLinkFrequency(p1, p2) {
+        const range = (0, NumberUtils_1.setRangeValue)(p1.id, p2.id), key = `${(0, NumberUtils_1.getRangeMin)(range)}_${(0, NumberUtils_1.getRangeMax)(range)}`;
+        let res = this.freqs.links.get(key);
+        if (res === undefined) {
+            res = Math.random();
+            this.freqs.links.set(key, res);
+        }
+        return res;
+    }
+    getTriangleFrequency(p1, p2, p3) {
+        let [id1, id2, id3] = [p1.id, p2.id, p3.id];
+        if (id1 > id2) {
+            [id2, id1] = [id1, id2];
+        }
+        if (id2 > id3) {
+            [id3, id2] = [id2, id3];
+        }
+        if (id1 > id3) {
+            [id3, id1] = [id1, id3];
+        }
+        const key = `${id1}_${id2}_${id3}`;
+        let res = this.freqs.triangles.get(key);
+        if (res === undefined) {
+            res = Math.random();
+            this.freqs.triangles.set(key, res);
+        }
+        return res;
+    }
+    addManualParticles() {
+        const container = this.container, options = container.actualOptions;
+        for (const particle of options.manualParticles) {
+            this.addParticle((0, NumberUtils_1.calcPositionFromSize)({
+                size: container.canvas.size,
+                position: particle.position,
+            }), particle.options);
+        }
+    }
+    setDensity() {
+        const options = this.container.actualOptions;
+        for (const group in options.particles.groups) {
+            this.applyDensity(options.particles.groups[group], 0, group);
+        }
+        this.applyDensity(options.particles, options.manualParticles.length);
+    }
+    handleClickMode(mode) {
+        this.interactionManager.handleClickMode(mode);
+    }
+    applyDensity(options, manualCount, group) {
+        var _a;
+        if (!((_a = options.number.density) === null || _a === void 0 ? void 0 : _a.enable)) {
+            return;
+        }
+        const numberOptions = options.number, densityFactor = this.initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, optParticlesLimit = numberOptions.limit > 0 ? numberOptions.limit : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount, particlesCount = Math.min(this.count, this.array.filter((t) => t.group === group).length);
+        this.limit = numberOptions.limit * densityFactor;
+        if (particlesCount < particlesNumber) {
+            this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
+        }
+        else if (particlesCount > particlesNumber) {
+            this.removeQuantity(particlesCount - particlesNumber, group);
+        }
+    }
+    initDensityFactor(densityOptions) {
+        const container = this.container;
+        if (!container.canvas.element || !densityOptions.enable) {
+            return 1;
+        }
+        const canvas = container.canvas.element, pxRatio = container.retina.pixelRatio;
+        return (canvas.width * canvas.height) / (densityOptions.factor * pxRatio ** 2 * densityOptions.area);
+    }
+    pushParticle(position, overrideOptions, group, initializer) {
+        try {
+            const particle = new Particle_1.Particle(__classPrivateFieldGet(this, _Particles_engine, "f"), this.nextId, this.container, position, overrideOptions, group);
+            let canAdd = true;
+            if (initializer) {
+                canAdd = initializer(particle);
+            }
+            if (!canAdd) {
+                return;
+            }
+            this.array.push(particle);
+            this.zArray.push(particle);
+            this.nextId++;
+            return particle;
+        }
+        catch (e) {
+            console.warn(`error adding particle: ${e}`);
+            return;
+        }
+    }
+}
+exports.Particles = Particles;
+_Particles_engine = new WeakMap();