@tsparticles/stencil 4.0.5

package/dist/esm/index-CPcFDf6d.js

@@ -0,0 +1,1052 @@
+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;
+
+var MoveDirection;
+(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";
+})(MoveDirection || (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 MoveDirection.top:
+            return -Math.PI * half;
+        case MoveDirection.topRight:
+            return -Math.PI * quarter;
+        case MoveDirection.right:
+            return empty;
+        case MoveDirection.bottomRight:
+            return Math.PI * quarter;
+        case MoveDirection.bottom:
+            return Math.PI * half;
+        case MoveDirection.bottomLeft:
+            return Math.PI * threeQuarter;
+        case MoveDirection.left:
+            return Math.PI;
+        case MoveDirection.topLeft:
+            return -Math.PI * threeQuarter;
+        case MoveDirection.inside:
+            return Math.atan2(center.y - position.y, center.x - position.x);
+        case 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 = {}));
+
+var OutModeDirection;
+(function (OutModeDirection) {
+    OutModeDirection["bottom"] = "bottom";
+    OutModeDirection["left"] = "left";
+    OutModeDirection["right"] = "right";
+    OutModeDirection["top"] = "top";
+})(OutModeDirection || (OutModeDirection = {}));
+
+var PixelMode;
+(function (PixelMode) {
+    PixelMode["precise"] = "precise";
+    PixelMode["percent"] = "percent";
+})(PixelMode || (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 === 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);
+        }
+    }
+}
+
+var EventType;
+(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";
+})(EventType || (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(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 import('./Container-Di-pVL5B.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();
+}
+
+var RangeType;
+(function (RangeType) {
+    RangeType["circle"] = "circle";
+    RangeType["rectangle"] = "rectangle";
+})(RangeType || (RangeType = {}));
+
+var RotateDirection;
+(function (RotateDirection) {
+    RotateDirection["clockwise"] = "clockwise";
+    RotateDirection["counterClockwise"] = "counter-clockwise";
+    RotateDirection["random"] = "random";
+})(RotateDirection || (RotateDirection = {}));
+
+var LimitMode;
+(function (LimitMode) {
+    LimitMode["delete"] = "delete";
+    LimitMode["wait"] = "wait";
+})(LimitMode || (LimitMode = {}));
+
+var OutMode;
+(function (OutMode) {
+    OutMode["bounce"] = "bounce";
+    OutMode["none"] = "none";
+    OutMode["out"] = "out";
+    OutMode["destroy"] = "destroy";
+    OutMode["split"] = "split";
+})(OutMode || (OutMode = {}));
+
+var AlterType;
+(function (AlterType) {
+    AlterType["darken"] = "darken";
+    AlterType["enlighten"] = "enlighten";
+})(AlterType || (AlterType = {}));
+
+var GradientType;
+(function (GradientType) {
+    GradientType["linear"] = "linear";
+    GradientType["radial"] = "radial";
+    GradientType["random"] = "random";
+})(GradientType || (GradientType = {}));
+
+var ParticleOutType;
+(function (ParticleOutType) {
+    ParticleOutType["normal"] = "normal";
+    ParticleOutType["inside"] = "inside";
+    ParticleOutType["outside"] = "outside";
+})(ParticleOutType || (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());
+}
+
+export { millisecondsToSeconds as $, AlterType as A, lFactor as B, double as C, hPhase as D, rgbMax as E, getRandomInRange as F, identity as G, defaultRgbMin as H, sextuple as I, triple as J, phaseNumerator as K, LimitMode as L, MoveDirection as M, sNormalizedOffset as N, OutMode as O, PixelMode as P, minimumSize as Q, RangeType as R, defaultCompositeValue as S, defaultTransformValue as T, zIndexFactorOffset as U, safeMutationObserver as V, generatedAttribute as W, cloneStyle as X, safeMatchMedia as Y, getFullScreenStyle as Z, safeDocument as _, isNull as a, manageListener as a0, visibilityChangeEvent as a1, resizeEvent as a2, Vector3d as a3, EventType as a4, defaultAngle as a5, defaultTransform as a6, ParticleOutType as a7, itemFromSingleOrMultiple as a8, getRandom as a9, defaultRatio as aA, defaultReduceFactor as aB, animate as aC, defaultFpsLimit as aD, minFpsLimit as aE, cancelAnimation as aF, defaultFps as aG, isParticlesEngineInitialized as aH, waitForParticlesEngineInitialization as aI, defaultRetryCount as aa, tryCountIncrement as ab, getParticleBaseVelocity as ac, randomInRangeValue as ad, OutModeDirection as ae, clamp as af, minZ as ag, getPosition as ah, getParticleDirectionAngle as ai, Vector as aj, getRangeValue as ak, doublePI as al, calcExactPositionOrRandomFromSize as am, isInArray as an, degToRad as ao, spatialHashGridCellSize as ap, minLimit as aq, minCount as ar, getLogger as as, minIndex as at, defaultRemoveQuantity as au, defaultDensityFactor as av, empty as aw, deleteCount as ax, countOffset as ay, one as az, setRangeValue as b, checkDistance as c, hMax as d, lMax as e, sMin as f, sMax as g, hMin as h, initParticlesEngine as i, isString as j, isArray as k, lMin as l, deepExtend as m, isNumber as n, isObject as o, executeOnSingleOrMultiple as p, isBoolean as q, originPoint as r, squareExp as s, tsParticles as t, minStrokeWidth as u, defaultZoom as v, itemFromArray as w, defaultOpacity as x, randomColorValue as y, half as z };