dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/CanvasUtils.js

@@ -0,0 +1,168 @@
+import { originPoint, defaultAngle, defaultTransform, identity, minStrokeWidth, lFactor } from "../Core/Utils/Constants.js";
+import { AlterType } from "../Enums/Types/AlterType.js";
+import { getStyleFromRgb } from "./ColorUtils.js";
+function drawLine(context, begin, end) {
+  context.beginPath();
+  context.moveTo(begin.x, begin.y);
+  context.lineTo(end.x, end.y);
+  context.closePath();
+}
+function paintBase(context, dimension, baseColor) {
+  context.fillStyle = baseColor ?? "rgba(0,0,0,0)";
+  context.fillRect(originPoint.x, originPoint.y, dimension.width, dimension.height);
+}
+function paintImage(context, dimension, image, opacity) {
+  if (!image) {
+    return;
+  }
+  context.globalAlpha = opacity;
+  context.drawImage(image, originPoint.x, originPoint.y, dimension.width, dimension.height);
+  context.globalAlpha = 1;
+}
+function clear(context, dimension) {
+  context.clearRect(originPoint.x, originPoint.y, dimension.width, dimension.height);
+}
+function drawParticle(data) {
+  const { container, context, particle, delta, colorStyles, backgroundMask, composite, radius, opacity, shadow, transform } = data, pos = particle.getPosition(), angle = particle.rotation + (particle.pathRotation ? particle.velocity.angle : defaultAngle), rotateData = {
+    sin: Math.sin(angle),
+    cos: Math.cos(angle)
+  }, rotating = !!angle, transformData = {
+    a: rotateData.cos * (transform.a ?? defaultTransform.a),
+    b: rotating ? rotateData.sin * (transform.b ?? identity) : transform.b ?? defaultTransform.b,
+    c: rotating ? -rotateData.sin * (transform.c ?? identity) : transform.c ?? defaultTransform.c,
+    d: rotateData.cos * (transform.d ?? defaultTransform.d)
+  };
+  context.setTransform(transformData.a, transformData.b, transformData.c, transformData.d, pos.x, pos.y);
+  if (backgroundMask) {
+    context.globalCompositeOperation = composite;
+  }
+  const shadowColor = particle.shadowColor;
+  if (shadow.enable && shadowColor) {
+    context.shadowBlur = shadow.blur;
+    context.shadowColor = getStyleFromRgb(shadowColor);
+    context.shadowOffsetX = shadow.offset.x;
+    context.shadowOffsetY = shadow.offset.y;
+  }
+  if (colorStyles.fill) {
+    context.fillStyle = colorStyles.fill;
+  }
+  const strokeWidth = particle.strokeWidth ?? minStrokeWidth;
+  context.lineWidth = strokeWidth;
+  if (colorStyles.stroke) {
+    context.strokeStyle = colorStyles.stroke;
+  }
+  const drawData = {
+    container,
+    context,
+    particle,
+    radius,
+    opacity,
+    delta,
+    transformData,
+    strokeWidth
+  };
+  drawShape(drawData);
+  drawShapeAfterDraw(drawData);
+  drawEffect(drawData);
+  context.globalCompositeOperation = "source-over";
+  context.resetTransform();
+}
+function drawEffect(data) {
+  const { container, context, particle, radius, opacity, delta, transformData } = data;
+  if (!particle.effect) {
+    return;
+  }
+  const drawer = container.effectDrawers.get(particle.effect);
+  if (!drawer) {
+    return;
+  }
+  drawer.draw({
+    context,
+    particle,
+    radius,
+    opacity,
+    delta,
+    pixelRatio: container.retina.pixelRatio,
+    transformData: { ...transformData }
+  });
+}
+function drawShape(data) {
+  const { container, context, particle, radius, opacity, delta, strokeWidth, transformData } = data;
+  if (!particle.shape) {
+    return;
+  }
+  const drawer = container.shapeDrawers.get(particle.shape);
+  if (!drawer) {
+    return;
+  }
+  context.beginPath();
+  drawer.draw({
+    context,
+    particle,
+    radius,
+    opacity,
+    delta,
+    pixelRatio: container.retina.pixelRatio,
+    transformData: { ...transformData }
+  });
+  if (particle.shapeClose) {
+    context.closePath();
+  }
+  if (strokeWidth > minStrokeWidth) {
+    context.stroke();
+  }
+  if (particle.shapeFill) {
+    context.fill();
+  }
+}
+function drawShapeAfterDraw(data) {
+  const { container, context, particle, radius, opacity, delta, transformData } = data;
+  if (!particle.shape) {
+    return;
+  }
+  const drawer = container.shapeDrawers.get(particle.shape);
+  if (!(drawer == null ? void 0 : drawer.afterDraw)) {
+    return;
+  }
+  drawer.afterDraw({
+    context,
+    particle,
+    radius,
+    opacity,
+    delta,
+    pixelRatio: container.retina.pixelRatio,
+    transformData: { ...transformData }
+  });
+}
+function drawPlugin(context, plugin, delta) {
+  if (!plugin.draw) {
+    return;
+  }
+  plugin.draw(context, delta);
+}
+function drawParticlePlugin(context, plugin, particle, delta) {
+  if (!plugin.drawParticle) {
+    return;
+  }
+  plugin.drawParticle(context, particle, delta);
+}
+function alterHsl(color, type, value) {
+  return {
+    h: color.h,
+    s: color.s,
+    l: color.l + (type === AlterType.darken ? -lFactor : lFactor) * value
+  };
+}
+export {
+  alterHsl,
+  clear,
+  drawEffect,
+  drawLine,
+  drawParticle,
+  drawParticlePlugin,
+  drawPlugin,
+  drawShape,
+  drawShapeAfterDraw,
+  paintBase,
+  paintImage
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/ColorUtils.js

@@ -0,0 +1,316 @@
+import { randomInRange, setRangeValue, mix, getRangeValue, getRandom, getRangeMax, getRangeMin, clamp } from "./NumberUtils.js";
+import { defaultOpacity, rgbMax, sMin, half, double, hMin, lMax, sMax, hPhase, hMax, randomColorValue, defaultRgbMin, identity, midColorValue, lMin, percentDenominator, decayOffset, defaultLoops, defaultTime, millisecondsToSeconds, defaultVelocity, rgbFactor, sextuple, triple, phaseNumerator, sNormalizedOffset } from "../Core/Utils/Constants.js";
+import { isString, isArray } from "./TypeUtils.js";
+import { AnimationStatus } from "../Enums/AnimationStatus.js";
+import { itemFromArray } from "./Utils.js";
+function stringToRgba(engine, input) {
+  if (!input) {
+    return;
+  }
+  for (const manager of engine.colorManagers.values()) {
+    if (input.startsWith(manager.stringPrefix)) {
+      return manager.parseString(input);
+    }
+  }
+}
+function rangeColorToRgb(engine, input, index, useIndex = true) {
+  if (!input) {
+    return;
+  }
+  const color = isString(input) ? { value: input } : input;
+  if (isString(color.value)) {
+    return colorToRgb(engine, color.value, index, useIndex);
+  }
+  if (isArray(color.value)) {
+    return rangeColorToRgb(engine, {
+      value: itemFromArray(color.value, index, useIndex)
+    });
+  }
+  for (const manager of engine.colorManagers.values()) {
+    const res = manager.handleRangeColor(color);
+    if (res) {
+      return res;
+    }
+  }
+}
+function colorToRgb(engine, input, index, useIndex = true) {
+  if (!input) {
+    return;
+  }
+  const color = isString(input) ? { value: input } : input;
+  if (isString(color.value)) {
+    return color.value === randomColorValue ? getRandomRgbColor() : stringToRgb(engine, color.value);
+  }
+  if (isArray(color.value)) {
+    return colorToRgb(engine, {
+      value: itemFromArray(color.value, index, useIndex)
+    });
+  }
+  for (const manager of engine.colorManagers.values()) {
+    const res = manager.handleColor(color);
+    if (res) {
+      return res;
+    }
+  }
+}
+function rangeColorToHsl(engine, color, index, useIndex = true) {
+  const rgb = rangeColorToRgb(engine, color, index, useIndex);
+  return rgb ? rgbToHsl(rgb) : void 0;
+}
+function rgbToHsl(color) {
+  const r1 = color.r / rgbMax, g1 = color.g / rgbMax, b1 = color.b / rgbMax, max = Math.max(r1, g1, b1), min = Math.min(r1, g1, b1), res = {
+    h: hMin,
+    l: (max + min) * half,
+    s: sMin
+  };
+  if (max !== min) {
+    res.s = res.l < half ? (max - min) / (max + min) : (max - min) / (double - max - min);
+    res.h = r1 === max ? (g1 - b1) / (max - min) : res.h = g1 === max ? double + (b1 - r1) / (max - min) : double * double + (r1 - g1) / (max - min);
+  }
+  res.l *= lMax;
+  res.s *= sMax;
+  res.h *= hPhase;
+  if (res.h < hMin) {
+    res.h += hMax;
+  }
+  if (res.h >= hMax) {
+    res.h -= hMax;
+  }
+  return res;
+}
+function stringToRgb(engine, input) {
+  return stringToRgba(engine, input);
+}
+function hslToRgb(hsl) {
+  const h = (hsl.h % hMax + hMax) % hMax, s = Math.max(sMin, Math.min(sMax, hsl.s)), l = Math.max(lMin, Math.min(lMax, hsl.l)), hNormalized = h / hMax, sNormalized = s / sMax, lNormalized = l / lMax;
+  if (s === sMin) {
+    const grayscaleValue = Math.round(lNormalized * rgbFactor);
+    return { r: grayscaleValue, g: grayscaleValue, b: grayscaleValue };
+  }
+  const channel = (temp12, temp22, temp3) => {
+    const temp3Min = 0, temp3Max = 1;
+    if (temp3 < temp3Min) {
+      temp3++;
+    }
+    if (temp3 > temp3Max) {
+      temp3--;
+    }
+    if (temp3 * sextuple < temp3Max) {
+      return temp12 + (temp22 - temp12) * sextuple * temp3;
+    }
+    if (temp3 * double < temp3Max) {
+      return temp22;
+    }
+    if (temp3 * triple < temp3Max * double) {
+      const temp3Offset = double / triple;
+      return temp12 + (temp22 - temp12) * (temp3Offset - temp3) * sextuple;
+    }
+    return temp12;
+  }, temp1 = lNormalized < half ? lNormalized * (sNormalizedOffset + sNormalized) : lNormalized + sNormalized - lNormalized * sNormalized, temp2 = double * lNormalized - temp1, phaseThird = phaseNumerator / triple, red = Math.min(rgbFactor, rgbFactor * channel(temp2, temp1, hNormalized + phaseThird)), green = Math.min(rgbFactor, rgbFactor * channel(temp2, temp1, hNormalized)), blue = Math.min(rgbFactor, rgbFactor * channel(temp2, temp1, hNormalized - phaseThird));
+  return { r: Math.round(red), g: Math.round(green), b: Math.round(blue) };
+}
+function hslaToRgba(hsla) {
+  const rgbResult = hslToRgb(hsla);
+  return {
+    a: hsla.a,
+    b: rgbResult.b,
+    g: rgbResult.g,
+    r: rgbResult.r
+  };
+}
+function getRandomRgbColor(min) {
+  const fixedMin = defaultRgbMin, fixedMax = rgbMax + identity;
+  return {
+    b: Math.floor(randomInRange(setRangeValue(fixedMin, fixedMax))),
+    g: Math.floor(randomInRange(setRangeValue(fixedMin, fixedMax))),
+    r: Math.floor(randomInRange(setRangeValue(fixedMin, fixedMax)))
+  };
+}
+function getStyleFromRgb(color, opacity) {
+  return `rgba(${color.r}, ${color.g}, ${color.b}, ${opacity ?? defaultOpacity})`;
+}
+function getStyleFromHsl(color, opacity) {
+  return `hsla(${color.h}, ${color.s}%, ${color.l}%, ${opacity ?? defaultOpacity})`;
+}
+function colorMix(color1, color2, size1, size2) {
+  let rgb1 = color1, rgb2 = color2;
+  if (rgb1.r === void 0) {
+    rgb1 = hslToRgb(color1);
+  }
+  if (rgb2.r === void 0) {
+    rgb2 = hslToRgb(color2);
+  }
+  return {
+    b: mix(rgb1.b, rgb2.b, size1, size2),
+    g: mix(rgb1.g, rgb2.g, size1, size2),
+    r: mix(rgb1.r, rgb2.r, size1, size2)
+  };
+}
+function getLinkColor(p1, p2, linkColor) {
+  if (linkColor === randomColorValue) {
+    return getRandomRgbColor();
+  } else if (linkColor === midColorValue) {
+    const sourceColor = p1.getFillColor() ?? p1.getStrokeColor(), destColor = (p2 == null ? void 0 : p2.getFillColor()) ?? (p2 == null ? void 0 : p2.getStrokeColor());
+    if (sourceColor && destColor && p2) {
+      return colorMix(sourceColor, destColor, p1.getRadius(), p2.getRadius());
+    } else {
+      const hslColor = sourceColor ?? destColor;
+      if (hslColor) {
+        return hslToRgb(hslColor);
+      }
+    }
+  } else {
+    return linkColor;
+  }
+}
+function getLinkRandomColor(engine, optColor, blink, consent) {
+  const color = isString(optColor) ? optColor : optColor.value;
+  if (color === randomColorValue) {
+    if (consent) {
+      return rangeColorToRgb(engine, {
+        value: color
+      });
+    }
+    if (blink) {
+      return randomColorValue;
+    }
+    return midColorValue;
+  } else if (color === midColorValue) {
+    return midColorValue;
+  } else {
+    return rangeColorToRgb(engine, {
+      value: color
+    });
+  }
+}
+function getHslFromAnimation(animation) {
+  return animation !== void 0 ? {
+    h: animation.h.value,
+    s: animation.s.value,
+    l: animation.l.value
+  } : void 0;
+}
+function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
+  const resColor = {
+    h: {
+      enable: false,
+      value: hsl.h
+    },
+    s: {
+      enable: false,
+      value: hsl.s
+    },
+    l: {
+      enable: false,
+      value: hsl.l
+    }
+  };
+  if (animationOptions) {
+    setColorAnimation(resColor.h, animationOptions.h, reduceFactor);
+    setColorAnimation(resColor.s, animationOptions.s, reduceFactor);
+    setColorAnimation(resColor.l, animationOptions.l, reduceFactor);
+  }
+  return resColor;
+}
+function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
+  colorValue.enable = colorAnimation.enable;
+  if (colorValue.enable) {
+    colorValue.velocity = getRangeValue(colorAnimation.speed) / percentDenominator * reduceFactor;
+    colorValue.decay = decayOffset - getRangeValue(colorAnimation.decay);
+    colorValue.status = AnimationStatus.increasing;
+    colorValue.loops = defaultLoops;
+    colorValue.maxLoops = getRangeValue(colorAnimation.count);
+    colorValue.time = defaultTime;
+    colorValue.delayTime = getRangeValue(colorAnimation.delay) * millisecondsToSeconds;
+    if (!colorAnimation.sync) {
+      colorValue.velocity *= getRandom();
+      colorValue.value *= getRandom();
+    }
+    colorValue.initialValue = colorValue.value;
+    colorValue.offset = setRangeValue(colorAnimation.offset);
+  } else {
+    colorValue.velocity = defaultVelocity;
+  }
+}
+function updateColorValue(data, range, decrease, delta) {
+  const minLoops = 0, minDelay = 0, identity2 = 1, minVelocity = 0, minOffset = 0, velocityFactor = 3.6;
+  if (!data || !data.enable || (data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops)) {
+    return;
+  }
+  if (!data.time) {
+    data.time = 0;
+  }
+  if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+    data.time += delta.value;
+  }
+  if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+    return;
+  }
+  const offset = data.offset ? randomInRange(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity2, max = getRangeMax(range), min = getRangeMin(range);
+  if (!decrease || data.status === AnimationStatus.increasing) {
+    data.value += velocity;
+    if (data.value > max) {
+      if (!data.loops) {
+        data.loops = 0;
+      }
+      data.loops++;
+      if (decrease) {
+        data.status = AnimationStatus.decreasing;
+      } else {
+        data.value -= max;
+      }
+    }
+  } else {
+    data.value -= velocity;
+    const minValue = 0;
+    if (data.value < minValue) {
+      if (!data.loops) {
+        data.loops = 0;
+      }
+      data.loops++;
+      data.status = AnimationStatus.increasing;
+    }
+  }
+  if (data.velocity && decay !== identity2) {
+    data.velocity *= decay;
+  }
+  data.value = clamp(data.value, min, max);
+}
+function updateColor(color, delta) {
+  if (!color) {
+    return;
+  }
+  const { h, s, l } = color, ranges = {
+    h: { min: 0, max: 360 },
+    s: { min: 0, max: 100 },
+    l: { min: 0, max: 100 }
+  };
+  if (h) {
+    updateColorValue(h, ranges.h, false, delta);
+  }
+  if (s) {
+    updateColorValue(s, ranges.s, true, delta);
+  }
+  if (l) {
+    updateColorValue(l, ranges.l, true, delta);
+  }
+}
+export {
+  colorMix,
+  colorToRgb,
+  getHslAnimationFromHsl,
+  getHslFromAnimation,
+  getLinkColor,
+  getLinkRandomColor,
+  getRandomRgbColor,
+  getStyleFromHsl,
+  getStyleFromRgb,
+  hslToRgb,
+  hslaToRgba,
+  rangeColorToHsl,
+  rangeColorToRgb,
+  rgbToHsl,
+  stringToRgb,
+  updateColor,
+  updateColorValue
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/EventDispatcher.js

@@ -0,0 +1,47 @@
+import { minIndex, deleteCount } from "../Core/Utils/Constants.js";
+class EventDispatcher {
+  constructor() {
+    this._listeners = /* @__PURE__ */ 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 == null ? void 0 : listeners.forEach((handler) => handler(args));
+  }
+  hasEventListener(type) {
+    return !!this._listeners.get(type);
+  }
+  removeAllEventListeners(type) {
+    if (!type) {
+      this._listeners = /* @__PURE__ */ 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);
+    }
+  }
+}
+export {
+  EventDispatcher
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js

@@ -0,0 +1,135 @@
+import { MoveDirection } from "../Enums/Directions/MoveDirection.js";
+import { doublePI, threeQuarter, half, quarter, empty, percentDenominator, double } from "../Core/Utils/Constants.js";
+import { Vector } from "../Core/Utils/Vectors.js";
+import { isNumber } from "./TypeUtils.js";
+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 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 mix(comp1, comp2, weight1, weight2) {
+  return Math.floor((comp1 * weight1 + comp2 * weight2) / (weight1 + weight2));
+}
+function randomInRange(r) {
+  const max = getRangeMax(r), minOffset = 0;
+  let min = getRangeMin(r);
+  if (max === min) {
+    min = minOffset;
+  }
+  return getRandom() * (max - min) + min;
+}
+function getRangeValue(value) {
+  return isNumber(value) ? value : randomInRange(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 === void 0 && isNumber(source)) {
+    return source;
+  }
+  const min = getRangeMin(source), max = getRangeMax(source);
+  return value !== void 0 ? {
+    min: Math.min(min, value),
+    max: Math.max(max, value)
+  } : setRangeValue(min, max);
+}
+function getDistances(pointA, pointB) {
+  const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y, squareExp = 2;
+  return { dx, dy, distance: Math.sqrt(dx ** squareExp + dy ** squareExp) };
+}
+function getDistance(pointA, pointB) {
+  return getDistances(pointA, pointB).distance;
+}
+function degToRad(degrees) {
+  const PIDeg = 180;
+  return degrees * Math.PI / PIDeg;
+}
+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 collisionVelocity(v1, v2, m1, m2) {
+  return Vector.create(v1.x * (m1 - m2) / (m1 + m2) + v2.x * double * m2 / (m1 + m2), v1.y);
+}
+function calcExactPositionOrRandomFromSize(data) {
+  var _a, _b;
+  return {
+    x: ((_a = data.position) == null ? void 0 : _a.x) ?? getRandom() * data.size.width,
+    y: ((_b = data.position) == null ? void 0 : _b.y) ?? getRandom() * data.size.height
+  };
+}
+function parseAlpha(input) {
+  const defaultAlpha = 1;
+  if (!input) {
+    return defaultAlpha;
+  }
+  return input.endsWith("%") ? parseFloat(input) / percentDenominator : parseFloat(input);
+}
+export {
+  animate,
+  calcExactPositionOrRandomFromSize,
+  cancelAnimation,
+  clamp,
+  collisionVelocity,
+  degToRad,
+  getDistance,
+  getDistances,
+  getParticleBaseVelocity,
+  getParticleDirectionAngle,
+  getRandom,
+  getRangeMax,
+  getRangeMin,
+  getRangeValue,
+  mix,
+  parseAlpha,
+  randomInRange,
+  setRangeValue
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/OptionsUtils.js

@@ -0,0 +1,15 @@
+import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions.js";
+function loadOptions(options, ...sourceOptionsArr) {
+  for (const sourceOptions of sourceOptionsArr) {
+    options.load(sourceOptions);
+  }
+}
+function loadParticlesOptions(engine, container, ...sourceOptionsArr) {
+  const options = new ParticlesOptions(engine, container);
+  loadOptions(options, ...sourceOptionsArr);
+  return options;
+}
+export {
+  loadOptions,
+  loadParticlesOptions
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js

@@ -0,0 +1,26 @@
+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 === void 0;
+}
+export {
+  isArray,
+  isBoolean,
+  isNull,
+  isNumber,
+  isObject,
+  isString
+};