@tsparticles/stencil 4.0.5

package/dist/cjs/index-BY5-j3YK.js

@@ -0,0 +1,1143 @@
+'use strict';
+
+const generatedAttribute = "generated", defaultCompositeValue = "source-over", resizeEvent = "resize", visibilityChangeEvent = "visibilitychange", percentDenominator = 100, half = 0.5, millisecondsToSeconds = 1000, originPoint = {
+    x: 0,
+    y: 0,
+    z: 0,
+}, defaultTransform = {
+    a: 1,
+    b: 0,
+    c: 0,
+    d: 1,
+}, randomColorValue = "random", double = 2, doublePI = Math.PI * double, defaultFps = 60, generatedTrue = "true", generatedFalse = "false", canvasTag = "canvas", defaultRetryCount = 0, squareExp = 2, spatialHashGridCellSize = 100, defaultRemoveQuantity = 1, defaultRatio = 1, defaultReduceFactor = 1, inverseFactorNumerator = 1, rgbMax = 255, hMax = 360, sMax = 100, lMax = 100, hMin = 0, sMin = 0, hPhase = 60, empty = 0, quarter = 0.25, threeQuarter = half + quarter, defaultTransformValue = 1, minimumSize = 0, zIndexFactorOffset = 1, defaultOpacity = 1, removeDeleteCount = 1, removeMinIndex = 0, defaultFpsLimit = 120, minFpsLimit = 0, canvasFirstIndex = 0, loadRandomFactor = 10000, loadMinIndex = 0, one = 1, none = 0, tryCountIncrement = 1, minZ = 0, minLimit = 0, countOffset = 1, minCount = 0, minIndex = 0, defaultDensityFactor = 1, deleteCount = 1, defaultAngle = 0, identity = 1, minStrokeWidth = 0, lFactor = 1, lMin = 0, triple = 3, sextuple = 6, sNormalizedOffset = 1, phaseNumerator = 1, defaultRgbMin = 0, defaultZoom = 1;
+
+exports.MoveDirection = void 0;
+(function (MoveDirection) {
+    MoveDirection["bottom"] = "bottom";
+    MoveDirection["bottomLeft"] = "bottom-left";
+    MoveDirection["bottomRight"] = "bottom-right";
+    MoveDirection["left"] = "left";
+    MoveDirection["none"] = "none";
+    MoveDirection["right"] = "right";
+    MoveDirection["top"] = "top";
+    MoveDirection["topLeft"] = "top-left";
+    MoveDirection["topRight"] = "top-right";
+    MoveDirection["outside"] = "outside";
+    MoveDirection["inside"] = "inside";
+})(exports.MoveDirection || (exports.MoveDirection = {}));
+
+function getZ(source) {
+    return "z" in source ? source.z : originPoint.z;
+}
+class Vector3d {
+    x;
+    y;
+    z;
+    constructor(x = originPoint.x, y = originPoint.y, z = originPoint.z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    static get origin() {
+        return Vector3d.create(originPoint.x, originPoint.y, originPoint.z);
+    }
+    get angle() {
+        return Math.atan2(this.y, this.x);
+    }
+    set angle(angle) {
+        this.#updateFromAngle(angle, this.length);
+    }
+    get length() {
+        return Math.sqrt(this.getLengthSq());
+    }
+    set length(length) {
+        this.#updateFromAngle(this.angle, length);
+    }
+    static clone(source) {
+        return Vector3d.create(source.x, source.y, getZ(source));
+    }
+    static create(x, y, z) {
+        if (typeof x === "number") {
+            return new Vector3d(x, y ?? originPoint.y, z ?? originPoint.z);
+        }
+        return new Vector3d(x.x, x.y, getZ(x));
+    }
+    add(v) {
+        return Vector3d.create(this.x + v.x, this.y + v.y, this.z + getZ(v));
+    }
+    addTo(v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += getZ(v);
+    }
+    copy() {
+        return Vector3d.clone(this);
+    }
+    div(n) {
+        return Vector3d.create(this.x / n, this.y / n, this.z / n);
+    }
+    divTo(n) {
+        this.x /= n;
+        this.y /= n;
+        this.z /= n;
+    }
+    getLengthSq() {
+        return this.x ** squareExp + this.y ** squareExp;
+    }
+    mult(n) {
+        return Vector3d.create(this.x * n, this.y * n, this.z * n);
+    }
+    multTo(n) {
+        this.x *= n;
+        this.y *= n;
+        this.z *= n;
+    }
+    normalize() {
+        const length = this.length;
+        if (length != none) {
+            this.multTo(inverseFactorNumerator / length);
+        }
+    }
+    rotate(angle) {
+        return Vector3d.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle), originPoint.z);
+    }
+    setTo(c) {
+        this.x = c.x;
+        this.y = c.y;
+        this.z = getZ(c);
+    }
+    sub(v) {
+        return Vector3d.create(this.x - v.x, this.y - v.y, this.z - getZ(v));
+    }
+    subFrom(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= getZ(v);
+    }
+    #updateFromAngle(angle, length) {
+        this.x = Math.cos(angle) * length;
+        this.y = Math.sin(angle) * length;
+    }
+}
+class Vector extends Vector3d {
+    constructor(x = originPoint.x, y = originPoint.y) {
+        super(x, y, originPoint.z);
+    }
+    static get origin() {
+        return Vector.create(originPoint.x, originPoint.y);
+    }
+    static clone(source) {
+        return Vector.create(source.x, source.y);
+    }
+    static create(x, y) {
+        if (typeof x === "number") {
+            return new Vector(x, y ?? originPoint.y);
+        }
+        return new Vector(x.x, x.y);
+    }
+}
+
+function isBoolean(arg) {
+    return typeof arg === "boolean";
+}
+function isString(arg) {
+    return typeof arg === "string";
+}
+function isNumber(arg) {
+    return typeof arg === "number";
+}
+function isObject(arg) {
+    return typeof arg === "object" && arg !== null;
+}
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function isNull(arg) {
+    return arg === null || arg === undefined;
+}
+
+const piDeg = 180, degToRadFactor = Math.PI / piDeg;
+let _random = Math.random;
+const _animationLoop = {
+    nextFrame: (cb) => requestAnimationFrame(cb),
+    cancel: (idx) => {
+        cancelAnimationFrame(idx);
+    },
+};
+function getRandom() {
+    const min = 0, max = 1;
+    return clamp(_random(), min, max - Number.EPSILON);
+}
+function getRandomInRange(min, max) {
+    return getRandom() * (max - min) + min;
+}
+function animate(fn) {
+    return _animationLoop.nextFrame(fn);
+}
+function cancelAnimation(handle) {
+    _animationLoop.cancel(handle);
+}
+function clamp(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+function randomInRangeValue(r) {
+    const max = getRangeMax(r), minOffset = 0;
+    let min = getRangeMin(r);
+    if (max === min) {
+        min = minOffset;
+    }
+    return getRandomInRange(min, max);
+}
+function getRangeValue(value) {
+    return isNumber(value) ? value : randomInRangeValue(value);
+}
+function getRangeMin(value) {
+    return isNumber(value) ? value : value.min;
+}
+function getRangeMax(value) {
+    return isNumber(value) ? value : value.max;
+}
+function setRangeValue(source, value) {
+    if (source === value || (value === undefined && isNumber(source))) {
+        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);
+}
+function getDistanceSq(pointA, pointB) {
+    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
+    return dx * dx + dy * dy;
+}
+function checkDistance(pointA, pointB, distance) {
+    return getDistanceSq(pointA, pointB) <= distance * distance;
+}
+function degToRad(degrees) {
+    return degrees * degToRadFactor;
+}
+function getParticleDirectionAngle(direction, position, center) {
+    if (isNumber(direction)) {
+        return degToRad(direction);
+    }
+    switch (direction) {
+        case exports.MoveDirection.top:
+            return -Math.PI * half;
+        case exports.MoveDirection.topRight:
+            return -Math.PI * quarter;
+        case exports.MoveDirection.right:
+            return empty;
+        case exports.MoveDirection.bottomRight:
+            return Math.PI * quarter;
+        case exports.MoveDirection.bottom:
+            return Math.PI * half;
+        case exports.MoveDirection.bottomLeft:
+            return Math.PI * threeQuarter;
+        case exports.MoveDirection.left:
+            return Math.PI;
+        case exports.MoveDirection.topLeft:
+            return -Math.PI * threeQuarter;
+        case exports.MoveDirection.inside:
+            return Math.atan2(center.y - position.y, center.x - position.x);
+        case exports.MoveDirection.outside:
+            return Math.atan2(position.y - center.y, position.x - center.x);
+        default:
+            return getRandom() * doublePI;
+    }
+}
+function getParticleBaseVelocity(direction) {
+    const baseVelocity = Vector.origin;
+    baseVelocity.length = 1;
+    baseVelocity.angle = direction;
+    return baseVelocity;
+}
+function calcExactPositionOrRandomFromSize(data) {
+    const { position, size } = data;
+    return {
+        x: position?.x ?? getRandom() * size.width,
+        y: position?.y ?? getRandom() * size.height,
+    };
+}
+
+var AnimationMode;
+(function (AnimationMode) {
+    AnimationMode["auto"] = "auto";
+    AnimationMode["increase"] = "increase";
+    AnimationMode["decrease"] = "decrease";
+    AnimationMode["random"] = "random";
+})(AnimationMode || (AnimationMode = {}));
+
+var AnimationStatus;
+(function (AnimationStatus) {
+    AnimationStatus["increasing"] = "increasing";
+    AnimationStatus["decreasing"] = "decreasing";
+})(AnimationStatus || (AnimationStatus = {}));
+
+var DestroyType;
+(function (DestroyType) {
+    DestroyType["none"] = "none";
+    DestroyType["max"] = "max";
+    DestroyType["min"] = "min";
+})(DestroyType || (DestroyType = {}));
+
+exports.OutModeDirection = void 0;
+(function (OutModeDirection) {
+    OutModeDirection["bottom"] = "bottom";
+    OutModeDirection["left"] = "left";
+    OutModeDirection["right"] = "right";
+    OutModeDirection["top"] = "top";
+})(exports.OutModeDirection || (exports.OutModeDirection = {}));
+
+exports.PixelMode = void 0;
+(function (PixelMode) {
+    PixelMode["precise"] = "precise";
+    PixelMode["percent"] = "percent";
+})(exports.PixelMode || (exports.PixelMode = {}));
+
+var StartValueType;
+(function (StartValueType) {
+    StartValueType["max"] = "max";
+    StartValueType["min"] = "min";
+    StartValueType["random"] = "random";
+})(StartValueType || (StartValueType = {}));
+
+function memoize(fn, options) {
+    const cache = new Map(), keyFn = options?.keyFn, stableStringify = (obj, seen = new WeakSet()) => {
+        if (obj === null) {
+            return "null";
+        }
+        const t = typeof obj;
+        if (t === "undefined") {
+            return "undefined";
+        }
+        if (t === "number" || t === "boolean" || t === "string") {
+            return JSON.stringify(obj);
+        }
+        if (t === "function") {
+            try {
+                const fn = obj;
+                return fn.toString();
+            }
+            catch {
+                return '"[Function]"';
+            }
+        }
+        if (t === "symbol") {
+            try {
+                return obj.toString();
+            }
+            catch {
+                return '"[Symbol]"';
+            }
+        }
+        if (Array.isArray(obj)) {
+            return `[${obj.map(i => stableStringify(i, seen)).join(",")}]`;
+        }
+        if (seen.has(obj)) {
+            return '"[Circular]"';
+        }
+        seen.add(obj);
+        const keys = Object.keys(obj).sort();
+        return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k], seen)}`).join(",")}}`;
+    }, defaultKeyer = (args) => stableStringify(args), makeKey = (args) => (keyFn ? keyFn(args) : defaultKeyer(args));
+    return (...args) => {
+        const key = makeKey(args), now = Date.now(), entry = cache.get(key);
+        if (entry !== undefined) {
+            {
+                cache.delete(key);
+                cache.set(key, { value: entry.value, ts: entry.ts });
+                return entry.value;
+            }
+        }
+        const result = fn(...args);
+        cache.set(key, { value: result, ts: now });
+        return result;
+    };
+}
+function hasMatchMedia() {
+    return typeof matchMedia !== "undefined";
+}
+function safeDocument() {
+    return globalThis.document;
+}
+function safeMatchMedia(query) {
+    if (!hasMatchMedia()) {
+        return;
+    }
+    return matchMedia(query);
+}
+function safeMutationObserver(callback) {
+    if (typeof MutationObserver === "undefined") {
+        return;
+    }
+    return new MutationObserver(callback);
+}
+function isInArray(value, array) {
+    return value === array || (isArray(array) && array.includes(value));
+}
+function arrayRandomIndex(array) {
+    return Math.floor(getRandom() * array.length);
+}
+function itemFromArray(array, index, useIndex = true) {
+    return array[index !== undefined && useIndex ? index % array.length : arrayRandomIndex(array)];
+}
+function deepExtend(destination, ...sources) {
+    for (const source of sources) {
+        if (isNull(source)) {
+            continue;
+        }
+        if (!isObject(source)) {
+            destination = source;
+            continue;
+        }
+        if (Array.isArray(source)) {
+            if (!Array.isArray(destination)) {
+                destination = [];
+            }
+        }
+        else if (!isObject(destination) || Array.isArray(destination)) {
+            destination = {};
+        }
+        const sourceKeys = Object.keys(source), dangerousKeys = new Set(["__proto__", "constructor", "prototype"]), hasNested = sourceKeys.some(k => {
+            const v = source[k];
+            return isObject(v) || Array.isArray(v);
+        });
+        if (!hasNested) {
+            const sourceDict = source, destDict = destination;
+            for (const key of sourceKeys) {
+                if (dangerousKeys.has(key)) {
+                    continue;
+                }
+                if (key in sourceDict) {
+                    const v = sourceDict[key];
+                    if (v !== undefined) {
+                        destDict[key] = v;
+                    }
+                }
+            }
+            continue;
+        }
+        for (const key of sourceKeys) {
+            if (dangerousKeys.has(key)) {
+                continue;
+            }
+            const sourceDict = source, destDict = destination, value = sourceDict[key];
+            destDict[key] = Array.isArray(value)
+                ? value.map(v => deepExtend(undefined, v))
+                : deepExtend(destDict[key], value);
+        }
+    }
+    return destination;
+}
+function executeOnSingleOrMultiple(obj, callback) {
+    const defaultIndex = 0;
+    return isArray(obj) ? obj.map((item, index) => callback(item, index)) : callback(obj, defaultIndex);
+}
+function itemFromSingleOrMultiple(obj, index, useIndex) {
+    return isArray(obj) ? itemFromArray(obj, index, useIndex) : obj;
+}
+function getPositionOrSize(positionOrSize, canvasSize) {
+    const isPercent = positionOrSize.mode === exports.PixelMode.percent;
+    if (!isPercent) {
+        const { mode: _, ...rest } = positionOrSize;
+        return rest;
+    }
+    const isPosition = "x" in positionOrSize;
+    if (isPosition) {
+        return {
+            x: (positionOrSize.x / percentDenominator) * canvasSize.width,
+            y: (positionOrSize.y / percentDenominator) * canvasSize.height,
+        };
+    }
+    else {
+        return {
+            width: (positionOrSize.width / percentDenominator) * canvasSize.width,
+            height: (positionOrSize.height / percentDenominator) * canvasSize.height,
+        };
+    }
+}
+function getPosition(position, canvasSize) {
+    return getPositionOrSize(position, canvasSize);
+}
+function cloneStyle(style) {
+    const clonedStyle = safeDocument().createElement("div").style;
+    for (const key in style) {
+        const styleKey = style[key];
+        if (!(key in style) || isNull(styleKey)) {
+            continue;
+        }
+        const styleValue = style.getPropertyValue?.(styleKey);
+        if (!styleValue) {
+            continue;
+        }
+        const stylePriority = style.getPropertyPriority?.(styleKey);
+        if (stylePriority) {
+            clonedStyle.setProperty(styleKey, styleValue, stylePriority);
+        }
+        else {
+            clonedStyle.setProperty(styleKey, styleValue);
+        }
+    }
+    return clonedStyle;
+}
+function computeFullScreenStyle(zIndex) {
+    const fullScreenStyle = safeDocument().createElement("div").style, radix = 10, style = {
+        width: "100%",
+        height: "100%",
+        margin: "0",
+        padding: "0",
+        borderWidth: "0",
+        position: "fixed",
+        zIndex: zIndex.toString(radix),
+        "z-index": zIndex.toString(radix),
+        top: "0",
+        left: "0",
+        "pointer-events": "none",
+    };
+    for (const key in style) {
+        const value = style[key];
+        if (value === undefined) {
+            continue;
+        }
+        fullScreenStyle.setProperty(key, value);
+    }
+    return fullScreenStyle;
+}
+const getFullScreenStyle = memoize(computeFullScreenStyle);
+function manageListener(element, event, handler, add, options) {
+    if (add) {
+        let addOptions = { passive: true };
+        if (isBoolean(options)) {
+            addOptions.capture = options;
+        }
+        else if (options !== undefined) {
+            addOptions = options;
+        }
+        element.addEventListener(event, handler, addOptions);
+    }
+    else {
+        const removeOptions = options;
+        element.removeEventListener(event, handler, removeOptions);
+    }
+}
+async function getItemsFromInitializer(container, map, initializers, force = false) {
+    let res = map.get(container);
+    if (!res || force) {
+        res = await Promise.all([...initializers.values()].map(t => t(container)));
+        map.set(container, res);
+    }
+    return res;
+}
+async function getItemMapFromInitializer(container, map, initializers, force = false) {
+    let res = map.get(container);
+    if (!res || force) {
+        const entries = await Promise.all([...initializers.entries()].map(([key, initializer]) => initializer(container).then(item => [key, item])));
+        res = new Map(entries);
+        map.set(container, res);
+    }
+    return res;
+}
+
+class EventDispatcher {
+    #listeners;
+    constructor() {
+        this.#listeners = new Map();
+    }
+    addEventListener(type, listener) {
+        this.removeEventListener(type, listener);
+        let arr = this.#listeners.get(type);
+        if (!arr) {
+            arr = [];
+            this.#listeners.set(type, arr);
+        }
+        arr.push(listener);
+    }
+    dispatchEvent(type, args) {
+        const listeners = this.#listeners.get(type);
+        listeners?.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 < minIndex) {
+            return;
+        }
+        if (length === deleteCount) {
+            this.#listeners.delete(type);
+        }
+        else {
+            arr.splice(idx, deleteCount);
+        }
+    }
+}
+
+exports.EventType = void 0;
+(function (EventType) {
+    EventType["configAdded"] = "configAdded";
+    EventType["containerInit"] = "containerInit";
+    EventType["particlesSetup"] = "particlesSetup";
+    EventType["containerStarted"] = "containerStarted";
+    EventType["containerStopped"] = "containerStopped";
+    EventType["containerDestroyed"] = "containerDestroyed";
+    EventType["containerPaused"] = "containerPaused";
+    EventType["containerPlay"] = "containerPlay";
+    EventType["containerBuilt"] = "containerBuilt";
+    EventType["particleAdded"] = "particleAdded";
+    EventType["particleDestroyed"] = "particleDestroyed";
+    EventType["particleRemoved"] = "particleRemoved";
+})(exports.EventType || (exports.EventType = {}));
+
+class PluginManager {
+    colorManagers = new Map();
+    easingFunctions = new Map();
+    effectDrawers = new Map();
+    initializers = {
+        effects: new Map(),
+        shapes: new Map(),
+        updaters: new Map(),
+    };
+    palettes = new Map();
+    plugins = [];
+    presets = new Map();
+    shapeDrawers = new Map();
+    updaters = new Map();
+    #allLoadersSet = new Set();
+    #configs = new Map();
+    #engine;
+    #executedSet = new Set();
+    #initialized = false;
+    #isRunningLoaders = false;
+    #loadPromises = new Set();
+    constructor(engine) {
+        this.#engine = engine;
+    }
+    get configs() {
+        const res = {};
+        for (const [name, config] of this.#configs) {
+            res[name] = config;
+        }
+        return res;
+    }
+    addColorManager(name, manager) {
+        this.colorManagers.set(name, manager);
+    }
+    addConfig(config) {
+        const key = config.key ?? config.name ?? "default";
+        this.#configs.set(key, config);
+        this.#engine.dispatchEvent(exports.EventType.configAdded, { data: { name: key, config } });
+    }
+    addEasing(name, easing) {
+        if (this.easingFunctions.get(name)) {
+            return;
+        }
+        this.easingFunctions.set(name, easing);
+    }
+    addEffect(effect, drawer) {
+        this.initializers.effects.set(effect, drawer);
+    }
+    addPalette(name, palette) {
+        this.palettes.set(name, palette);
+    }
+    addParticleUpdater(name, updaterInitializer) {
+        this.initializers.updaters.set(name, updaterInitializer);
+    }
+    addPlugin(plugin) {
+        if (this.getPlugin(plugin.id)) {
+            return;
+        }
+        this.plugins.push(plugin);
+    }
+    addPreset(preset, options, override = false) {
+        if (!(override || !this.getPreset(preset))) {
+            return;
+        }
+        this.presets.set(preset, options);
+    }
+    addShape(shapes, drawer) {
+        for (const shape of shapes) {
+            this.initializers.shapes.set(shape, drawer);
+        }
+    }
+    clearPlugins(container) {
+        this.effectDrawers.delete(container);
+        this.shapeDrawers.delete(container);
+        this.updaters.delete(container);
+    }
+    getEasing(name) {
+        return this.easingFunctions.get(name) ?? ((value) => value);
+    }
+    getEffectDrawers(container, force = false) {
+        return getItemMapFromInitializer(container, this.effectDrawers, this.initializers.effects, force);
+    }
+    getPalette(name) {
+        return this.palettes.get(name);
+    }
+    getPlugin(plugin) {
+        return this.plugins.find(t => t.id === plugin);
+    }
+    getPreset(preset) {
+        return this.presets.get(preset);
+    }
+    async getShapeDrawers(container, force = false) {
+        return getItemMapFromInitializer(container, this.shapeDrawers, this.initializers.shapes, force);
+    }
+    async getUpdaters(container, force = false) {
+        return getItemsFromInitializer(container, this.updaters, this.initializers.updaters, force);
+    }
+    async init() {
+        if (this.#initialized || this.#isRunningLoaders) {
+            return;
+        }
+        this.#isRunningLoaders = true;
+        this.#executedSet = new Set();
+        this.#allLoadersSet = new Set(this.#loadPromises);
+        try {
+            for (const loader of this.#allLoadersSet) {
+                await this.#runLoader(loader, this.#executedSet, this.#allLoadersSet);
+            }
+        }
+        finally {
+            this.#loadPromises.clear();
+            this.#isRunningLoaders = false;
+            this.#initialized = true;
+        }
+    }
+    loadParticlesOptions(container, options, ...sourceOptions) {
+        const updaters = this.updaters.get(container);
+        if (!updaters) {
+            return;
+        }
+        updaters.forEach(updater => updater.loadOptions?.(options, ...sourceOptions));
+    }
+    async register(...loaders) {
+        if (this.#initialized) {
+            throw new Error("Register plugins can only be done before calling tsParticles.load()");
+        }
+        for (const loader of loaders) {
+            if (this.#isRunningLoaders) {
+                await this.#runLoader(loader, this.#executedSet, this.#allLoadersSet);
+            }
+            else {
+                this.#loadPromises.add(loader);
+            }
+        }
+    }
+    async #runLoader(loader, executed, allLoaders) {
+        if (executed.has(loader))
+            return;
+        executed.add(loader);
+        allLoaders.add(loader);
+        await loader(this.#engine);
+    }
+}
+
+const errorPrefix = "tsParticles - Error";
+const wrap = (fn) => (...args) => {
+    fn(...args);
+}, _logger = {
+    debug: wrap(console.debug),
+    error: (message, ...optionalParams) => {
+        console.error(`${errorPrefix} - ${message}`, ...optionalParams);
+    },
+    info: wrap(console.info),
+    log: wrap(console.log),
+    trace: wrap(console.trace),
+    verbose: wrap(console.log),
+    warning: wrap(console.warn),
+};
+function getLogger() {
+    return _logger;
+}
+
+const fullPercent = "100%";
+async function getDataFromUrl(data) {
+    const url = itemFromSingleOrMultiple(data.url, data.index);
+    if (!url) {
+        return data.fallback;
+    }
+    const response = await fetch(url);
+    if (response.ok) {
+        return (await response.json());
+    }
+    getLogger().error(`${response.status.toString()} while retrieving config file`);
+    return data.fallback;
+}
+const getCanvasFromContainer = (domContainer) => {
+    const documentSafe = safeDocument();
+    let canvasEl;
+    const isCanvas = domContainer instanceof HTMLCanvasElement || domContainer.tagName.toLowerCase() === canvasTag;
+    if (isCanvas) {
+        canvasEl = domContainer;
+        canvasEl.dataset[generatedAttribute] ??= generatedFalse;
+        if (canvasEl.dataset[generatedAttribute] === generatedTrue) {
+            canvasEl.style.width ||= fullPercent;
+            canvasEl.style.height ||= fullPercent;
+            canvasEl.style.pointerEvents = "none";
+            canvasEl.style.setProperty("pointer-events", "none");
+        }
+    }
+    else {
+        const existingCanvases = domContainer.getElementsByTagName(canvasTag), foundCanvas = existingCanvases.item(canvasFirstIndex);
+        if (foundCanvas) {
+            canvasEl = foundCanvas;
+            canvasEl.dataset[generatedAttribute] = generatedFalse;
+        }
+        else {
+            canvasEl = documentSafe.createElement(canvasTag);
+            canvasEl.dataset[generatedAttribute] = generatedTrue;
+            domContainer.appendChild(canvasEl);
+        }
+        canvasEl.style.width ||= fullPercent;
+        canvasEl.style.height ||= fullPercent;
+        canvasEl.style.pointerEvents = "none";
+        canvasEl.style.setProperty("pointer-events", "none");
+    }
+    return canvasEl;
+}, getDomContainer = (id, source) => {
+    const documentSafe = safeDocument();
+    let domContainer = source ?? documentSafe.getElementById(id);
+    if (domContainer) {
+        return domContainer;
+    }
+    domContainer = documentSafe.createElement("canvas");
+    domContainer.id = id;
+    domContainer.dataset[generatedAttribute] = generatedTrue;
+    documentSafe.body.append(domContainer);
+    return domContainer;
+};
+class Engine {
+    pluginManager = new PluginManager(this);
+    #domArray = [];
+    #eventDispatcher = new EventDispatcher();
+    #initialized = false;
+    get items() {
+        return this.#domArray;
+    }
+    get version() {
+        return "4.0.5";
+    }
+    addEventListener(type, listener) {
+        this.#eventDispatcher.addEventListener(type, listener);
+    }
+    checkVersion(pluginVersion) {
+        if (this.version === pluginVersion) {
+            return;
+        }
+        throw new Error(`The tsParticles version is different from the loaded plugins version. Engine version: ${this.version}. Plugin version: ${pluginVersion}`);
+    }
+    dispatchEvent(type, args) {
+        this.#eventDispatcher.dispatchEvent(type, args);
+    }
+    async init() {
+        if (this.#initialized) {
+            return;
+        }
+        await this.pluginManager.init();
+        this.#initialized = true;
+    }
+    item(index) {
+        const items = this.items, item = items[index];
+        if (item?.destroyed) {
+            items.splice(index, removeDeleteCount);
+            return;
+        }
+        return item;
+    }
+    async load(params) {
+        await this.init();
+        let domSourceElement;
+        if (typeof HTMLElement !== "undefined" && params.element instanceof HTMLElement) {
+            domSourceElement = params.element;
+        }
+        const { Container } = await Promise.resolve().then(function () { return require('./Container-DFed5jPA.js'); }), id = params.id ?? domSourceElement?.id ?? `tsparticles${Math.floor(getRandom() * loadRandomFactor).toString()}`, { index, url } = params, options = url ? await getDataFromUrl({ fallback: params.options, url, index }) : params.options, currentOptions = itemFromSingleOrMultiple(options, index), { items } = this, oldIndex = items.findIndex(v => v.id.description === id), newItem = new Container({
+            dispatchCallback: (eventType, args) => {
+                this.dispatchEvent(eventType, args);
+            },
+            id,
+            onDestroy: (remove) => {
+                if (!remove) {
+                    return;
+                }
+                const mainArr = this.items, idx = mainArr.indexOf(newItem);
+                if (idx >= removeMinIndex) {
+                    mainArr.splice(idx, removeDeleteCount);
+                }
+            },
+            pluginManager: this.pluginManager,
+            sourceOptions: currentOptions,
+        });
+        if (oldIndex >= loadMinIndex) {
+            const old = this.item(oldIndex), deleteCount = old ? one : none;
+            if (old && !old.destroyed) {
+                old.destroy(false);
+            }
+            items.splice(oldIndex, deleteCount, newItem);
+        }
+        else {
+            items.push(newItem);
+        }
+        const sourceCanvas = typeof OffscreenCanvas !== "undefined" && params.element instanceof OffscreenCanvas
+            ? params.element
+            : getCanvasFromContainer(getDomContainer(id, domSourceElement));
+        newItem.canvas.loadCanvas(sourceCanvas);
+        await newItem.start();
+        return newItem;
+    }
+    async refresh(refresh = true) {
+        if (!refresh) {
+            return;
+        }
+        await Promise.all(this.items.map(t => t.refresh()));
+    }
+    removeEventListener(type, listener) {
+        this.#eventDispatcher.removeEventListener(type, listener);
+    }
+}
+
+function initEngine() {
+    return new Engine();
+}
+
+exports.RangeType = void 0;
+(function (RangeType) {
+    RangeType["circle"] = "circle";
+    RangeType["rectangle"] = "rectangle";
+})(exports.RangeType || (exports.RangeType = {}));
+
+var RotateDirection;
+(function (RotateDirection) {
+    RotateDirection["clockwise"] = "clockwise";
+    RotateDirection["counterClockwise"] = "counter-clockwise";
+    RotateDirection["random"] = "random";
+})(RotateDirection || (RotateDirection = {}));
+
+exports.LimitMode = void 0;
+(function (LimitMode) {
+    LimitMode["delete"] = "delete";
+    LimitMode["wait"] = "wait";
+})(exports.LimitMode || (exports.LimitMode = {}));
+
+exports.OutMode = void 0;
+(function (OutMode) {
+    OutMode["bounce"] = "bounce";
+    OutMode["none"] = "none";
+    OutMode["out"] = "out";
+    OutMode["destroy"] = "destroy";
+    OutMode["split"] = "split";
+})(exports.OutMode || (exports.OutMode = {}));
+
+exports.AlterType = void 0;
+(function (AlterType) {
+    AlterType["darken"] = "darken";
+    AlterType["enlighten"] = "enlighten";
+})(exports.AlterType || (exports.AlterType = {}));
+
+var GradientType;
+(function (GradientType) {
+    GradientType["linear"] = "linear";
+    GradientType["radial"] = "radial";
+    GradientType["random"] = "random";
+})(GradientType || (GradientType = {}));
+
+exports.ParticleOutType = void 0;
+(function (ParticleOutType) {
+    ParticleOutType["normal"] = "normal";
+    ParticleOutType["inside"] = "inside";
+    ParticleOutType["outside"] = "outside";
+})(exports.ParticleOutType || (exports.ParticleOutType = {}));
+
+var EasingType;
+(function (EasingType) {
+    EasingType["easeInBack"] = "ease-in-back";
+    EasingType["easeInBounce"] = "ease-in-bounce";
+    EasingType["easeInCirc"] = "ease-in-circ";
+    EasingType["easeInCubic"] = "ease-in-cubic";
+    EasingType["easeInElastic"] = "ease-in-elastic";
+    EasingType["easeInExpo"] = "ease-in-expo";
+    EasingType["easeInGaussian"] = "ease-in-gaussian";
+    EasingType["easeInLinear"] = "ease-in-linear";
+    EasingType["easeInQuad"] = "ease-in-quad";
+    EasingType["easeInQuart"] = "ease-in-quart";
+    EasingType["easeInQuint"] = "ease-in-quint";
+    EasingType["easeInSigmoid"] = "ease-in-sigmoid";
+    EasingType["easeInSine"] = "ease-in-sine";
+    EasingType["easeInSmoothstep"] = "ease-in-smoothstep";
+    EasingType["easeOutBack"] = "ease-out-back";
+    EasingType["easeOutBounce"] = "ease-out-bounce";
+    EasingType["easeOutCirc"] = "ease-out-circ";
+    EasingType["easeOutCubic"] = "ease-out-cubic";
+    EasingType["easeOutElastic"] = "ease-out-elastic";
+    EasingType["easeOutExpo"] = "ease-out-expo";
+    EasingType["easeOutGaussian"] = "ease-out-gaussian";
+    EasingType["easeOutLinear"] = "ease-out-linear";
+    EasingType["easeOutQuad"] = "ease-out-quad";
+    EasingType["easeOutQuart"] = "ease-out-quart";
+    EasingType["easeOutQuint"] = "ease-out-quint";
+    EasingType["easeOutSigmoid"] = "ease-out-sigmoid";
+    EasingType["easeOutSine"] = "ease-out-sine";
+    EasingType["easeOutSmoothstep"] = "ease-out-smoothstep";
+    EasingType["easeInOutBack"] = "ease-in-out-back";
+    EasingType["easeInOutBounce"] = "ease-in-out-bounce";
+    EasingType["easeInOutCirc"] = "ease-in-out-circ";
+    EasingType["easeInOutCubic"] = "ease-in-out-cubic";
+    EasingType["easeInOutElastic"] = "ease-in-out-elastic";
+    EasingType["easeInOutExpo"] = "ease-in-out-expo";
+    EasingType["easeInOutGaussian"] = "ease-in-out-gaussian";
+    EasingType["easeInOutLinear"] = "ease-in-out-linear";
+    EasingType["easeInOutQuad"] = "ease-in-out-quad";
+    EasingType["easeInOutQuart"] = "ease-in-out-quart";
+    EasingType["easeInOutQuint"] = "ease-in-out-quint";
+    EasingType["easeInOutSigmoid"] = "ease-in-out-sigmoid";
+    EasingType["easeInOutSine"] = "ease-in-out-sine";
+    EasingType["easeInOutSmoothstep"] = "ease-in-out-smoothstep";
+})(EasingType || (EasingType = {}));
+
+const tsParticles = initEngine();
+
+let initialized = false;
+let initPromise;
+let initCallback;
+async function initParticlesEngine(init) {
+    if (initialized) {
+        return;
+    }
+    if (initPromise) {
+        if (initCallback !== init) {
+            throw new Error("initParticlesEngine callback must be stable across the app lifecycle.");
+        }
+        await initPromise;
+        return;
+    }
+    initCallback = init;
+    initPromise = (async () => {
+        if (init) {
+            await init(tsParticles);
+        }
+        if (typeof tsParticles.init === "function") {
+            await tsParticles.init();
+        }
+        initialized = true;
+    })().catch((error) => {
+        initPromise = undefined;
+        initCallback = undefined;
+        initialized = false;
+        throw error;
+    });
+    await initPromise;
+}
+function isParticlesEngineInitialized() {
+    return initialized;
+}
+async function waitForParticlesEngineInitialization() {
+    await (initPromise !== null && initPromise !== void 0 ? initPromise : Promise.resolve());
+}
+
+exports.Vector = Vector;
+exports.Vector3d = Vector3d;
+exports.animate = animate;
+exports.calcExactPositionOrRandomFromSize = calcExactPositionOrRandomFromSize;
+exports.cancelAnimation = cancelAnimation;
+exports.checkDistance = checkDistance;
+exports.clamp = clamp;
+exports.cloneStyle = cloneStyle;
+exports.countOffset = countOffset;
+exports.deepExtend = deepExtend;
+exports.defaultAngle = defaultAngle;
+exports.defaultCompositeValue = defaultCompositeValue;
+exports.defaultDensityFactor = defaultDensityFactor;
+exports.defaultFps = defaultFps;
+exports.defaultFpsLimit = defaultFpsLimit;
+exports.defaultOpacity = defaultOpacity;
+exports.defaultRatio = defaultRatio;
+exports.defaultReduceFactor = defaultReduceFactor;
+exports.defaultRemoveQuantity = defaultRemoveQuantity;
+exports.defaultRetryCount = defaultRetryCount;
+exports.defaultRgbMin = defaultRgbMin;
+exports.defaultTransform = defaultTransform;
+exports.defaultTransformValue = defaultTransformValue;
+exports.defaultZoom = defaultZoom;
+exports.degToRad = degToRad;
+exports.deleteCount = deleteCount;
+exports.double = double;
+exports.doublePI = doublePI;
+exports.empty = empty;
+exports.executeOnSingleOrMultiple = executeOnSingleOrMultiple;
+exports.generatedAttribute = generatedAttribute;
+exports.getFullScreenStyle = getFullScreenStyle;
+exports.getLogger = getLogger;
+exports.getParticleBaseVelocity = getParticleBaseVelocity;
+exports.getParticleDirectionAngle = getParticleDirectionAngle;
+exports.getPosition = getPosition;
+exports.getRandom = getRandom;
+exports.getRandomInRange = getRandomInRange;
+exports.getRangeValue = getRangeValue;
+exports.hMax = hMax;
+exports.hMin = hMin;
+exports.hPhase = hPhase;
+exports.half = half;
+exports.identity = identity;
+exports.initParticlesEngine = initParticlesEngine;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isInArray = isInArray;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isParticlesEngineInitialized = isParticlesEngineInitialized;
+exports.isString = isString;
+exports.itemFromArray = itemFromArray;
+exports.itemFromSingleOrMultiple = itemFromSingleOrMultiple;
+exports.lFactor = lFactor;
+exports.lMax = lMax;
+exports.lMin = lMin;
+exports.manageListener = manageListener;
+exports.millisecondsToSeconds = millisecondsToSeconds;
+exports.minCount = minCount;
+exports.minFpsLimit = minFpsLimit;
+exports.minIndex = minIndex;
+exports.minLimit = minLimit;
+exports.minStrokeWidth = minStrokeWidth;
+exports.minZ = minZ;
+exports.minimumSize = minimumSize;
+exports.one = one;
+exports.originPoint = originPoint;
+exports.phaseNumerator = phaseNumerator;
+exports.randomColorValue = randomColorValue;
+exports.randomInRangeValue = randomInRangeValue;
+exports.resizeEvent = resizeEvent;
+exports.rgbMax = rgbMax;
+exports.sMax = sMax;
+exports.sMin = sMin;
+exports.sNormalizedOffset = sNormalizedOffset;
+exports.safeDocument = safeDocument;
+exports.safeMatchMedia = safeMatchMedia;
+exports.safeMutationObserver = safeMutationObserver;
+exports.setRangeValue = setRangeValue;
+exports.sextuple = sextuple;
+exports.spatialHashGridCellSize = spatialHashGridCellSize;
+exports.squareExp = squareExp;
+exports.triple = triple;
+exports.tryCountIncrement = tryCountIncrement;
+exports.tsParticles = tsParticles;
+exports.visibilityChangeEvent = visibilityChangeEvent;
+exports.waitForParticlesEngineInitialization = waitForParticlesEngineInitialization;
+exports.zIndexFactorOffset = zIndexFactorOffset;