@tsparticles/engine 4.0.0-alpha.25 → 4.0.0-alpha.27

package/browser/Options/Classes/Particles/Fill.js

@@ -0,0 +1,28 @@
+import { AnimatableColor } from "../AnimatableColor.js";
+import { isNull } from "../../../Utils/TypeUtils.js";
+import { setRangeValue } from "../../../Utils/MathUtils.js";
+export class Fill {
+    color;
+    enable;
+    opacity;
+    constructor() {
+        this.enable = true;
+        this.color = new AnimatableColor();
+        this.color.value = "#fff";
+        this.opacity = 1;
+    }
+    load(data) {
+        if (isNull(data)) {
+            return;
+        }
+        if (data.color !== undefined) {
+            this.color = AnimatableColor.create(this.color, data.color);
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.opacity !== undefined) {
+            this.opacity = setRangeValue(data.opacity);
+        }
+    }
+}

package/browser/Options/Classes/Particles/Move/Move.js

@@ -1,7 +1,6 @@
 import { MoveDirection } from "../../../../Enums/Directions/MoveDirection.js";
 import { isNull, isNumber, isObject } from "../../../../Utils/TypeUtils.js";
 import { MoveAngle } from "./MoveAngle.js";
-import { MoveAttract } from "./MoveAttract.js";
 import { MoveCenter } from "./MoveCenter.js";
 import { MoveGravity } from "./MoveGravity.js";
 import { MovePath } from "./Path/MovePath.js";
@@ -10,7 +9,6 @@ import { Spin } from "./Spin.js";
 import { setRangeValue } from "../../../../Utils/MathUtils.js";
 export class Move {
     angle;
-    attract;
     center;
     decay;
     direction;
@@ -29,7 +27,6 @@ export class Move {
     warp;
     constructor() {
         this.angle = new MoveAngle();
-        this.attract = new MoveAttract();
         this.center = new MoveCenter();
         this.decay = 0;
         this.distance = {};
@@ -52,7 +49,6 @@ export class Move {
             return;
         }
         this.angle.load(isNumber(data.angle) ? { value: data.angle } : data.angle);
-        this.attract.load(data.attract);
         this.center.load(data.center);
         if (data.decay !== undefined) {
             this.decay = setRangeValue(data.decay);

package/browser/Options/Classes/Particles/ParticlesOptions.js

@@ -1,6 +1,6 @@
 import { deepExtend, executeOnSingleOrMultiple } from "../../../Utils/Utils.js";
-import { AnimatableColor } from "../AnimatableColor.js";
 import { Effect } from "./Effect/Effect.js";
+import { Fill } from "./Fill.js";
 import { Move } from "./Move/Move.js";
 import { Opacity } from "./Opacity/Opacity.js";
 import { ParticlesBounce } from "./Bounce/ParticlesBounce.js";
@@ -12,8 +12,8 @@ import { ZIndex } from "./ZIndex/ZIndex.js";
 import { isNull } from "../../../Utils/TypeUtils.js";
 export class ParticlesOptions {
     bounce;
-    color;
     effect;
+    fill;
     groups;
     move;
     number;
@@ -29,9 +29,8 @@ export class ParticlesOptions {
         this._engine = engine;
         this._container = container;
         this.bounce = new ParticlesBounce();
-        this.color = new AnimatableColor();
-        this.color.value = "#fff";
         this.effect = new Effect();
+        this.fill = new Fill();
         this.groups = {};
         this.move = new Move();
         this.number = new ParticlesNumber();
@@ -48,7 +47,7 @@ export class ParticlesOptions {
         }
         if (data.groups !== undefined) {
             for (const group of Object.keys(data.groups)) {
-                if (!Object.hasOwn(data.groups, group)) {
+                if (!(group in data.groups)) {
                     continue;
                 }
                 const item = data.groups[group];
@@ -61,7 +60,6 @@ export class ParticlesOptions {
             this.reduceDuplicates = data.reduceDuplicates;
         }
         this.bounce.load(data.bounce);
-        this.color.load(AnimatableColor.create(this.color, data.color));
         this.effect.load(data.effect);
         this.move.load(data.move);
         this.number.load(data.number);
@@ -69,6 +67,14 @@ export class ParticlesOptions {
         this.shape.load(data.shape);
         this.size.load(data.size);
         this.zIndex.load(data.zIndex);
+        const fillToLoad = data.fill;
+        if (fillToLoad) {
+            this.fill = executeOnSingleOrMultiple(fillToLoad, t => {
+                const tmp = new Fill();
+                tmp.load(t);
+                return tmp;
+            });
+        }
         const strokeToLoad = data.stroke;
         if (strokeToLoad) {
             this.stroke = executeOnSingleOrMultiple(strokeToLoad, t => {

package/browser/Options/Classes/Particles/Shape/Shape.js

@@ -2,12 +2,10 @@ import { deepExtend } from "../../../../Utils/Utils.js";
 import { isNull } from "../../../../Utils/TypeUtils.js";
 export class Shape {
     close;
-    fill;
     options;
     type;
     constructor() {
         this.close = true;
-        this.fill = true;
         this.options = {};
         this.type = "circle";
     }
@@ -27,9 +25,6 @@ export class Shape {
         if (data.close !== undefined) {
             this.close = data.close;
         }
-        if (data.fill !== undefined) {
-            this.fill = data.fill;
-        }
         if (data.type !== undefined) {
             this.type = data.type;
         }

package/browser/Utils/CanvasUtils.js

@@ -7,15 +7,16 @@ export function paintImage(context, dimension, image, opacity) {
     if (!image) {
         return;
     }
+    const prevAlpha = context.globalAlpha;
     context.globalAlpha = opacity;
     context.drawImage(image, originPoint.x, originPoint.y, dimension.width, dimension.height);
-    context.globalAlpha = 1;
+    context.globalAlpha = prevAlpha;
 }
 export function clear(context, dimension) {
     context.clearRect(originPoint.x, originPoint.y, dimension.width, dimension.height);
 }
 export function drawParticle(data) {
-    const { container, context, particle, delta, colorStyles, radius, opacity, transform } = data, pos = particle.getPosition(), transformData = particle.getTransformData(transform), drawScale = defaultZoom, drawPosition = {
+    const { container, context, particle, delta, colorStyles, radius, opacity, transform } = data, { effectDrawers, shapeDrawers } = container.particles, pos = particle.getPosition(), transformData = particle.getTransformData(transform), drawScale = defaultZoom, drawPosition = {
         x: pos.x,
         y: pos.y,
     };
@@ -23,7 +24,7 @@ export function drawParticle(data) {
     if (colorStyles.fill) {
         context.fillStyle = colorStyles.fill;
     }
-    const strokeWidth = particle.strokeWidth ?? minStrokeWidth;
+    const fillEnabled = !!particle.fillEnabled, strokeWidth = particle.strokeWidth ?? minStrokeWidth;
     context.lineWidth = strokeWidth;
     if (colorStyles.stroke) {
         context.strokeStyle = colorStyles.stroke;
@@ -36,8 +37,8 @@ export function drawParticle(data) {
         opacity,
         delta,
         pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
+        fill: fillEnabled,
+        stroke: strokeWidth > minStrokeWidth,
         transformData,
         position: { ...pos },
         drawPosition,
@@ -46,42 +47,40 @@ export function drawParticle(data) {
     for (const plugin of container.plugins) {
         plugin.drawParticleTransform?.(drawData);
     }
-    drawBeforeEffect(container, drawData);
-    drawShapeBeforeDraw(container, drawData);
-    drawShape(container, drawData);
-    drawShapeAfterDraw(container, drawData);
-    drawAfterEffect(container, drawData);
+    const effect = particle.effect ? effectDrawers.get(particle.effect) : undefined, shape = particle.shape ? shapeDrawers.get(particle.shape) : undefined;
+    drawBeforeEffect(effect, drawData);
+    drawShapeBeforeDraw(shape, drawData);
+    drawShape(shape, drawData);
+    drawShapeAfterDraw(shape, drawData);
+    drawAfterEffect(effect, drawData);
     context.resetTransform();
 }
-export function drawAfterEffect(container, data) {
+export function drawAfterEffect(drawer, data) {
+    if (!drawer?.drawAfter) {
+        return;
+    }
     const { particle } = data;
     if (!particle.effect) {
         return;
     }
-    const drawer = container.particles.effectDrawers.get(particle.effect), drawFunc = drawer?.drawAfter;
-    if (!drawFunc) {
+    drawer.drawAfter(data);
+}
+export function drawBeforeEffect(drawer, data) {
+    if (!drawer?.drawBefore) {
         return;
     }
-    drawFunc(data);
-}
-export function drawBeforeEffect(container, data) {
     const { particle } = data;
     if (!particle.effect) {
         return;
     }
-    const drawer = container.particles.effectDrawers.get(particle.effect);
-    if (!drawer?.drawBefore) {
-        return;
-    }
     drawer.drawBefore(data);
 }
-export function drawShape(container, data) {
-    const { context, particle, stroke } = data;
-    if (!particle.shape) {
+export function drawShape(drawer, data) {
+    if (!drawer) {
         return;
     }
-    const drawer = container.particles.shapeDrawers.get(particle.shape);
-    if (!drawer) {
+    const { context, fill, particle, stroke } = data;
+    if (!particle.shape) {
         return;
     }
     context.beginPath();
@@ -92,30 +91,28 @@ export function drawShape(container, data) {
     if (stroke) {
         context.stroke();
     }
-    if (particle.shapeFill) {
+    if (fill) {
         context.fill();
     }
 }
-export function drawShapeAfterDraw(container, data) {
-    const { particle } = data;
-    if (!particle.shape) {
-        return;
-    }
-    const drawer = container.particles.shapeDrawers.get(particle.shape);
+export function drawShapeAfterDraw(drawer, data) {
     if (!drawer?.afterDraw) {
         return;
     }
-    drawer.afterDraw(data);
-}
-export function drawShapeBeforeDraw(container, data) {
     const { particle } = data;
     if (!particle.shape) {
         return;
     }
-    const drawer = container.particles.shapeDrawers.get(particle.shape);
+    drawer.afterDraw(data);
+}
+export function drawShapeBeforeDraw(drawer, data) {
     if (!drawer?.beforeDraw) {
         return;
     }
+    const { particle } = data;
+    if (!particle.shape) {
+        return;
+    }
     drawer.beforeDraw(data);
 }
 export function drawParticlePlugin(context, plugin, particle, delta) {

package/browser/Utils/ColorUtils.js

@@ -1,4 +1,4 @@
-import { clamp, getRandom, getRandomInRange, getRangeMax, getRangeMin, getRangeValue, mix, randomInRangeValue, setRangeValue, } from "./MathUtils.js";
+import { clamp, getRandom, getRandomInRange, getRangeValue, mix, randomInRangeValue, setRangeValue, } from "./MathUtils.js";
 import { decayOffset, defaultLoops, defaultOpacity, defaultRgbMin, defaultTime, defaultVelocity, double, hMax, hMin, hPhase, half, identity, lFactor, lMax, lMin, midColorValue, millisecondsToSeconds, percentDenominator, phaseNumerator, randomColorValue, rgbMax, sMax, sMin, sNormalizedOffset, sextuple, triple, } from "../Core/Utils/Constants.js";
 import { isArray, isString } from "./TypeUtils.js";
 import { AlterType } from "../Enums/Types/AlterType.js";
@@ -190,10 +190,10 @@ function getSdrStyleFromHsl(color, opacity) {
 }
 export function colorMix(color1, color2, size1, size2) {
     let rgb1 = color1, rgb2 = color2;
-    if (!Object.hasOwn(rgb1, "r")) {
+    if (!("r" in rgb1)) {
         rgb1 = hslToRgb(color1);
     }
-    if (!Object.hasOwn(rgb2, "r")) {
+    if (!("r" in rgb2)) {
         rgb2 = hslToRgb(color2);
     }
     return {
@@ -246,27 +246,33 @@ export function getLinkRandomColor(engine, optColor, blink, consent) {
     }
 }
 export function getHslFromAnimation(animation) {
-    return animation !== undefined
-        ? {
+    return animation === undefined
+        ? undefined
+        : {
             h: animation.h.value,
             s: animation.s.value,
             l: animation.l.value,
-        }
-        : undefined;
+        };
 }
 export function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
     const resColor = {
         h: {
             enable: false,
             value: hsl.h,
+            min: hMin,
+            max: hMax,
         },
         s: {
             enable: false,
             value: hsl.s,
+            min: sMin,
+            max: sMax,
         },
         l: {
             enable: false,
             value: hsl.l,
+            min: lMin,
+            max: lMax,
         },
     };
     if (animationOptions) {
@@ -278,6 +284,8 @@ export function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
 }
 function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
     colorValue.enable = colorAnimation.enable;
+    colorValue.min = colorAnimation.min;
+    colorValue.max = colorAnimation.max;
     if (colorValue.enable) {
         colorValue.velocity = (getRangeValue(colorAnimation.speed) / percentDenominator) * reduceFactor;
         colorValue.decay = decayOffset - getRangeValue(colorAnimation.decay);
@@ -297,7 +305,7 @@ function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
         colorValue.velocity = defaultVelocity;
     }
 }
-export function updateColorValue(data, range, decrease, delta) {
+export function updateColorValue(data, decrease, delta) {
     const minLoops = 0, minDelay = 0, identity = 1, minVelocity = 0, minOffset = 0, velocityFactor = 3.6;
     if (!data.enable ||
         ((data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops))) {
@@ -310,7 +318,7 @@ export function updateColorValue(data, range, decrease, delta) {
     if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
         return;
     }
-    const offset = data.offset ? randomInRangeValue(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity, max = getRangeMax(range), min = getRangeMin(range);
+    const offset = data.offset ? randomInRangeValue(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity, max = data.max, min = data.min;
     if (!decrease || data.status === AnimationStatus.increasing) {
         data.value += velocity;
         if (data.value > max) {
@@ -326,8 +334,7 @@ export function updateColorValue(data, range, decrease, delta) {
     }
     else {
         data.value -= velocity;
-        const minValue = 0;
-        if (data.value < minValue) {
+        if (data.value < min) {
             data.loops ??= 0;
             data.loops++;
             data.status = AnimationStatus.increasing;
@@ -342,14 +349,10 @@ export function updateColor(color, delta) {
     if (!color) {
         return;
     }
-    const { h, s, l } = color, ranges = {
-        h: { min: hMin, max: hMax },
-        s: { min: sMin, max: sMax },
-        l: { min: lMin, max: lMax },
-    };
-    updateColorValue(h, ranges.h, false, delta);
-    updateColorValue(s, ranges.s, true, delta);
-    updateColorValue(l, ranges.l, true, delta);
+    const { h, s, l } = color;
+    updateColorValue(h, false, delta);
+    updateColorValue(s, true, delta);
+    updateColorValue(l, true, delta);
 }
 export function alterHsl(color, type, value) {
     return {

package/browser/Utils/MathUtils.js

@@ -69,8 +69,15 @@ export function getDistances(pointA, pointB) {
     const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
     return { dx: dx, dy: dy, distance: Math.hypot(dx, dy) };
 }
+export function getDistanceSq(pointA, pointB) {
+    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
+    return dx * dx + dy * dy;
+}
 export function getDistance(pointA, pointB) {
-    return getDistances(pointA, pointB).distance;
+    return Math.sqrt(getDistanceSq(pointA, pointB));
+}
+export function checkDistance(pointA, pointB, distance) {
+    return getDistanceSq(pointA, pointB) <= distance * distance;
 }
 export function degToRad(degrees) {
     return degrees * degToRadFactor;

package/browser/Utils/Utils.js

@@ -8,16 +8,70 @@ import { OutModeDirection } from "../Enums/Directions/OutModeDirection.js";
 import { PixelMode } from "../Enums/Modes/PixelMode.js";
 import { StartValueType } from "../Enums/Types/StartValueType.js";
 import { Vector } from "../Core/Utils/Vectors.js";
-const minRadius = 0;
-function memoize(fn) {
-    const cache = new Map();
+const minRadius = 0, minMemoizeSize = 0;
+export function memoize(fn, options) {
+    const cache = new Map(), maxSize = options?.maxSize, ttlMs = options?.ttlMs, 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)), ensureBounds = () => {
+        if (typeof maxSize === "number" && maxSize >= minMemoizeSize) {
+            while (cache.size > maxSize) {
+                const firstKey = cache.keys().next().value;
+                if (firstKey === undefined)
+                    break;
+                cache.delete(firstKey);
+            }
+        }
+    };
     return (...args) => {
-        const key = JSON.stringify(args);
-        if (cache.has(key)) {
-            return cache.get(key);
+        const key = makeKey(args), now = Date.now(), entry = cache.get(key);
+        if (entry !== undefined) {
+            if (ttlMs && now - entry.ts > ttlMs) {
+                cache.delete(key);
+            }
+            else {
+                cache.delete(key);
+                cache.set(key, { value: entry.value, ts: entry.ts });
+                return entry.value;
+            }
         }
         const result = fn(...args);
-        cache.set(key, result);
+        cache.set(key, { value: result, ts: now });
+        ensureBounds();
         return result;
     };
 }
@@ -83,33 +137,48 @@ export function calculateBounds(point, radius) {
 }
 export function deepExtend(destination, ...sources) {
     for (const source of sources) {
-        if (source === undefined || source === null) {
+        if (isNull(source)) {
             continue;
         }
         if (!isObject(source)) {
             destination = source;
             continue;
         }
-        const sourceIsArray = Array.isArray(source);
-        if (sourceIsArray) {
+        if (Array.isArray(source)) {
             if (!Array.isArray(destination)) {
                 destination = [];
             }
         }
-        else {
-            if (!isObject(destination) || 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 in source) {
-            if (key === "__proto__") {
+        for (const key of sourceKeys) {
+            if (dangerousKeys.has(key)) {
                 continue;
             }
-            const sourceDict = source, value = sourceDict[key], destDict = destination;
-            destDict[key] =
-                isObject(value) && Array.isArray(value)
-                    ? value.map(v => deepExtend(destDict[key], v))
-                    : deepExtend(destDict[key], value);
+            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;
@@ -301,7 +370,7 @@ export function cloneStyle(style) {
     const clonedStyle = safeDocument().createElement("div").style;
     for (const key in style) {
         const styleKey = style[key];
-        if (!Object.hasOwn(style, key) || isNull(styleKey)) {
+        if (!(key in style) || isNull(styleKey)) {
             continue;
         }
         const styleValue = style.getPropertyValue?.(styleKey);
@@ -309,11 +378,11 @@ export function cloneStyle(style) {
             continue;
         }
         const stylePriority = style.getPropertyPriority?.(styleKey);
-        if (!stylePriority) {
-            clonedStyle.setProperty(styleKey, styleValue);
+        if (stylePriority) {
+            clonedStyle.setProperty(styleKey, styleValue, stylePriority);
         }
         else {
-            clonedStyle.setProperty(styleKey, styleValue, stylePriority);
+            clonedStyle.setProperty(styleKey, styleValue);
         }
     }
     return clonedStyle;

package/browser/exports.js

@@ -27,8 +27,8 @@ export * from "./Options/Classes/OptionsColor.js";
 export * from "./Options/Classes/Particles/Bounce/ParticlesBounce.js";
 export * from "./Options/Classes/Particles/Bounce/ParticlesBounceFactor.js";
 export * from "./Options/Classes/Particles/ParticlesOptions.js";
+export * from "./Options/Classes/Particles/Fill.js";
 export * from "./Options/Classes/Particles/Stroke.js";
-export * from "./Options/Classes/Particles/Move/MoveAttract.js";
 export * from "./Options/Classes/Particles/Move/Move.js";
 export * from "./Options/Classes/Particles/Move/MoveAngle.js";
 export * from "./Options/Classes/Particles/Move/MoveCenter.js";

package/cjs/Core/Canvas.js

@@ -1,6 +1,6 @@
 import { clear, drawParticle, drawParticlePlugin, paintBase, paintImage } from "../Utils/CanvasUtils.js";
 import { cloneStyle, getFullScreenStyle, safeMatchMedia, safeMutationObserver } from "../Utils/Utils.js";
-import { defaultTransformValue, defaultZoom, generatedAttribute, half, minimumSize, zIndexFactorOffset, } from "./Utils/Constants.js";
+import { defaultCompositeValue, defaultTransformValue, defaultZoom, generatedAttribute, half, minimumSize, zIndexFactorOffset, } from "./Utils/Constants.js";
 import { getStyleFromHsl, getStyleFromRgb, rangeColorToHsl, rangeColorToRgb } from "../Utils/ColorUtils.js";
 const fColorIndex = 0, sColorIndex = 1;
 function setTransformValue(factor, newFactor, key) {
@@ -163,14 +163,14 @@ export class Canvas {
         if (radius <= minimumSize) {
             return;
         }
-        const pfColor = particle.getFillColor(), psColor = particle.getStrokeColor() ?? pfColor;
+        const pfColor = particle.getFillColor(), psColor = particle.getStrokeColor();
         let [fColor, sColor] = this._getPluginParticleColors(particle);
         fColor ??= pfColor;
         sColor ??= psColor;
         if (!fColor && !sColor) {
             return;
         }
-        const container = this.container, zIndexOptions = particle.options.zIndex, zIndexFactor = zIndexFactorOffset - particle.zIndexFactor, { opacity, strokeOpacity } = particle.getOpacity(), transform = this._reusableTransform, colorStyles = this._reusableColorStyles, fill = fColor ? getStyleFromHsl(fColor, container.hdr, opacity) : undefined, stroke = sColor ? getStyleFromHsl(sColor, container.hdr, strokeOpacity) : fill;
+        const container = this.container, zIndexOptions = particle.options.zIndex, zIndexFactor = zIndexFactorOffset - particle.zIndexFactor, { fillOpacity, opacity, strokeOpacity } = particle.getOpacity(), transform = this._reusableTransform, colorStyles = this._reusableColorStyles, fill = fColor ? getStyleFromHsl(fColor, container.hdr, fillOpacity * opacity) : undefined, stroke = sColor ? getStyleFromHsl(sColor, container.hdr, strokeOpacity * opacity) : fill;
         transform.a = transform.b = transform.c = transform.d = undefined;
         colorStyles.fill = fill;
         colorStyles.stroke = stroke;
@@ -357,6 +357,9 @@ export class Canvas {
             willReadFrequently: false,
         };
         this._context = this.element.getContext("2d", this._canvasSettings);
+        if (this._context) {
+            this._context.globalCompositeOperation = defaultCompositeValue;
+        }
         this._safeMutationObserver(obs => {
             obs.disconnect();
         });
@@ -514,7 +517,7 @@ export class Canvas {
             this._resetOriginalStyle();
         }
         for (const key in options.style) {
-            if (!key || !Object.hasOwn(options.style, key)) {
+            if (!key || !(key in options.style)) {
                 continue;
             }
             const value = options.style[key];