@tsparticles/engine 3.0.0-alpha.0

package/cjs/Utils/ColorUtils.js

@@ -0,0 +1,295 @@
+"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/cjs/Utils/EventDispatcher.js

@@ -0,0 +1,48 @@
+"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/cjs/Utils/HslColorManager.js

@@ -0,0 +1,44 @@
+"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/cjs/Utils/NumberUtils.js

@@ -0,0 +1,175 @@
+"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/cjs/Utils/OptionsUtils.js

@@ -0,0 +1,16 @@
+"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/cjs/Utils/RgbColorManager.js

@@ -0,0 +1,43 @@
+"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;