@tsparticles/engine 3.0.0-alpha.0

package/umd/Utils/ColorUtils.js

@@ -0,0 +1,305 @@
+(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", "./NumberUtils", "./Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getHslAnimationFromHsl = exports.getHslFromAnimation = exports.getLinkRandomColor = exports.getLinkColor = exports.colorMix = exports.getStyleFromHsl = exports.getStyleFromRgb = exports.getRandomRgbColor = exports.hslaToRgba = exports.hslToRgb = exports.stringToRgb = exports.stringToAlpha = exports.rgbToHsl = exports.rangeColorToHsl = exports.colorToHsl = exports.colorToRgb = exports.rangeColorToRgb = exports.addColorManager = void 0;
+    const NumberUtils_1 = require("./NumberUtils");
+    const Utils_1 = require("./Utils");
+    const randomColorValue = "random", midColorValue = "mid", colorManagers = new Map();
+    function addColorManager(manager) {
+        colorManagers.set(manager.key, manager);
+    }
+    exports.addColorManager = addColorManager;
+    function hue2rgb(p, q, t) {
+        if (t < 0) {
+            t += 1;
+        }
+        if (t > 1) {
+            t -= 1;
+        }
+        if (t < 1 / 6) {
+            return p + (q - p) * 6 * t;
+        }
+        if (t < 1 / 2) {
+            return q;
+        }
+        if (t < 2 / 3) {
+            return p + (q - p) * (2 / 3 - t) * 6;
+        }
+        return p;
+    }
+    function stringToRgba(input) {
+        for (const [, manager] of colorManagers) {
+            if (input.startsWith(manager.stringPrefix)) {
+                return manager.parseString(input);
+            }
+        }
+        const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i, hexFixed = input.replace(shorthandRegex, (_, r, g, b, a) => {
+            return r + r + g + g + b + b + (a !== undefined ? a + a : "");
+        }), regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i, result = regex.exec(hexFixed);
+        return result
+            ? {
+                a: result[4] !== undefined ? parseInt(result[4], 16) / 0xff : 1,
+                b: parseInt(result[3], 16),
+                g: parseInt(result[2], 16),
+                r: parseInt(result[1], 16),
+            }
+            : undefined;
+    }
+    function rangeColorToRgb(input, index, useIndex = true) {
+        if (!input) {
+            return;
+        }
+        const color = typeof input === "string" ? { value: input } : input;
+        if (typeof color.value === "string") {
+            return colorToRgb(color.value, index, useIndex);
+        }
+        if (color.value instanceof Array) {
+            return rangeColorToRgb({
+                value: (0, Utils_1.itemFromArray)(color.value, index, useIndex),
+            });
+        }
+        for (const [, manager] of colorManagers) {
+            const res = manager.handleRangeColor(color);
+            if (res) {
+                return res;
+            }
+        }
+    }
+    exports.rangeColorToRgb = rangeColorToRgb;
+    function colorToRgb(input, index, useIndex = true) {
+        if (!input) {
+            return;
+        }
+        const color = typeof input === "string" ? { value: input } : input;
+        if (typeof color.value === "string") {
+            return color.value === randomColorValue ? getRandomRgbColor() : stringToRgb(color.value);
+        }
+        if (color.value instanceof Array) {
+            return colorToRgb({
+                value: (0, Utils_1.itemFromArray)(color.value, index, useIndex),
+            });
+        }
+        for (const [, manager] of colorManagers) {
+            const res = manager.handleColor(color);
+            if (res) {
+                return res;
+            }
+        }
+    }
+    exports.colorToRgb = colorToRgb;
+    function colorToHsl(color, index, useIndex = true) {
+        const rgb = colorToRgb(color, index, useIndex);
+        return rgb ? rgbToHsl(rgb) : undefined;
+    }
+    exports.colorToHsl = colorToHsl;
+    function rangeColorToHsl(color, index, useIndex = true) {
+        const rgb = rangeColorToRgb(color, index, useIndex);
+        return rgb ? rgbToHsl(rgb) : undefined;
+    }
+    exports.rangeColorToHsl = rangeColorToHsl;
+    function rgbToHsl(color) {
+        const r1 = color.r / 255, g1 = color.g / 255, b1 = color.b / 255, max = Math.max(r1, g1, b1), min = Math.min(r1, g1, b1), res = {
+            h: 0,
+            l: (max + min) / 2,
+            s: 0,
+        };
+        if (max !== min) {
+            res.s = res.l < 0.5 ? (max - min) / (max + min) : (max - min) / (2.0 - max - min);
+            res.h =
+                r1 === max
+                    ? (g1 - b1) / (max - min)
+                    : (res.h = g1 === max ? 2.0 + (b1 - r1) / (max - min) : 4.0 + (r1 - g1) / (max - min));
+        }
+        res.l *= 100;
+        res.s *= 100;
+        res.h *= 60;
+        if (res.h < 0) {
+            res.h += 360;
+        }
+        if (res.h >= 360) {
+            res.h -= 360;
+        }
+        return res;
+    }
+    exports.rgbToHsl = rgbToHsl;
+    function stringToAlpha(input) {
+        var _a;
+        return (_a = stringToRgba(input)) === null || _a === void 0 ? void 0 : _a.a;
+    }
+    exports.stringToAlpha = stringToAlpha;
+    function stringToRgb(input) {
+        return stringToRgba(input);
+    }
+    exports.stringToRgb = stringToRgb;
+    function hslToRgb(hsl) {
+        const result = { b: 0, g: 0, r: 0 }, hslPercent = {
+            h: hsl.h / 360,
+            l: hsl.l / 100,
+            s: hsl.s / 100,
+        };
+        if (!hslPercent.s) {
+            result.b = hslPercent.l;
+            result.g = hslPercent.l;
+            result.r = hslPercent.l;
+        }
+        else {
+            const q = hslPercent.l < 0.5
+                ? hslPercent.l * (1 + hslPercent.s)
+                : hslPercent.l + hslPercent.s - hslPercent.l * hslPercent.s, p = 2 * hslPercent.l - q;
+            result.r = hue2rgb(p, q, hslPercent.h + 1 / 3);
+            result.g = hue2rgb(p, q, hslPercent.h);
+            result.b = hue2rgb(p, q, hslPercent.h - 1 / 3);
+        }
+        result.r = Math.floor(result.r * 255);
+        result.g = Math.floor(result.g * 255);
+        result.b = Math.floor(result.b * 255);
+        return result;
+    }
+    exports.hslToRgb = hslToRgb;
+    function hslaToRgba(hsla) {
+        const rgbResult = hslToRgb(hsla);
+        return {
+            a: hsla.a,
+            b: rgbResult.b,
+            g: rgbResult.g,
+            r: rgbResult.r,
+        };
+    }
+    exports.hslaToRgba = hslaToRgba;
+    function getRandomRgbColor(min) {
+        const fixedMin = min !== null && min !== void 0 ? min : 0;
+        return {
+            b: Math.floor((0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(fixedMin, 256))),
+            g: Math.floor((0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(fixedMin, 256))),
+            r: Math.floor((0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(fixedMin, 256))),
+        };
+    }
+    exports.getRandomRgbColor = getRandomRgbColor;
+    function getStyleFromRgb(color, opacity) {
+        return `rgba(${color.r}, ${color.g}, ${color.b}, ${opacity !== null && opacity !== void 0 ? opacity : 1})`;
+    }
+    exports.getStyleFromRgb = getStyleFromRgb;
+    function getStyleFromHsl(color, opacity) {
+        return `hsla(${color.h}, ${color.s}%, ${color.l}%, ${opacity !== null && opacity !== void 0 ? opacity : 1})`;
+    }
+    exports.getStyleFromHsl = getStyleFromHsl;
+    function colorMix(color1, color2, size1, size2) {
+        let rgb1 = color1, rgb2 = color2;
+        if (rgb1.r === undefined) {
+            rgb1 = hslToRgb(color1);
+        }
+        if (rgb2.r === undefined) {
+            rgb2 = hslToRgb(color2);
+        }
+        return {
+            b: (0, NumberUtils_1.mix)(rgb1.b, rgb2.b, size1, size2),
+            g: (0, NumberUtils_1.mix)(rgb1.g, rgb2.g, size1, size2),
+            r: (0, NumberUtils_1.mix)(rgb1.r, rgb2.r, size1, size2),
+        };
+    }
+    exports.colorMix = colorMix;
+    function getLinkColor(p1, p2, linkColor) {
+        var _a, _b;
+        if (linkColor === randomColorValue) {
+            return getRandomRgbColor();
+        }
+        else if (linkColor === midColorValue) {
+            const sourceColor = (_a = p1.getFillColor()) !== null && _a !== void 0 ? _a : p1.getStrokeColor(), destColor = (_b = p2 === null || p2 === void 0 ? void 0 : p2.getFillColor()) !== null && _b !== void 0 ? _b : p2 === null || p2 === void 0 ? void 0 : p2.getStrokeColor();
+            if (sourceColor && destColor && p2) {
+                return colorMix(sourceColor, destColor, p1.getRadius(), p2.getRadius());
+            }
+            else {
+                const hslColor = sourceColor !== null && sourceColor !== void 0 ? sourceColor : destColor;
+                if (hslColor) {
+                    return hslToRgb(hslColor);
+                }
+            }
+        }
+        else {
+            return linkColor;
+        }
+    }
+    exports.getLinkColor = getLinkColor;
+    function getLinkRandomColor(optColor, blink, consent) {
+        const color = typeof optColor === "string" ? optColor : optColor.value;
+        if (color === randomColorValue) {
+            if (consent) {
+                return rangeColorToRgb({
+                    value: color,
+                });
+            }
+            if (blink) {
+                return randomColorValue;
+            }
+            return midColorValue;
+        }
+        else if (color === midColorValue) {
+            return midColorValue;
+        }
+        else {
+            return rangeColorToRgb({
+                value: color,
+            });
+        }
+    }
+    exports.getLinkRandomColor = getLinkRandomColor;
+    function getHslFromAnimation(animation) {
+        return animation !== undefined
+            ? {
+                h: animation.h.value,
+                s: animation.s.value,
+                l: animation.l.value,
+            }
+            : undefined;
+    }
+    exports.getHslFromAnimation = getHslFromAnimation;
+    function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
+        const resColor = {
+            h: {
+                enable: false,
+                value: hsl.h,
+            },
+            s: {
+                enable: false,
+                value: hsl.s,
+            },
+            l: {
+                enable: false,
+                value: hsl.l,
+            },
+        };
+        if (animationOptions) {
+            setColorAnimation(resColor.h, animationOptions.h, reduceFactor);
+            setColorAnimation(resColor.s, animationOptions.s, reduceFactor);
+            setColorAnimation(resColor.l, animationOptions.l, reduceFactor);
+        }
+        return resColor;
+    }
+    exports.getHslAnimationFromHsl = getHslAnimationFromHsl;
+    function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
+        colorValue.enable = colorAnimation.enable;
+        if (colorValue.enable) {
+            colorValue.velocity = ((0, NumberUtils_1.getRangeValue)(colorAnimation.speed) / 100) * reduceFactor;
+            colorValue.decay = 1 - (0, NumberUtils_1.getRangeValue)(colorAnimation.decay);
+            colorValue.status = "increasing";
+            colorValue.loops = 0;
+            colorValue.maxLoops = (0, NumberUtils_1.getRangeValue)(colorAnimation.count);
+            if (!colorAnimation.sync) {
+                colorValue.velocity *= (0, NumberUtils_1.getRandom)();
+                colorValue.value *= (0, NumberUtils_1.getRandom)();
+            }
+            colorValue.initialValue = colorValue.value;
+        }
+        else {
+            colorValue.velocity = 0;
+        }
+    }
+});

package/umd/Utils/EventDispatcher.js

@@ -0,0 +1,58 @@
+(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.EventDispatcher = void 0;
+    class EventDispatcher {
+        constructor() {
+            this._listeners = new Map();
+        }
+        addEventListener(type, listener) {
+            var _a;
+            this.removeEventListener(type, listener);
+            if (!this._listeners.get(type)) {
+                this._listeners.set(type, []);
+            }
+            (_a = this._listeners.get(type)) === null || _a === void 0 ? void 0 : _a.push(listener);
+        }
+        dispatchEvent(type, args) {
+            var _a;
+            (_a = this._listeners.get(type)) === null || _a === void 0 ? void 0 : _a.forEach((handler) => handler(args));
+        }
+        hasEventListener(type) {
+            return !!this._listeners.get(type);
+        }
+        removeAllEventListeners(type) {
+            if (!type) {
+                this._listeners = new Map();
+            }
+            else {
+                this._listeners.delete(type);
+            }
+        }
+        removeEventListener(type, listener) {
+            const arr = this._listeners.get(type);
+            if (!arr) {
+                return;
+            }
+            const length = arr.length, idx = arr.indexOf(listener);
+            if (idx < 0) {
+                return;
+            }
+            if (length === 1) {
+                this._listeners.delete(type);
+            }
+            else {
+                arr.splice(idx, 1);
+            }
+        }
+    }
+    exports.EventDispatcher = EventDispatcher;
+});

package/umd/Utils/HslColorManager.js

@@ -0,0 +1,54 @@
+(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", "./NumberUtils", "./ColorUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HslColorManager = void 0;
+    const NumberUtils_1 = require("./NumberUtils");
+    const ColorUtils_1 = require("./ColorUtils");
+    class HslColorManager {
+        constructor() {
+            this.key = "hsl";
+            this.stringPrefix = "hsl";
+        }
+        handleColor(color) {
+            var _a;
+            const colorValue = color.value, hslColor = (_a = colorValue.hsl) !== null && _a !== void 0 ? _a : color.value;
+            if (hslColor.h !== undefined && hslColor.s !== undefined && hslColor.l !== undefined) {
+                return (0, ColorUtils_1.hslToRgb)(hslColor);
+            }
+        }
+        handleRangeColor(color) {
+            var _a;
+            const colorValue = color.value, hslColor = (_a = colorValue.hsl) !== null && _a !== void 0 ? _a : color.value;
+            if (hslColor.h !== undefined && hslColor.l !== undefined) {
+                return (0, ColorUtils_1.hslToRgb)({
+                    h: (0, NumberUtils_1.getRangeValue)(hslColor.h),
+                    l: (0, NumberUtils_1.getRangeValue)(hslColor.l),
+                    s: (0, NumberUtils_1.getRangeValue)(hslColor.s),
+                });
+            }
+        }
+        parseString(input) {
+            if (!input.startsWith("hsl")) {
+                return;
+            }
+            const regex = /hsla?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input);
+            return result
+                ? (0, ColorUtils_1.hslaToRgba)({
+                    a: result.length > 4 ? (0, NumberUtils_1.parseAlpha)(result[5]) : 1,
+                    h: parseInt(result[1], 10),
+                    l: parseInt(result[3], 10),
+                    s: parseInt(result[2], 10),
+                })
+                : undefined;
+        }
+    }
+    exports.HslColorManager = HslColorManager;
+});

package/umd/Utils/NumberUtils.js

@@ -0,0 +1,185 @@
+(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", "../Core/Utils/Vector"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseAlpha = exports.calcExactPositionOrRandomFromSizeRanged = exports.calcExactPositionOrRandomFromSize = exports.calcPositionOrRandomFromSizeRanged = exports.calcPositionOrRandomFromSize = exports.calcPositionFromSize = exports.collisionVelocity = exports.getParticleBaseVelocity = exports.getParticleDirectionAngle = exports.getDistance = exports.getDistances = exports.getValue = exports.setRangeValue = exports.getRangeMax = exports.getRangeMin = exports.getRangeValue = exports.randomInRange = exports.mix = exports.clamp = exports.getRandom = exports.setRandom = exports.getEasing = exports.addEasing = void 0;
+    const Vector_1 = require("../Core/Utils/Vector");
+    let _random = Math.random;
+    const easings = new Map();
+    function addEasing(name, easing) {
+        if (!easings.get(name)) {
+            easings.set(name, easing);
+        }
+    }
+    exports.addEasing = addEasing;
+    function getEasing(name) {
+        return easings.get(name) || ((value) => value);
+    }
+    exports.getEasing = getEasing;
+    function setRandom(rnd = Math.random) {
+        _random = rnd;
+    }
+    exports.setRandom = setRandom;
+    function getRandom() {
+        return clamp(_random(), 0, 1 - 1e-16);
+    }
+    exports.getRandom = getRandom;
+    function clamp(num, min, max) {
+        return Math.min(Math.max(num, min), max);
+    }
+    exports.clamp = clamp;
+    function mix(comp1, comp2, weight1, weight2) {
+        return Math.floor((comp1 * weight1 + comp2 * weight2) / (weight1 + weight2));
+    }
+    exports.mix = mix;
+    function randomInRange(r) {
+        const max = getRangeMax(r);
+        let min = getRangeMin(r);
+        if (max === min) {
+            min = 0;
+        }
+        return getRandom() * (max - min) + min;
+    }
+    exports.randomInRange = randomInRange;
+    function getRangeValue(value) {
+        return typeof value === "number" ? value : randomInRange(value);
+    }
+    exports.getRangeValue = getRangeValue;
+    function getRangeMin(value) {
+        return typeof value === "number" ? value : value.min;
+    }
+    exports.getRangeMin = getRangeMin;
+    function getRangeMax(value) {
+        return typeof value === "number" ? value : value.max;
+    }
+    exports.getRangeMax = getRangeMax;
+    function setRangeValue(source, value) {
+        if (source === value || (value === undefined && typeof source === "number")) {
+            return source;
+        }
+        const min = getRangeMin(source), max = getRangeMax(source);
+        return value !== undefined
+            ? {
+                min: Math.min(min, value),
+                max: Math.max(max, value),
+            }
+            : setRangeValue(min, max);
+    }
+    exports.setRangeValue = setRangeValue;
+    function getValue(options) {
+        const random = options.random, { enable, minimumValue } = typeof random === "boolean"
+            ? {
+                enable: random,
+                minimumValue: 0,
+            }
+            : random;
+        return enable ? getRangeValue(setRangeValue(options.value, minimumValue)) : getRangeValue(options.value);
+    }
+    exports.getValue = getValue;
+    function getDistances(pointA, pointB) {
+        const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
+        return { dx: dx, dy: dy, distance: Math.sqrt(dx ** 2 + dy ** 2) };
+    }
+    exports.getDistances = getDistances;
+    function getDistance(pointA, pointB) {
+        return getDistances(pointA, pointB).distance;
+    }
+    exports.getDistance = getDistance;
+    function getParticleDirectionAngle(direction, position, center) {
+        if (typeof direction === "number") {
+            return (direction * Math.PI) / 180;
+        }
+        else {
+            switch (direction) {
+                case "top":
+                    return -Math.PI / 2;
+                case "top-right":
+                    return -Math.PI / 4;
+                case "right":
+                    return 0;
+                case "bottom-right":
+                    return Math.PI / 4;
+                case "bottom":
+                    return Math.PI / 2;
+                case "bottom-left":
+                    return (3 * Math.PI) / 4;
+                case "left":
+                    return Math.PI;
+                case "top-left":
+                    return (-3 * Math.PI) / 4;
+                case "inside":
+                    return Math.atan2(center.y - position.y, center.x - position.x);
+                case "outside":
+                    return Math.atan2(position.y - center.y, position.x - center.x);
+                default:
+                    return getRandom() * Math.PI * 2;
+            }
+        }
+    }
+    exports.getParticleDirectionAngle = getParticleDirectionAngle;
+    function getParticleBaseVelocity(direction) {
+        const baseVelocity = Vector_1.Vector.origin;
+        baseVelocity.length = 1;
+        baseVelocity.angle = direction;
+        return baseVelocity;
+    }
+    exports.getParticleBaseVelocity = getParticleBaseVelocity;
+    function collisionVelocity(v1, v2, m1, m2) {
+        return Vector_1.Vector.create((v1.x * (m1 - m2)) / (m1 + m2) + (v2.x * 2 * m2) / (m1 + m2), v1.y);
+    }
+    exports.collisionVelocity = collisionVelocity;
+    function calcPositionFromSize(data) {
+        return data.position && data.position.x !== undefined && data.position.y !== undefined
+            ? {
+                x: (data.position.x * data.size.width) / 100,
+                y: (data.position.y * data.size.height) / 100,
+            }
+            : undefined;
+    }
+    exports.calcPositionFromSize = calcPositionFromSize;
+    function calcPositionOrRandomFromSize(data) {
+        var _a, _b, _c, _d;
+        return {
+            x: (((_b = (_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : getRandom() * 100) * data.size.width) / 100,
+            y: (((_d = (_c = data.position) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : getRandom() * 100) * data.size.height) / 100,
+        };
+    }
+    exports.calcPositionOrRandomFromSize = calcPositionOrRandomFromSize;
+    function calcPositionOrRandomFromSizeRanged(data) {
+        var _a, _b;
+        const position = {
+            x: ((_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== undefined ? getRangeValue(data.position.x) : undefined,
+            y: ((_b = data.position) === null || _b === void 0 ? void 0 : _b.y) !== undefined ? getRangeValue(data.position.y) : undefined,
+        };
+        return calcPositionOrRandomFromSize({ size: data.size, position });
+    }
+    exports.calcPositionOrRandomFromSizeRanged = calcPositionOrRandomFromSizeRanged;
+    function calcExactPositionOrRandomFromSize(data) {
+        var _a, _b, _c, _d;
+        return {
+            x: (_b = (_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : getRandom() * data.size.width,
+            y: (_d = (_c = data.position) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : getRandom() * data.size.height,
+        };
+    }
+    exports.calcExactPositionOrRandomFromSize = calcExactPositionOrRandomFromSize;
+    function calcExactPositionOrRandomFromSizeRanged(data) {
+        var _a, _b;
+        const position = {
+            x: ((_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== undefined ? getRangeValue(data.position.x) : undefined,
+            y: ((_b = data.position) === null || _b === void 0 ? void 0 : _b.y) !== undefined ? getRangeValue(data.position.y) : undefined,
+        };
+        return calcExactPositionOrRandomFromSize({ size: data.size, position });
+    }
+    exports.calcExactPositionOrRandomFromSizeRanged = calcExactPositionOrRandomFromSizeRanged;
+    function parseAlpha(input) {
+        return input ? (input.endsWith("%") ? parseFloat(input) / 100 : parseFloat(input)) : 1;
+    }
+    exports.parseAlpha = parseAlpha;
+});

package/umd/Utils/OptionsUtils.js

@@ -0,0 +1,26 @@
+(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/Particles/ParticlesOptions"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadParticlesOptions = exports.loadOptions = void 0;
+    const ParticlesOptions_1 = require("../Options/Classes/Particles/ParticlesOptions");
+    function loadOptions(options, ...sourceOptionsArr) {
+        for (const sourceOptions of sourceOptionsArr) {
+            options.load(sourceOptions);
+        }
+    }
+    exports.loadOptions = loadOptions;
+    function loadParticlesOptions(engine, container, ...sourceOptionsArr) {
+        const options = new ParticlesOptions_1.ParticlesOptions(engine, container);
+        loadOptions(options, ...sourceOptionsArr);
+        return options;
+    }
+    exports.loadParticlesOptions = loadParticlesOptions;
+});

package/umd/Utils/RgbColorManager.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", "./NumberUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RgbColorManager = void 0;
+    const NumberUtils_1 = require("./NumberUtils");
+    class RgbColorManager {
+        constructor() {
+            this.key = "rgb";
+            this.stringPrefix = "rgb";
+        }
+        handleColor(color) {
+            var _a;
+            const colorValue = color.value, rgbColor = (_a = colorValue.rgb) !== null && _a !== void 0 ? _a : color.value;
+            if (rgbColor.r !== undefined) {
+                return rgbColor;
+            }
+        }
+        handleRangeColor(color) {
+            var _a;
+            const colorValue = color.value, rgbColor = (_a = colorValue.rgb) !== null && _a !== void 0 ? _a : color.value;
+            if (rgbColor.r !== undefined) {
+                return {
+                    r: (0, NumberUtils_1.getRangeValue)(rgbColor.r),
+                    g: (0, NumberUtils_1.getRangeValue)(rgbColor.g),
+                    b: (0, NumberUtils_1.getRangeValue)(rgbColor.b),
+                };
+            }
+        }
+        parseString(input) {
+            if (!input.startsWith(this.stringPrefix)) {
+                return;
+            }
+            const regex = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input);
+            return result
+                ? {
+                    a: result.length > 4 ? (0, NumberUtils_1.parseAlpha)(result[5]) : 1,
+                    b: parseInt(result[3], 10),
+                    g: parseInt(result[2], 10),
+                    r: parseInt(result[1], 10),
+                }
+                : undefined;
+        }
+    }
+    exports.RgbColorManager = RgbColorManager;
+});