@truelab/truengine 4.2.0 → 5.1.0

package/dist/libs/particles.js

@@ -1,100 +1,203 @@
 var pt = Object.defineProperty;
 var ut = (i, t, e) => t in i ? pt(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
 var s = (i, t, e) => ut(i, typeof t != "symbol" ? t + "" : t, e);
-import { T as B, P as C, b as mt, S as dt, c as ft, d as xt } from "../pixi-chunk.js";
-class O {
+import { P as mt, T as B, S as dt, b as ft, c as C, d as xt } from "../pixi-chunk.js";
+var p = /* @__PURE__ */ ((i) => (i[i.Spawn = 0] = "Spawn", i[i.Normal = 2] = "Normal", i[i.Late = 5] = "Late", i))(p || {});
+class yt {
+  constructor(t) {
+    this.particle = t;
+  }
+  get x() {
+    return this.particle.x;
+  }
+  set x(t) {
+    this.particle.x = t;
+  }
+  get y() {
+    return this.particle.y;
+  }
+  set y(t) {
+    this.particle.y = t;
+  }
+  set(t = 0, e = t) {
+    this.particle.x = t, this.particle.y = e;
+  }
+}
+class vt {
+  constructor(t) {
+    this.particle = t;
+  }
+  get x() {
+    return this.particle.scaleX;
+  }
+  set x(t) {
+    this.particle.scaleX = t;
+  }
+  get y() {
+    return this.particle.scaleY;
+  }
+  set y(t) {
+    this.particle.scaleY = t;
+  }
+  set(t = 0, e = t) {
+    this.particle.scaleX = t, this.particle.scaleY = e;
+  }
+}
+class Pt {
+  constructor(t) {
+    this.particle = t;
+  }
+  get x() {
+    return this.particle.anchorX;
+  }
+  set x(t) {
+    this.particle.anchorX = t;
+  }
+  get y() {
+    return this.particle.anchorY;
+  }
+  set y(t) {
+    this.particle.anchorY = t;
+  }
+  set(t = 0, e = t) {
+    this.particle.anchorX = t, this.particle.anchorY = e;
+  }
+}
+class _t extends mt {
   /**
-   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
+   * @param emitter The emitter that controls this particle.
    */
-  constructor(t) {
+  constructor(e) {
+    super({ texture: B.EMPTY, anchorX: 0.5, anchorY: 0.5 });
     /**
-     * List of segment objects in the chain.
+     * The emitter that controls this particle.
      */
-    s(this, "segments");
+    s(this, "emitter");
     /**
-     * Total length of all segments of the chain.
+     * The maximum lifetime of this particle, in seconds.
      */
-    s(this, "totalLength");
+    s(this, "maxLife");
     /**
-     * Total length of segments up to and including the segment of the same index.
-     * Used for weighted random selection of segment.
+     * The current age of the particle, in seconds.
      */
-    s(this, "countingLengths");
-    this.segments = [], this.countingLengths = [], this.totalLength = 0, this.init(t);
+    s(this, "age");
+    /**
+     * The current age of the particle as a normalized value between 0 and 1.
+     */
+    s(this, "agePercent");
+    /**
+     * One divided by the max life of the particle, saved for slightly faster math.
+     */
+    s(this, "oneOverLife");
+    /**
+     * Reference to the next particle in the list.
+     */
+    s(this, "next");
+    /**
+     * Reference to the previous particle in the list.
+     */
+    s(this, "prev");
+    s(this, "prevChild");
+    s(this, "nextChild");
+    /**
+     * Static per-particle configuration for behaviors to use. Is not cleared when recycling.
+     */
+    s(this, "config");
+    /** Принимается от BlendModeBehavior, но ParticleContainer рендерит одним блендом — игнорируется */
+    s(this, "blendMode");
+    /** Флаг видимости для совместимости с эмиттером; рендер частицы им не управляет */
+    s(this, "visible");
+    /** ParticleContainer не является родителем в терминах сцен-графа — удаление делает эмиттер */
+    s(this, "parent", null);
+    s(this, "position");
+    s(this, "scale");
+    s(this, "anchor");
+    this.position = new yt(this), this.scale = new vt(this), this.anchor = new Pt(this), this.prevChild = this.nextChild = null, this.emitter = e, this.config = {}, this.visible = !0, this.maxLife = 0, this.age = 0, this.agePercent = 0, this.oneOverLife = 0, this.next = null, this.prev = null;
   }
   /**
-   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
+   * Initializes the particle for use, based on the properties that have to
+   * have been set already on the particle.
    */
-  init(t) {
-    if (!t || !t.length)
-      this.segments.push({ p1: { x: 0, y: 0 }, p2: { x: 0, y: 0 }, l: 0 });
-    else if (Array.isArray(t[0]))
-      for (let e = 0; e < t.length; ++e) {
-        const a = t[e];
-        let r = a[0];
-        for (let l = 1; l < a.length; ++l) {
-          const n = a[l];
-          this.segments.push({ p1: r, p2: n, l: 0 }), r = n;
-        }
-      }
-    else {
-      let e = t[0];
-      for (let a = 1; a < t.length; ++a) {
-        const r = t[a];
-        this.segments.push({ p1: e, p2: r, l: 0 }), e = r;
-      }
-    }
-    for (let e = 0; e < this.segments.length; ++e) {
-      const { p1: a, p2: r } = this.segments[e], l = Math.sqrt((r.x - a.x) * (r.x - a.x) + (r.y - a.y) * (r.y - a.y));
-      this.segments[e].l = l, this.totalLength += l, this.countingLengths.push(this.totalLength);
-    }
+  init(e) {
+    this.maxLife = e, this.age = this.agePercent = 0, this.rotation = 0, this.x = this.y = 0, this.scaleX = this.scaleY = 1, this.tint = 16777215, this.alpha = 1, this.oneOverLife = 1 / this.maxLife, this.visible = !0;
   }
   /**
-   * Gets a random point in the chain.
-   * @param out The point to store the selected position in.
+   * Kills the particle, removing it from the display list
+   * and telling the emitter to recycle it.
    */
-  getRandPos(t) {
-    const e = Math.random() * this.totalLength;
-    let a, r;
-    if (this.segments.length === 1)
-      a = this.segments[0], r = e;
-    else
-      for (let o = 0; o < this.countingLengths.length; ++o)
-        if (e < this.countingLengths[o]) {
-          a = this.segments[o], r = o === 0 ? e : e - this.countingLengths[o - 1];
-          break;
-        }
-    r /= a.l || 1;
-    const { p1: l, p2: n } = a;
-    t.x = l.x + r * (n.x - l.x), t.y = l.y + r * (n.y - l.y);
+  kill() {
+    this.emitter.recycle(this);
+  }
+  /**
+   * Destroys the particle, removing references and preventing future use.
+   */
+  destroy() {
+    this.emitter = this.next = this.prev = null;
   }
 }
-s(O, "type", "polygonalChain"), s(O, "editorConfig", null);
-class A {
-  constructor(t) {
+class wt extends dt {
+  /**
+   * @param emitter The emitter that controls this particle.
+   */
+  constructor(e) {
+    super();
     /**
-     * X (left) position of the rectangle.
+     * The emitter that controls this particle.
      */
-    s(this, "x");
+    s(this, "emitter");
     /**
-     * Y (top) position of the rectangle.
+     * The maximum lifetime of this particle, in seconds.
      */
-    s(this, "y");
+    s(this, "maxLife");
     /**
-     * Width of the rectangle.
+     * The current age of the particle, in seconds.
      */
-    s(this, "w");
+    s(this, "age");
     /**
-     * Height of the rectangle.
+     * The current age of the particle as a normalized value between 0 and 1.
      */
-    s(this, "h");
-    this.x = t.x, this.y = t.y, this.w = t.w, this.h = t.h;
+    s(this, "agePercent");
+    /**
+     * One divided by the max life of the particle, saved for slightly faster math.
+     */
+    s(this, "oneOverLife");
+    /**
+     * Reference to the next particle in the list.
+     */
+    s(this, "next");
+    /**
+     * Reference to the previous particle in the list.
+     */
+    s(this, "prev");
+    s(this, "prevChild");
+    s(this, "nextChild");
+    /**
+     * Static per-particle configuration for behaviors to use. Is not cleared when recycling.
+     */
+    s(this, "config");
+    this.prevChild = this.nextChild = null, this.emitter = e, this.config = {}, this.anchor.x = this.anchor.y = 0.5, this.maxLife = 0, this.age = 0, this.agePercent = 0, this.oneOverLife = 0, this.next = null, this.prev = null, this.init = this.init, this.kill = this.kill;
   }
-  getRandPos(t) {
-    t.x = Math.random() * this.w + this.x, t.y = Math.random() * this.h + this.y;
+  /**
+   * Initializes the particle for use, based on the properties that have to
+   * have been set already on the particle.
+   */
+  init(e) {
+    this.maxLife = e, this.age = this.agePercent = 0, this.rotation = 0, this.position.x = this.position.y = 0, this.scale.x = this.scale.y = 1, this.tint = 16777215, this.alpha = 1, this.oneOverLife = 1 / this.maxLife, this.visible = !0;
+  }
+  /**
+   * Kills the particle, removing it from the display list
+   * and telling the emitter to recycle it.
+   */
+  kill() {
+    this.emitter.recycle(this);
+  }
+  /**
+   * Destroys the particle, removing references and preventing future use.
+   */
+  destroy() {
+    this.parent && this.parent.removeChild(this), this.emitter = this.next = this.prev = null, super.destroy();
   }
 }
-s(A, "type", "rect"), s(A, "editorConfig", null);
 class P {
   /**
    * @param value The value for this node
@@ -153,7 +256,7 @@ class P {
   }
 }
 let F = B.from;
-const yt = !1, _ = Math.PI / 180;
+const gt = !1, _ = Math.PI / 180;
 function w(i, t) {
   if (!i) return;
   const e = Math.sin(i), a = Math.cos(i), r = t.x * a - t.y * e, l = t.x * e + t.y * a;
@@ -190,7 +293,7 @@ function nt(i) {
 function ot(i) {
   return i ? i.toLowerCase().replace(/_/g, "-").replace(/ /g, "-") : "normal";
 }
-function vt(i, t = 10) {
+function Ct(i, t = 10) {
   (typeof t != "number" || t <= 0) && (t = 10);
   const e = new P(g(i[0].value), i[0].time);
   e.isStepped = !0;
@@ -214,7 +317,7 @@ const It = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   DEG_TO_RADS: _,
   GetTextureFromString: F,
   combineRGBComponents: k,
-  createSteppedGradient: vt,
+  createSteppedGradient: Ct,
   generateEase: nt,
   getBlendMode: ot,
   hexToRGB: g,
@@ -222,1562 +325,1457 @@ const It = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   normalize: lt,
   rotatePoint: w,
   scaleBy: rt,
-  verbose: yt
-}, Symbol.toStringTag, { value: "Module" }));
-class T {
-  constructor(t) {
+  verbose: gt
+}, Symbol.toStringTag, { value: "Module" })), st = ft.shared, b = Symbol("Position particle per emitter position"), L = class L {
+  /**
+   * @param particleParent The container to add the particles to.
+   * @param particleImages A texture or array of textures to use
+   *                       for the particles. Strings will be turned
+   *                       into textures via Texture.from().
+   * @param config A configuration object containing settings for the emitter.
+   * @param config.emit If config.emit is explicitly passed as false, the
+   *                    Emitter will start disabled.
+   * @param config.autoUpdate If config.autoUpdate is explicitly passed as
+   *                          true, the Emitter will automatically call
+   *                          update via the PIXI shared ticker.
+   */
+  constructor(t, e) {
     /**
-     * X position of the center of the shape.
+     * Active initialization behaviors for this emitter.
      */
-    s(this, "x");
+    s(this, "initBehaviors");
     /**
-     * Y position of the center of the shape.
+     * Active update behaviors for this emitter.
      */
-    s(this, "y");
+    s(this, "updateBehaviors");
     /**
-     * Radius of circle, or outer radius of a ring.
+     * Active recycle behaviors for this emitter.
      */
-    s(this, "radius");
+    s(this, "recycleBehaviors");
+    // properties for individual particles
     /**
-     * Inner radius of a ring. Use 0 to have a circle.
+     * The minimum lifetime for a particle, in seconds.
      */
-    s(this, "innerRadius");
+    s(this, "minLifetime");
     /**
-     * If rotation should be applied to particles.
+     * The maximum lifetime for a particle, in seconds.
+     */
+    s(this, "maxLifetime");
+    /**
+     * An easing function for nonlinear interpolation of values. Accepts a single
+     * parameter of time as a value from 0-1, inclusive. Expected outputs are values
+     * from 0-1, inclusive.
+     */
+    s(this, "customEase");
+    // properties for spawning particles
+    /**
+     * Time between particle spawns in seconds.
+     */
+    s(this, "_frequency");
+    /**
+     * Chance that a particle will be spawned on each opportunity to spawn one.
+     * 0 is 0%, 1 is 100%.
+     */
+    s(this, "spawnChance");
+    /**
+     * Maximum number of particles to keep alive at a time. If this limit
+     * is reached, no more particles will spawn until some have died.
+     */
+    s(this, "maxParticles");
+    /**
+     * The amount of time in seconds to emit for before setting emit to false.
+     * A value of -1 is an unlimited amount of time.
+     */
+    s(this, "emitterLifetime");
+    /**
+     * Position at which to spawn particles, relative to the emitter's owner's origin.
+     * For example, the flames of a rocket travelling right might have a spawnPos
+     * of {x:-50, y:0}.
+     * to spawn at the rear of the rocket.
+     * To change this, use updateSpawnPos().
+     */
+    s(this, "spawnPos");
+    /**
+     * Number of particles to spawn time that the frequency allows for particles to spawn.
+     */
+    s(this, "particlesPerWave");
+    /**
+     * Rotation of the emitter or emitter's owner in degrees. This is added to
+     * the calculated spawn angle.
+     * To change this, use rotate().
      */
     s(this, "rotation");
-    this.x = t.x || 0, this.y = t.y || 0, this.radius = t.radius, this.innerRadius = t.innerRadius || 0, this.rotation = !!t.affectRotation;
-  }
-  getRandPos(t) {
-    this.innerRadius !== this.radius ? t.x = Math.random() * (this.radius - this.innerRadius) + this.innerRadius : t.x = this.radius, t.y = 0;
-    const e = Math.random() * Math.PI * 2;
-    this.rotation && (t.rotation += e), w(e, t.position), t.position.x += this.x, t.position.y += this.y;
-  }
-}
-s(T, "type", "torus"), s(T, "editorConfig", null);
-const Pt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  PolygonalChain: O,
-  Rectangle: A,
-  Torus: T
-}, Symbol.toStringTag, { value: "Module" }));
-var p = /* @__PURE__ */ ((i) => (i[i.Spawn = 0] = "Spawn", i[i.Normal = 2] = "Normal", i[i.Late = 5] = "Late", i))(p || {});
-const _t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null
-}, Symbol.toStringTag, { value: "Module" }));
-class I {
-  constructor(t) {
-    // doesn't _really_ need to be late, but doing so ensures that we can override any
-    // rotation behavior that is mistakenly added
-    s(this, "order", p.Late);
-    s(this, "minStart");
-    s(this, "maxStart");
-    s(this, "accel");
-    s(this, "rotate");
-    s(this, "maxSpeed");
-    this.minStart = t.minStart, this.maxStart = t.maxStart, this.accel = t.accel, this.rotate = !!t.rotate, this.maxSpeed = t.maxSpeed ?? 0;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.random() * (this.maxStart - this.minStart) + this.minStart;
-      e.config.velocity ? e.config.velocity.set(a, 0) : e.config.velocity = new C(a, 0), w(e.rotation, e.config.velocity), e = e.next;
-    }
-  }
-  updateParticle(t, e) {
-    const a = t.config.velocity, r = a.x, l = a.y;
-    if (a.x += this.accel.x * e, a.y += this.accel.y * e, this.maxSpeed) {
-      const n = at(a);
-      n > this.maxSpeed && rt(a, this.maxSpeed / n);
-    }
-    t.x += (r + a.x) / 2 * e, t.y += (l + a.y) / 2 * e, this.rotate && (t.rotation = Math.atan2(a.y, a.x));
-  }
-}
-s(I, "type", "moveAcceleration"), s(I, "editorConfig", null);
-function wt(i) {
-  return this.ease && (i = this.ease(i)), (this.first.next.value - this.first.value) * i + this.first.value;
-}
-function gt(i) {
-  this.ease && (i = this.ease(i));
-  const t = this.first.value, e = this.first.next.value, a = (e.r - t.r) * i + t.r, r = (e.g - t.g) * i + t.g, l = (e.b - t.b) * i + t.b;
-  return k(a, r, l);
-}
-function Ct(i) {
-  this.ease && (i = this.ease(i));
-  let t = this.first, { next: e } = t;
-  for (; i > e.time; )
-    t = e, e = e.next;
-  return i = (i - t.time) / (e.time - t.time), (e.value - t.value) * i + t.value;
-}
-function St(i) {
-  this.ease && (i = this.ease(i));
-  let t = this.first, { next: e } = t;
-  for (; i > e.time; )
-    t = e, e = e.next;
-  i = (i - t.time) / (e.time - t.time);
-  const a = t.value, r = e.value, l = (r.r - a.r) * i + a.r, n = (r.g - a.g) * i + a.g, o = (r.b - a.b) * i + a.b;
-  return k(l, n, o);
-}
-function bt(i) {
-  this.ease && (i = this.ease(i));
-  let t = this.first;
-  for (; t.next && i > t.next.time; )
-    t = t.next;
-  return t.value;
-}
-function Lt(i) {
-  this.ease && (i = this.ease(i));
-  let t = this.first;
-  for (; t.next && i > t.next.time; )
-    t = t.next;
-  const e = t.value;
-  return k(e.r, e.g, e.b);
-}
-class R {
-  /**
-   * @param isColor If this list handles color values
-   */
-  constructor(t = !1) {
     /**
-     * The first property node in the linked list.
+     * The world position of the emitter's owner, to add spawnPos to when
+     * spawning particles. To change this, use updateOwnerPos().
      */
-    s(this, "first");
+    s(this, "ownerPos");
     /**
-     * Calculates the correct value for the current interpolation value. This method is set in
-     * the reset() method.
-     * @param lerp The interpolation value from 0-1.
-     * @return The interpolated value. Colors are converted to the hex value.
+     * The origin + spawnPos in the previous update, so that the spawn position
+     * can be interpolated to space out particles better.
      */
-    s(this, "interpolate");
+    s(this, "_prevEmitterPos");
     /**
-     * A custom easing method for this list.
-     * @param lerp The interpolation value from 0-1.
-     * @return The eased value, also from 0-1.
+     * If _prevEmitterPos is valid, to prevent interpolation on the first update
      */
-    s(this, "ease");
+    s(this, "_prevPosIsValid");
     /**
-     * If this list manages colors, which requires a different method for interpolation.
+     * If either ownerPos or spawnPos has changed since the previous update.
      */
-    s(this, "isColor");
-    this.first = null, this.isColor = !!t, this.interpolate = null, this.ease = null;
+    s(this, "_posChanged");
+    /**
+     * The container to add particles to.
+     */
+    s(this, "_parent");
+    /**
+     * If particles should be added at the back of the display list instead of the front.
+     */
+    s(this, "addAtBack");
+    /**
+     * The current number of active particles.
+     */
+    s(this, "particleCount");
+    /**
+     * If particles should be emitted during update() calls. Setting this to false
+     * stops new particles from being created, but allows existing ones to die out.
+     */
+    s(this, "_emit");
+    /**
+     * The timer for when to spawn particles in seconds, where numbers less
+     * than 0 mean that particles should be spawned.
+     */
+    s(this, "_spawnTimer");
+    /**
+     * The life of the emitter in seconds.
+     */
+    s(this, "_emitterLife");
+    /**
+     * The particles that are active and on the display list. This is the first particle in a
+     * linked list.
+     */
+    s(this, "_activeParticlesFirst");
+    /**
+     * The particles that are active and on the display list. This is the last particle in a
+     * linked list.
+     */
+    s(this, "_activeParticlesLast");
+    /**
+     * The particles that are not currently being used. This is the first particle in a
+     * linked list.
+     */
+    s(this, "_poolFirst");
+    /**
+     * The original config object that this emitter was initialized with.
+     */
+    s(this, "_origConfig");
+    /**
+     * If the update function is called automatically from the shared ticker.
+     * Setting this to false requires calling the update function manually.
+     */
+    s(this, "_autoUpdate");
+    /**
+     * Родитель является PIXI.ParticleContainer (частицы добавляются через addParticle)
+     */
+    s(this, "_isParticleContainer");
+    /**
+     * If the emitter should destroy itself when all particles have died out. This is set by
+     * playOnceAndDestroy();
+     */
+    s(this, "_destroyWhenComplete");
+    /**
+     * A callback for when all particles have died out. This is set by
+     * playOnceAndDestroy() or playOnce();
+     */
+    s(this, "_completeCallback");
+    this.initBehaviors = [], this.updateBehaviors = [], this.recycleBehaviors = [], this.minLifetime = 0, this.maxLifetime = 0, this.customEase = null, this._frequency = 1, this.spawnChance = 1, this.maxParticles = 1e3, this.emitterLifetime = -1, this.spawnPos = new C(), this.particlesPerWave = 1, this.rotation = 0, this.ownerPos = new C(), this._prevEmitterPos = new C(), this._prevPosIsValid = !1, this._posChanged = !1, this._parent = null, this._isParticleContainer = !1, this.addAtBack = !1, this.particleCount = 0, this._emit = !1, this._spawnTimer = 0, this._emitterLife = -1, this._activeParticlesFirst = null, this._activeParticlesLast = null, this._poolFirst = null, this._origConfig = null, this._autoUpdate = !1, this._destroyWhenComplete = !1, this._completeCallback = null, this.parent = t, e && this.init(e), this.recycle = this.recycle, this.update = this.update, this.rotate = this.rotate, this.updateSpawnPos = this.updateSpawnPos, this.updateOwnerPos = this.updateOwnerPos;
   }
   /**
-   * Resets the list for use.
-   * @param first The first node in the list.
-   * @param first.isStepped If the values should be stepped instead of interpolated linearly.
+   * Registers a new behavior, so that it will be recognized when initializing emitters.
+   * Behaviors registered later with duplicate types will override older ones, although there is no limit on
+   * the allowed types.
+   * @param constructor The behavior class to register.
    */
-  reset(t) {
-    this.first = t, t.next && t.next.time >= 1 ? this.interpolate = this.isColor ? gt : wt : t.isStepped ? this.interpolate = this.isColor ? Lt : bt : this.interpolate = this.isColor ? St : Ct, this.ease = this.first.ease;
-  }
-}
-class V {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "list");
-    this.list = new R(!1), this.list.reset(P.createList(t.alpha));
+  static registerBehavior(t) {
+    L.knownBehaviors[t.type] = t;
   }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.alpha = this.list.first.value, e = e.next;
+  /**
+   * Time between particle spawns in seconds. If this value is not a number greater than 0,
+   * it will be set to 1 (particle per second) to prevent infinite loops.
+   */
+  get frequency() {
+    return this._frequency;
   }
-  updateParticle(t) {
-    t.alpha = this.list.interpolate(t.agePercent);
+  set frequency(t) {
+    typeof t == "number" && t > 0 ? this._frequency = t : this._frequency = 1;
   }
-}
-s(V, "type", "alpha"), s(V, "editorConfig", null);
-class q {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "value");
-    this.value = t.alpha;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.alpha = this.value, e = e.next;
+  /**
+   * The container to add particles to. Settings this will dump any active particles.
+   */
+  get parent() {
+    return this._parent;
   }
-}
-s(q, "type", "alphaStatic"), s(q, "editorConfig", null);
-function ht(i) {
-  const t = [];
-  for (let e = 0; e < i.length; ++e) {
-    let a = i[e];
-    if (typeof a == "string")
-      t.push(F(a));
-    else if (a instanceof B)
-      t.push(a);
-    else {
-      let r = a.count || 1;
-      for (typeof a.texture == "string" ? a = F(a.texture) : a = a.texture; r > 0; --r)
-        t.push(a);
-    }
+  set parent(t) {
+    this.cleanup();
+    const e = t instanceof xt;
+    e !== this._isParticleContainer && (this._poolFirst = null), this._isParticleContainer = e, this._parent = t;
   }
-  return t;
-}
-class N {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "anims");
-    this.anims = [];
-    for (let e = 0; e < t.anims.length; ++e) {
-      const a = t.anims[e], r = ht(a.textures), l = a.framerate < 0 ? -1 : a.framerate > 0 ? a.framerate : 60, n = {
-        textures: r,
-        duration: l > 0 ? r.length / l : 0,
-        framerate: l,
-        loop: l > 0 ? !!a.loop : !1
-      };
-      this.anims.push(n);
-    }
+  /**
+   * Создать частицу подходящего класса: лёгкую для ParticleContainer или спрайтовую для обычного контейнера
+   */
+  _createParticle() {
+    return this._isParticleContainer ? new _t(this) : new wt(this);
   }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.floor(Math.random() * this.anims.length), r = e.config.anim = this.anims[a];
-      e.texture = r.textures[0], e.config.animElapsed = 0, r.framerate === -1 ? (e.config.animDuration = e.maxLife, e.config.animFramerate = r.textures.length / e.maxLife) : (e.config.animDuration = r.duration, e.config.animFramerate = r.framerate), e = e.next;
-    }
+  /**
+   * Добавить частицу в контейнер (addParticle для ParticleContainer, addChild для обычного)
+   */
+  _addParticleToParent(t) {
+    this._isParticleContainer ? this._parent.addParticle(t) : this.addAtBack ? this._parent.addChildAt(t, 0) : this._parent.addChild(t);
   }
-  updateParticle(t, e) {
-    const { config: a } = t, { anim: r } = a;
-    a.animElapsed += e, a.animElapsed >= a.animDuration && (a.anim.loop ? a.animElapsed = a.animElapsed % a.animDuration : a.animElapsed = a.animDuration - 1e-6);
-    const l = a.animElapsed * a.animFramerate + 1e-7 | 0;
-    t.texture = r.textures[l] || r.textures[r.textures.length - 1] || B.EMPTY;
+  /**
+   * Sets up the emitter based on the config settings.
+   * @param config A configuration object containing settings for the emitter.
+   */
+  init(t) {
+    if (!t)
+      return;
+    this.cleanup(), this._origConfig = t, this.minLifetime = t.lifetime.min, this.maxLifetime = t.lifetime.max, t.ease ? this.customEase = typeof t.ease == "function" ? t.ease : nt(t.ease) : this.customEase = null, this.particlesPerWave = 1, t.particlesPerWave && t.particlesPerWave > 1 && (this.particlesPerWave = t.particlesPerWave), this.frequency = t.frequency, this.spawnChance = typeof t.spawnChance == "number" && t.spawnChance > 0 ? t.spawnChance : 1, this.emitterLifetime = t.emitterLifetime || -1, this.maxParticles = t.maxParticles > 0 ? t.maxParticles : 1e3, this.addAtBack = !!t.addAtBack, this.rotation = 0, this.ownerPos.set(0), t.pos ? this.spawnPos.copyFrom(t.pos) : this.spawnPos.set(0), this._prevEmitterPos.copyFrom(this.spawnPos), this._prevPosIsValid = !1, this._spawnTimer = 0, this.emit = t.emit === void 0 ? !0 : !!t.emit, this.autoUpdate = !!t.autoUpdate;
+    const e = t.behaviors.map((a) => {
+      const r = L.knownBehaviors[a.type];
+      return r ? new r(a.config) : (console.error(`Unknown behavior: ${a.type}`), null);
+    }).filter((a) => !!a);
+    e.push(b), e.sort((a, r) => a === b ? r.order === p.Spawn ? 1 : -1 : r === b ? a.order === p.Spawn ? -1 : 1 : a.order - r.order), this.initBehaviors = e.slice(), this.updateBehaviors = e.filter((a) => a !== b && a.updateParticle), this.recycleBehaviors = e.filter(
+      (a) => a !== b && a.recycleParticle
+    );
   }
-}
-s(N, "type", "animatedRandom"), s(N, "editorConfig", null);
-class U {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "anim");
-    const { anim: e } = t, a = ht(e.textures), r = e.framerate < 0 ? -1 : e.framerate > 0 ? e.framerate : 60;
-    this.anim = {
-      textures: a,
-      duration: r > 0 ? a.length / r : 0,
-      framerate: r,
-      loop: r > 0 ? !!e.loop : !1
-    };
+  /**
+   * Gets the instantiated behavior of the specified type, if it is present on this emitter.
+   * @param type The behavior type to find.
+   */
+  getBehavior(t) {
+    return L.knownBehaviors[t] && this.initBehaviors.find((e) => e instanceof L.knownBehaviors[t]) || null;
   }
-  initParticles(t) {
-    let e = t;
-    const { anim: a } = this;
-    for (; e; )
-      e.texture = a.textures[0], e.config.animElapsed = 0, a.framerate === -1 ? (e.config.animDuration = e.maxLife, e.config.animFramerate = a.textures.length / e.maxLife) : (e.config.animDuration = a.duration, e.config.animFramerate = a.framerate), e = e.next;
+  /**
+   * Fills the pool with the specified number of particles, so that they don't have to be instantiated later.
+   * @param count The number of particles to create.
+   */
+  fillPool(t) {
+    for (; t > 0; --t) {
+      const e = this._createParticle();
+      e.next = this._poolFirst, this._poolFirst = e;
+    }
   }
-  updateParticle(t, e) {
-    const { anim: a } = this, { config: r } = t;
-    r.animElapsed += e, r.animElapsed >= r.animDuration && (a.loop ? r.animElapsed = r.animElapsed % r.animDuration : r.animElapsed = r.animDuration - 1e-6);
-    const l = r.animElapsed * r.animFramerate + 1e-7 | 0;
-    t.texture = a.textures[l] || a.textures[a.textures.length - 1] || B.EMPTY;
+  /**
+   * Recycles an individual particle. For internal use only.
+   * @param particle The particle to recycle.
+   * @param fromCleanup If this is being called to manually clean up all particles.
+   * @internal
+   */
+  recycle(t, e = !1) {
+    var a;
+    for (let r = 0; r < this.recycleBehaviors.length; ++r)
+      this.recycleBehaviors[r].recycleParticle(t, !e);
+    t.next && (t.next.prev = t.prev), t.prev && (t.prev.next = t.next), t === this._activeParticlesLast && (this._activeParticlesLast = t.prev), t === this._activeParticlesFirst && (this._activeParticlesFirst = t.next), t.prev = null, t.next = this._poolFirst, this._poolFirst = t, this._isParticleContainer ? (a = this._parent) == null || a.removeParticle(t) : t.parent && t.parent.removeChild(t), --this.particleCount;
   }
-}
-s(U, "type", "animatedSingle"), s(U, "editorConfig", null);
-class W {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "value");
-    this.value = t.blendMode;
+  /**
+   * Sets the rotation of the emitter to a new value. This rotates the spawn position in addition
+   * to particle direction.
+   * @param newRot The new rotation, in degrees.
+   */
+  rotate(t) {
+    if (this.rotation === t) return;
+    const e = t - this.rotation;
+    this.rotation = t, w(e, this.spawnPos), this._posChanged = !0;
   }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.blendMode = ot(this.value), e = e.next;
+  /**
+   * Changes the spawn position of the emitter.
+   * @param x The new x value of the spawn position for the emitter.
+   * @param y The new y value of the spawn position for the emitter.
+   */
+  updateSpawnPos(t, e) {
+    this._posChanged = !0, this.spawnPos.x = t, this.spawnPos.y = e;
   }
-}
-s(W, "type", "blendMode"), s(W, "editorConfig", null);
-class Y {
-  constructor(t) {
-    s(this, "order", p.Spawn);
-    s(this, "spacing");
-    s(this, "start");
-    s(this, "distance");
-    this.spacing = t.spacing * _, this.start = t.start * _, this.distance = t.distance;
+  /**
+   * Changes the position of the emitter's owner. You should call this if you are adding
+   * particles to the world container that your emitter's owner is moving around in.
+   * @param x The new x value of the emitter's owner.
+   * @param y The new y value of the emitter's owner.
+   */
+  updateOwnerPos(t, e) {
+    this._posChanged = !0, this.ownerPos.x = t, this.ownerPos.y = e;
   }
-  initParticles(t) {
-    let e = 0, a = t;
-    for (; a; ) {
-      let r;
-      this.spacing ? r = this.start + this.spacing * e : r = Math.random() * Math.PI * 2, a.rotation = r, this.distance && (a.position.x = this.distance, w(r, a.position)), a = a.next, ++e;
-    }
+  /**
+   * Prevents emitter position interpolation in the next update.
+   * This should be used if you made a major position change of your emitter's owner
+   * that was not normal movement.
+   */
+  resetPositionTracking() {
+    this._prevPosIsValid = !1;
   }
-}
-s(Y, "type", "spawnBurst"), s(Y, "editorConfig", null);
-class D {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "list");
-    this.list = new R(!0), this.list.reset(P.createList(t.color));
+  /**
+   * If particles should be emitted during update() calls. Setting this to false
+   * stops new particles from being created, but allows existing ones to die out.
+   */
+  get emit() {
+    return this._emit;
   }
-  initParticles(t) {
-    let e = t;
-    const a = this.list.first.value, r = k(a.r, a.g, a.b);
-    for (; e; )
-      e.tint = r, e = e.next;
+  set emit(t) {
+    this._emit = !!t, this._emitterLife = this.emitterLifetime;
   }
-  updateParticle(t) {
-    t.tint = this.list.interpolate(t.agePercent);
+  /**
+   * If the update function is called automatically from the shared ticker.
+   * Setting this to false requires calling the update function manually.
+   */
+  get autoUpdate() {
+    return this._autoUpdate;
   }
-}
-s(D, "type", "color"), s(D, "editorConfig", null);
-class X {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "value");
-    let { color: e } = t;
-    e.charAt(0) === "#" ? e = e.substr(1) : e.indexOf("0x") === 0 && (e = e.substr(2)), this.value = parseInt(e, 16);
+  set autoUpdate(t) {
+    this._autoUpdate && !t ? st.remove(this.update, this) : !this._autoUpdate && t && st.add(this.update, this), this._autoUpdate = !!t;
   }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.tint = this.value, e = e.next;
+  /**
+   * Starts emitting particles, sets autoUpdate to true, and sets up the Emitter to destroy itself
+   * when particle emission is complete.
+   * @param callback Callback for when emission is complete (all particles have died off)
+   */
+  playOnceAndDestroy(t) {
+    this.autoUpdate = !0, this.emit = !0, this._destroyWhenComplete = !0, this._completeCallback = t;
   }
-}
-s(X, "type", "colorStatic"), s(X, "editorConfig", null);
-class j {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "textures");
-    s(this, "index");
-    this.index = 0, this.textures = t.textures.map((e) => typeof e == "string" ? F(e) : e);
+  /**
+   * Starts emitting particles and optionally calls a callback when particle emission is complete.
+   * @param callback Callback for when emission is complete (all particles have died off)
+   */
+  playOnce(t) {
+    this.emit = !0, this._completeCallback = t;
   }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.texture = this.textures[this.index], ++this.index >= this.textures.length && (this.index = 0), e = e.next;
-  }
-}
-s(j, "type", "textureOrdered"), s(j, "editorConfig", null);
-const E = new C(), ct = [
-  "E",
-  "LN2",
-  "LN10",
-  "LOG2E",
-  "LOG10E",
-  "PI",
-  "SQRT1_2",
-  "SQRT2",
-  "abs",
-  "acos",
-  "acosh",
-  "asin",
-  "asinh",
-  "atan",
-  "atanh",
-  "atan2",
-  "cbrt",
-  "ceil",
-  "cos",
-  "cosh",
-  "exp",
-  "expm1",
-  "floor",
-  "fround",
-  "hypot",
-  "log",
-  "log1p",
-  "log10",
-  "log2",
-  "max",
-  "min",
-  "pow",
-  "random",
-  "round",
-  "sign",
-  "sin",
-  "sinh",
-  "sqrt",
-  "tan",
-  "tanh"
-], Mt = new RegExp(
-  [
-    // Allow the 4 basic operations, parentheses and all numbers/decimals, as well
-    // as 'x', for the variable usage.
-    "[01234567890\\.\\*\\-\\+\\/\\(\\)x ,]"
-  ].concat(ct).join("|"),
-  "g"
-);
-function Et(i) {
-  const t = i.match(Mt);
-  for (let e = t.length - 1; e >= 0; --e)
-    ct.indexOf(t[e]) >= 0 && (t[e] = `Math.${t[e]}`);
-  return i = t.join(""), new Function("x", `return ${i};`);
-}
-class G {
-  constructor(t) {
-    // *MUST* happen after other behaviors do initialization so that we can read initial transformations
-    s(this, "order", p.Late);
-    /**
-     * The function representing the path the particle should take.
-     */
-    s(this, "path");
-    s(this, "list");
-    s(this, "minMult");
-    if (t.path)
-      if (typeof t.path == "function")
-        this.path = t.path;
-      else
-        try {
-          this.path = Et(t.path);
-        } catch {
-          this.path = null;
+  /**
+   * Updates all particles spawned by this emitter and emits new ones.
+   * @param delta Time elapsed since the previous frame, in __seconds__.
+   */
+  update(t) {
+    if (typeof t != "number" && (t = t.deltaMS * 1e-3), this._autoUpdate && (t = st.elapsedMS * 1e-3), !this._parent) return;
+    for (let n = this._activeParticlesFirst, o; n; n = o)
+      if (o = n.next, n.age += t, n.age > n.maxLife || n.age < 0)
+        this.recycle(n);
+      else {
+        let c = n.age * n.oneOverLife;
+        this.customEase && (this.customEase.length === 4 ? c = this.customEase(c, 0, 1, 1) : c = this.customEase(c)), n.agePercent = c;
+        for (let u = 0; u < this.updateBehaviors.length; ++u)
+          if (this.updateBehaviors[u].updateParticle(n, t)) {
+            this.recycle(n);
+            break;
+          }
+      }
+    let e, a;
+    this._prevPosIsValid && (e = this._prevEmitterPos.x, a = this._prevEmitterPos.y);
+    const r = this.ownerPos.x + this.spawnPos.x, l = this.ownerPos.y + this.spawnPos.y;
+    if (this._emit)
+      for (this._spawnTimer -= t < 0 ? 0 : t; this._spawnTimer <= 0; ) {
+        if (this._emitterLife >= 0 && (this._emitterLife -= this._frequency, this._emitterLife <= 0)) {
+          this._spawnTimer = 0, this._emitterLife = 0, this.emit = !1;
+          break;
         }
-    else
-      this.path = (e) => e;
-    this.list = new R(!1), this.list.reset(P.createList(t.speed)), this.minMult = t.minMult ?? 1;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      e.config.initRotation = e.rotation, e.config.initPosition ? e.config.initPosition.copyFrom(e.position) : e.config.initPosition = new C(e.x, e.y), e.config.movement = 0;
-      const a = Math.random() * (1 - this.minMult) + this.minMult;
-      e.config.speedMult = a, e = e.next;
+        if (this.particleCount >= this.maxParticles) {
+          this._spawnTimer += this._frequency;
+          continue;
+        }
+        let n, o;
+        if (this._prevPosIsValid && this._posChanged) {
+          const d = 1 + this._spawnTimer / t;
+          n = (r - e) * d + e, o = (l - a) * d + a;
+        } else
+          n = r, o = l;
+        let c = null, u = null;
+        for (let d = Math.min(this.particlesPerWave, this.maxParticles - this.particleCount), y = 0; y < d; ++y) {
+          if (this.spawnChance < 1 && Math.random() >= this.spawnChance)
+            continue;
+          let f;
+          if (this.minLifetime === this.maxLifetime ? f = this.minLifetime : f = Math.random() * (this.maxLifetime - this.minLifetime) + this.minLifetime, -this._spawnTimer >= f)
+            continue;
+          let x;
+          this._poolFirst ? (x = this._poolFirst, this._poolFirst = this._poolFirst.next, x.next = null) : x = this._createParticle(), x.init(f), this._addParticleToParent(x), c ? (u.next = x, x.prev = u, u = x) : u = c = x, ++this.particleCount;
+        }
+        if (c) {
+          this._activeParticlesLast ? (this._activeParticlesLast.next = c, c.prev = this._activeParticlesLast, this._activeParticlesLast = u) : (this._activeParticlesFirst = c, this._activeParticlesLast = u);
+          for (let d = 0; d < this.initBehaviors.length; ++d) {
+            const y = this.initBehaviors[d];
+            if (y === b)
+              for (let f = c, x; f; f = x) {
+                x = f.next, this.rotation !== 0 && (w(this.rotation, f.position), f.rotation += this.rotation), f.position.x += n, f.position.y += o, f.age += -this._spawnTimer;
+                let h = f.age * f.oneOverLife;
+                this.customEase && (this.customEase.length === 4 ? h = this.customEase(h, 0, 1, 1) : h = this.customEase(h)), f.agePercent = h;
+              }
+            else
+              y.initParticles(c);
+          }
+          for (let d = c, y; d; d = y) {
+            y = d.next;
+            for (let f = 0; f < this.updateBehaviors.length; ++f)
+              if (this.updateBehaviors[f].updateParticle(d, -this._spawnTimer)) {
+                this.recycle(d);
+                break;
+              }
+          }
+        }
+        this._spawnTimer += this._frequency;
+      }
+    if (this._posChanged && (this._prevEmitterPos.x = r, this._prevEmitterPos.y = l, this._prevPosIsValid = !0, this._posChanged = !1), !this._emit && !this._activeParticlesFirst) {
+      if (this._completeCallback) {
+        const n = this._completeCallback;
+        this._completeCallback = null, n();
+      }
+      this._destroyWhenComplete && this.destroy();
     }
   }
-  updateParticle(t, e) {
-    const a = this.list.interpolate(t.agePercent) * t.config.speedMult;
-    t.config.movement += a * e, E.x = t.config.movement, E.y = this.path(E.x), w(t.config.initRotation, E), t.position.x = t.config.initPosition.x + E.x, t.position.y = t.config.initPosition.y + E.y;
-  }
-}
-s(G, "type", "movePath"), s(G, "editorConfig", null);
-class z {
-  constructor() {
-    s(this, "order", p.Spawn);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  initParticles(t) {
-  }
-}
-s(z, "type", "spawnPoint"), s(z, "editorConfig", null);
-class $ {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "textures");
-    this.textures = t.textures.map((e) => typeof e == "string" ? F(e) : e);
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.floor(Math.random() * this.textures.length);
-      e.texture = this.textures[a], e = e.next;
+  /**
+   * Emits a single wave of particles, using standard spawnChance & particlesPerWave settings. Does not affect
+   * regular spawning through the frequency, and ignores the emit property. The max particle count is respected, however,
+   * so if there are already too many particles then nothing will happen.
+   */
+  emitNow() {
+    const t = this.ownerPos.x + this.spawnPos.x, e = this.ownerPos.y + this.spawnPos.y;
+    let a = null, r = null;
+    for (let l = Math.min(this.particlesPerWave, this.maxParticles - this.particleCount), n = 0; n < l; ++n) {
+      if (this.spawnChance < 1 && Math.random() >= this.spawnChance)
+        continue;
+      let o;
+      this._poolFirst ? (o = this._poolFirst, this._poolFirst = this._poolFirst.next, o.next = null) : o = this._createParticle();
+      let c;
+      this.minLifetime === this.maxLifetime ? c = this.minLifetime : c = Math.random() * (this.maxLifetime - this.minLifetime) + this.minLifetime, o.init(c), this._addParticleToParent(o), a ? (r.next = o, o.prev = r, r = o) : r = a = o, ++this.particleCount;
+    }
+    if (a) {
+      this._activeParticlesLast ? (this._activeParticlesLast.next = a, a.prev = this._activeParticlesLast, this._activeParticlesLast = r) : (this._activeParticlesFirst = a, this._activeParticlesLast = r);
+      for (let l = 0; l < this.initBehaviors.length; ++l) {
+        const n = this.initBehaviors[l];
+        if (n === b)
+          for (let o = a, c; o; o = c)
+            c = o.next, this.rotation !== 0 && (w(this.rotation, o.position), o.rotation += this.rotation), o.position.x += t, o.position.y += e;
+        else
+          n.initParticles(a);
+      }
     }
   }
-}
-s($, "type", "textureRandom"), s($, "editorConfig", null);
-class Q {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "minStart");
-    s(this, "maxStart");
-    s(this, "minSpeed");
-    s(this, "maxSpeed");
-    s(this, "accel");
-    this.minStart = t.minStart * _, this.maxStart = t.maxStart * _, this.minSpeed = t.minSpeed * _, this.maxSpeed = t.maxSpeed * _, this.accel = t.accel * _;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      this.minStart === this.maxStart ? e.rotation += this.maxStart : e.rotation += Math.random() * (this.maxStart - this.minStart) + this.minStart, e.config.rotSpeed = Math.random() * (this.maxSpeed - this.minSpeed) + this.minSpeed, e = e.next;
+  /**
+   * Kills all active particles immediately.
+   */
+  cleanup() {
+    let t, e;
+    for (t = this._activeParticlesFirst; t; t = e)
+      e = t.next, this.recycle(t, !0);
+    this._activeParticlesFirst = this._activeParticlesLast = null, this.particleCount = 0;
   }
-  updateParticle(t, e) {
-    if (this.accel) {
-      const a = t.config.rotSpeed;
-      t.config.rotSpeed += this.accel * e, t.rotation += (t.config.rotSpeed + a) / 2 * e;
-    } else
-      t.rotation += t.config.rotSpeed * e;
-  }
-}
-s(Q, "type", "rotation"), s(Q, "editorConfig", null);
-class H {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "min");
-    s(this, "max");
-    this.min = t.min * _, this.max = t.max * _;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      this.min === this.max ? e.rotation += this.max : e.rotation += Math.random() * (this.max - this.min) + this.min, e = e.next;
-  }
-}
-s(H, "type", "rotationStatic"), s(H, "editorConfig", null);
-class J {
-  constructor(t) {
-    s(this, "order", p.Late + 1);
-    s(this, "rotation");
-    this.rotation = (t.rotation || 0) * _;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.rotation = this.rotation, e = e.next;
-  }
-}
-s(J, "type", "noRotation"), s(J, "editorConfig", null);
-class K {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "list");
-    s(this, "minMult");
-    this.list = new R(!1), this.list.reset(P.createList(t.scale)), this.minMult = t.minMult ?? 1;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.random() * (1 - this.minMult) + this.minMult;
-      e.config.scaleMult = a, e.scale.x = e.scale.y = this.list.first.value * a, e = e.next;
-    }
-  }
-  updateParticle(t) {
-    t.scale.x = t.scale.y = this.list.interpolate(t.agePercent) * t.config.scaleMult;
-  }
-}
-s(K, "type", "scale"), s(K, "editorConfig", null);
-class Z {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "min");
-    s(this, "max");
-    this.min = t.min, this.max = t.max;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.random() * (this.max - this.min) + this.min;
-      e.scale.x = e.scale.y = a, e = e.next;
-    }
-  }
-}
-s(Z, "type", "scaleStatic"), s(Z, "editorConfig", null);
-const L = class L {
-  constructor(t) {
-    s(this, "order", p.Spawn);
-    s(this, "shape");
-    const e = L.shapes[t.type];
-    if (!e)
-      throw new Error(`No shape found with type '${t.type}'`);
-    this.shape = new e(t.data);
+  /**
+   * If this emitter has been destroyed. Note that a destroyed emitter can still be reused, after
+   * having a new parent set and being reinitialized.
+   */
+  get destroyed() {
+    return !(this._parent && this.initBehaviors.length);
   }
   /**
-   * Registers a shape to be used by the ShapeSpawn behavior.
-   * @param constructor The shape class constructor to use, with a static `type` property to reference it by.
-   * @param typeOverride An optional type override, primarily for registering a shape under multiple names.
+   * Destroys the emitter and all of its particles.
    */
-  static registerShape(t, e) {
-    L.shapes[e || t.type] = t;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      this.shape.getRandPos(e), e = e.next;
+  destroy() {
+    this.autoUpdate = !1, this.cleanup();
+    let t;
+    for (let e = this._poolFirst; e; e = t)
+      t = e.next, e.destroy();
+    this._poolFirst = this._parent = this.spawnPos = this.ownerPos = this.customEase = this._completeCallback = null, this.initBehaviors.length = this.updateBehaviors.length = this.recycleBehaviors.length = 0;
   }
 };
-s(L, "type", "spawnShape"), s(L, "editorConfig", null), /**
- * Dictionary of all registered shape classes.
- */
-s(L, "shapes", {});
-let S = L;
-S.registerShape(O);
-S.registerShape(A);
-S.registerShape(T);
-S.registerShape(T, "circle");
-class tt {
-  constructor(t) {
-    s(this, "order", p.Normal);
-    s(this, "texture");
-    this.texture = typeof t.texture == "string" ? F(t.texture) : t.texture;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; )
-      e.texture = this.texture, e = e.next;
-  }
-}
-s(tt, "type", "textureSingle"), s(tt, "editorConfig", null);
-class et {
-  constructor(t) {
-    s(this, "order", p.Late);
-    s(this, "list");
-    s(this, "minMult");
-    this.list = new R(!1), this.list.reset(P.createList(t.speed)), this.minMult = t.minMult ?? 1;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.random() * (1 - this.minMult) + this.minMult;
-      e.config.speedMult = a, e.config.velocity ? e.config.velocity.set(this.list.first.value * a, 0) : e.config.velocity = new C(this.list.first.value * a, 0), w(e.rotation, e.config.velocity), e = e.next;
-    }
-  }
-  updateParticle(t, e) {
-    const a = this.list.interpolate(t.agePercent) * t.config.speedMult, r = t.config.velocity;
-    lt(r), rt(r, a), t.x += r.x * e, t.y += r.y * e;
-  }
-}
-s(et, "type", "moveSpeed"), s(et, "editorConfig", null);
-class it {
-  constructor(t) {
-    s(this, "order", p.Late);
-    s(this, "min");
-    s(this, "max");
-    this.min = t.min, this.max = t.max;
-  }
-  initParticles(t) {
-    let e = t;
-    for (; e; ) {
-      const a = Math.random() * (this.max - this.min) + this.min;
-      e.config.velocity ? e.config.velocity.set(a, 0) : e.config.velocity = new C(a, 0), w(e.rotation, e.config.velocity), e = e.next;
-    }
-  }
-  updateParticle(t, e) {
-    const { velocity: a } = t.config;
-    t.x += a.x * e, t.y += a.y * e;
-  }
-}
-s(it, "type", "moveSpeedStatic"), s(it, "editorConfig", null);
-const Vt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  AccelerationBehavior: I,
-  AlphaBehavior: V,
-  BehaviorOrder: p,
-  BlendModeBehavior: W,
-  BurstSpawnBehavior: Y,
-  ColorBehavior: D,
-  NoRotationBehavior: J,
-  OrderedTextureBehavior: j,
-  PathBehavior: G,
-  PointSpawnBehavior: z,
-  RandomAnimatedTextureBehavior: N,
-  RandomTextureBehavior: $,
-  RotationBehavior: Q,
-  ScaleBehavior: K,
-  ShapeSpawnBehavior: S,
-  SingleAnimatedTextureBehavior: U,
-  SingleTextureBehavior: tt,
-  SpeedBehavior: et,
-  StaticAlphaBehavior: q,
-  StaticColorBehavior: X,
-  StaticRotationBehavior: H,
-  StaticScaleBehavior: Z,
-  StaticSpeedBehavior: it,
-  editor: _t,
-  spawnShapes: Pt
-}, Symbol.toStringTag, { value: "Module" }));
-class Ft {
-  constructor(t) {
-    this.particle = t;
-  }
-  get x() {
-    return this.particle.x;
-  }
-  set x(t) {
-    this.particle.x = t;
-  }
-  get y() {
-    return this.particle.y;
-  }
-  set y(t) {
-    this.particle.y = t;
-  }
-  set(t = 0, e = t) {
-    this.particle.x = t, this.particle.y = e;
-  }
-}
-class Tt {
-  constructor(t) {
-    this.particle = t;
-  }
-  get x() {
-    return this.particle.scaleX;
-  }
-  set x(t) {
-    this.particle.scaleX = t;
-  }
-  get y() {
-    return this.particle.scaleY;
-  }
-  set y(t) {
-    this.particle.scaleY = t;
-  }
-  set(t = 0, e = t) {
-    this.particle.scaleX = t, this.particle.scaleY = e;
-  }
-}
-class Bt {
-  constructor(t) {
-    this.particle = t;
-  }
-  get x() {
-    return this.particle.anchorX;
-  }
-  set x(t) {
-    this.particle.anchorX = t;
-  }
-  get y() {
-    return this.particle.anchorY;
-  }
-  set y(t) {
-    this.particle.anchorY = t;
-  }
-  set(t = 0, e = t) {
-    this.particle.anchorX = t, this.particle.anchorY = e;
-  }
-}
-class kt extends mt {
-  /**
-   * @param emitter The emitter that controls this particle.
-   */
-  constructor(e) {
-    super({ texture: B.EMPTY, anchorX: 0.5, anchorY: 0.5 });
-    /**
-     * The emitter that controls this particle.
-     */
-    s(this, "emitter");
-    /**
-     * The maximum lifetime of this particle, in seconds.
-     */
-    s(this, "maxLife");
-    /**
-     * The current age of the particle, in seconds.
-     */
-    s(this, "age");
-    /**
-     * The current age of the particle as a normalized value between 0 and 1.
-     */
-    s(this, "agePercent");
-    /**
-     * One divided by the max life of the particle, saved for slightly faster math.
-     */
-    s(this, "oneOverLife");
-    /**
-     * Reference to the next particle in the list.
-     */
-    s(this, "next");
-    /**
-     * Reference to the previous particle in the list.
-     */
-    s(this, "prev");
-    s(this, "prevChild");
-    s(this, "nextChild");
-    /**
-     * Static per-particle configuration for behaviors to use. Is not cleared when recycling.
-     */
-    s(this, "config");
-    /** Принимается от BlendModeBehavior, но ParticleContainer рендерит одним блендом — игнорируется */
-    s(this, "blendMode");
-    /** Флаг видимости для совместимости с эмиттером; рендер частицы им не управляет */
-    s(this, "visible");
-    /** ParticleContainer не является родителем в терминах сцен-графа — удаление делает эмиттер */
-    s(this, "parent", null);
-    s(this, "position");
-    s(this, "scale");
-    s(this, "anchor");
-    this.position = new Ft(this), this.scale = new Tt(this), this.anchor = new Bt(this), this.prevChild = this.nextChild = null, this.emitter = e, this.config = {}, this.visible = !0, this.maxLife = 0, this.age = 0, this.agePercent = 0, this.oneOverLife = 0, this.next = null, this.prev = null;
-  }
-  /**
-   * Initializes the particle for use, based on the properties that have to
-   * have been set already on the particle.
-   */
-  init(e) {
-    this.maxLife = e, this.age = this.agePercent = 0, this.rotation = 0, this.x = this.y = 0, this.scaleX = this.scaleY = 1, this.tint = 16777215, this.alpha = 1, this.oneOverLife = 1 / this.maxLife, this.visible = !0;
-  }
-  /**
-   * Kills the particle, removing it from the display list
-   * and telling the emitter to recycle it.
-   */
-  kill() {
-    this.emitter.recycle(this);
-  }
-  /**
-   * Destroys the particle, removing references and preventing future use.
-   */
-  destroy() {
-    this.emitter = this.next = this.prev = null;
-  }
-}
-class Rt extends dt {
-  /**
-   * @param emitter The emitter that controls this particle.
-   */
-  constructor(e) {
-    super();
-    /**
-     * The emitter that controls this particle.
-     */
-    s(this, "emitter");
-    /**
-     * The maximum lifetime of this particle, in seconds.
-     */
-    s(this, "maxLife");
-    /**
-     * The current age of the particle, in seconds.
-     */
-    s(this, "age");
-    /**
-     * The current age of the particle as a normalized value between 0 and 1.
-     */
-    s(this, "agePercent");
-    /**
-     * One divided by the max life of the particle, saved for slightly faster math.
-     */
-    s(this, "oneOverLife");
-    /**
-     * Reference to the next particle in the list.
-     */
-    s(this, "next");
-    /**
-     * Reference to the previous particle in the list.
-     */
-    s(this, "prev");
-    s(this, "prevChild");
-    s(this, "nextChild");
-    /**
-     * Static per-particle configuration for behaviors to use. Is not cleared when recycling.
-     */
-    s(this, "config");
-    this.prevChild = this.nextChild = null, this.emitter = e, this.config = {}, this.anchor.x = this.anchor.y = 0.5, this.maxLife = 0, this.age = 0, this.agePercent = 0, this.oneOverLife = 0, this.next = null, this.prev = null, this.init = this.init, this.kill = this.kill;
-  }
-  /**
-   * Initializes the particle for use, based on the properties that have to
-   * have been set already on the particle.
-   */
-  init(e) {
-    this.maxLife = e, this.age = this.agePercent = 0, this.rotation = 0, this.position.x = this.position.y = 0, this.scale.x = this.scale.y = 1, this.tint = 16777215, this.alpha = 1, this.oneOverLife = 1 / this.maxLife, this.visible = !0;
-  }
-  /**
-   * Kills the particle, removing it from the display list
-   * and telling the emitter to recycle it.
-   */
-  kill() {
-    this.emitter.recycle(this);
-  }
-  /**
-   * Destroys the particle, removing references and preventing future use.
-   */
-  destroy() {
-    this.parent && this.parent.removeChild(this), this.emitter = this.next = this.prev = null, super.destroy();
+s(L, "knownBehaviors", {});
+let m = L;
+function Vt(i, t) {
+  var a, r, l, n, o, c, u, d, y, f, x;
+  if ("behaviors" in i)
+    return i;
+  const e = {
+    lifetime: i.lifetime,
+    ease: i.ease,
+    particlesPerWave: i.particlesPerWave,
+    frequency: i.frequency,
+    spawnChance: i.spawnChance,
+    emitterLifetime: i.emitterLifetime,
+    maxParticles: i.maxParticles,
+    addAtBack: i.addAtBack,
+    pos: i.pos,
+    emit: i.emit,
+    autoUpdate: i.autoUpdate,
+    behaviors: []
+  };
+  if (i.alpha)
+    if ("start" in i.alpha)
+      if (i.alpha.start === i.alpha.end)
+        i.alpha.start !== 1 && e.behaviors.push({
+          type: "alphaStatic",
+          config: { alpha: i.alpha.start }
+        });
+      else {
+        const h = {
+          list: [
+            { time: 0, value: i.alpha.start },
+            { time: 1, value: i.alpha.end }
+          ]
+        };
+        e.behaviors.push({
+          type: "alpha",
+          config: { alpha: h }
+        });
+      }
+    else i.alpha.list.length === 1 ? i.alpha.list[0].value !== 1 && e.behaviors.push({
+      type: "alphaStatic",
+      config: { alpha: i.alpha.list[0].value }
+    }) : e.behaviors.push({
+      type: "alpha",
+      config: { alpha: i.alpha }
+    });
+  if (i.acceleration && (i.acceleration.x || i.acceleration.y)) {
+    let h, v;
+    "start" in i.speed ? (h = i.speed.start * (i.speed.minimumSpeedMultiplier ?? 1), v = i.speed.start) : (h = i.speed.list[0].value * (i.minimumSpeedMultiplier ?? 1), v = i.speed.list[0].value), e.behaviors.push({
+      type: "moveAcceleration",
+      config: {
+        accel: i.acceleration,
+        minStart: h,
+        maxStart: v,
+        rotate: !i.noRotation,
+        maxSpeed: i.maxSpeed
+      }
+    });
+  } else if ((a = i.extraData) != null && a.path) {
+    let h, v;
+    "start" in i.speed ? (v = i.speed.minimumSpeedMultiplier ?? 1, i.speed.start === i.speed.end ? h = {
+      list: [{ time: 0, value: i.speed.start }]
+    } : h = {
+      list: [
+        { time: 0, value: i.speed.start },
+        { time: 1, value: i.speed.end }
+      ]
+    }) : (h = i.speed, v = i.minimumSpeedMultiplier ?? 1), e.behaviors.push({
+      type: "movePath",
+      config: {
+        path: i.extraData.path,
+        speed: h,
+        minMult: v
+      }
+    });
+  } else if (i.speed)
+    if ("start" in i.speed)
+      if (i.speed.start === i.speed.end)
+        e.behaviors.push({
+          type: "moveSpeedStatic",
+          config: {
+            min: i.speed.start * (i.speed.minimumSpeedMultiplier ?? 1),
+            max: i.speed.start
+          }
+        });
+      else {
+        const h = {
+          list: [
+            { time: 0, value: i.speed.start },
+            { time: 1, value: i.speed.end }
+          ]
+        };
+        e.behaviors.push({
+          type: "moveSpeed",
+          config: { speed: h, minMult: i.speed.minimumSpeedMultiplier }
+        });
+      }
+    else i.speed.list.length === 1 ? e.behaviors.push({
+      type: "moveSpeedStatic",
+      config: {
+        min: i.speed.list[0].value * (i.minimumSpeedMultiplier ?? 1),
+        max: i.speed.list[0].value
+      }
+    }) : e.behaviors.push({
+      type: "moveSpeed",
+      config: { speed: i.speed, minMult: i.minimumSpeedMultiplier ?? 1 }
+    });
+  if (i.scale)
+    if ("start" in i.scale) {
+      const h = i.scale.minimumScaleMultiplier ?? 1;
+      if (i.scale.start === i.scale.end)
+        e.behaviors.push({
+          type: "scaleStatic",
+          config: {
+            min: i.scale.start * h,
+            max: i.scale.start
+          }
+        });
+      else {
+        const v = {
+          list: [
+            { time: 0, value: i.scale.start },
+            { time: 1, value: i.scale.end }
+          ]
+        };
+        e.behaviors.push({
+          type: "scale",
+          config: { scale: v, minMult: h }
+        });
+      }
+    } else if (i.scale.list.length === 1) {
+      const h = i.minimumScaleMultiplier ?? 1, v = i.scale.list[0].value;
+      e.behaviors.push({
+        type: "scaleStatic",
+        config: { min: v * h, max: v }
+      });
+    } else
+      e.behaviors.push({
+        type: "scale",
+        config: { scale: i.scale, minMult: i.minimumScaleMultiplier ?? 1 }
+      });
+  if (i.color)
+    if ("start" in i.color)
+      if (i.color.start === i.color.end)
+        i.color.start !== "ffffff" && e.behaviors.push({
+          type: "colorStatic",
+          config: { color: i.color.start }
+        });
+      else {
+        const h = {
+          list: [
+            { time: 0, value: i.color.start },
+            { time: 1, value: i.color.end }
+          ]
+        };
+        e.behaviors.push({
+          type: "color",
+          config: { color: h }
+        });
+      }
+    else i.color.list.length === 1 ? i.color.list[0].value !== "ffffff" && e.behaviors.push({
+      type: "colorStatic",
+      config: { color: i.color.list[0].value }
+    }) : e.behaviors.push({
+      type: "color",
+      config: { color: i.color }
+    });
+  if (i.rotationAcceleration || (r = i.rotationSpeed) != null && r.min || (l = i.rotationSpeed) != null && l.max ? e.behaviors.push({
+    type: "rotation",
+    config: {
+      accel: i.rotationAcceleration || 0,
+      minSpeed: ((n = i.rotationSpeed) == null ? void 0 : n.min) || 0,
+      maxSpeed: ((o = i.rotationSpeed) == null ? void 0 : o.max) || 0,
+      minStart: ((c = i.startRotation) == null ? void 0 : c.min) || 0,
+      maxStart: ((u = i.startRotation) == null ? void 0 : u.max) || 0
+    }
+  }) : ((d = i.startRotation) != null && d.min || (y = i.startRotation) != null && y.max) && e.behaviors.push({
+    type: "rotationStatic",
+    config: {
+      min: ((f = i.startRotation) == null ? void 0 : f.min) || 0,
+      max: ((x = i.startRotation) == null ? void 0 : x.max) || 0
+    }
+  }), i.noRotation && e.behaviors.push({
+    type: "noRotation",
+    config: {}
+  }), i.blendMode && i.blendMode !== "normal" && e.behaviors.push({
+    type: "blendMode",
+    config: {
+      blendMode: i.blendMode
+    }
+  }), Array.isArray(t) && typeof t[0] != "string" && "framerate" in t[0]) {
+    for (let h = 0; h < t.length; ++h)
+      t[h].framerate === "matchLife" && (t[h].framerate = -1);
+    e.behaviors.push({
+      type: "animatedRandom",
+      config: {
+        anims: t
+      }
+    });
+  } else typeof t != "string" && "framerate" in t ? (t.framerate === "matchLife" && (t.framerate = -1), e.behaviors.push({
+    type: "animatedSingle",
+    config: {
+      anim: t
+    }
+  })) : i.orderedArt && Array.isArray(t) ? e.behaviors.push({
+    type: "textureOrdered",
+    config: {
+      textures: t
+    }
+  }) : Array.isArray(t) ? e.behaviors.push({
+    type: "textureRandom",
+    config: {
+      textures: t
+    }
+  }) : e.behaviors.push({
+    type: "textureSingle",
+    config: {
+      texture: t
+    }
+  });
+  if (i.spawnType === "burst")
+    e.behaviors.push({
+      type: "spawnBurst",
+      config: {
+        start: i.angleStart || 0,
+        spacing: i.particleSpacing,
+        // older formats bursted from a single point
+        distance: 0
+      }
+    });
+  else if (i.spawnType === "point")
+    e.behaviors.push({
+      type: "spawnPoint",
+      config: {}
+    });
+  else {
+    let h;
+    i.spawnType === "ring" ? h = {
+      type: "torus",
+      data: {
+        x: i.spawnCircle.x,
+        y: i.spawnCircle.y,
+        radius: i.spawnCircle.r,
+        innerRadius: i.spawnCircle.minR,
+        affectRotation: !0
+      }
+    } : i.spawnType === "circle" ? h = {
+      type: "torus",
+      data: {
+        x: i.spawnCircle.x,
+        y: i.spawnCircle.y,
+        radius: i.spawnCircle.r,
+        innerRadius: 0,
+        affectRotation: !1
+      }
+    } : i.spawnType === "rect" ? h = {
+      type: "rect",
+      data: i.spawnRect
+    } : i.spawnType === "polygonalChain" && (h = {
+      type: "polygonalChain",
+      data: i.spawnPolygon
+    }), h && e.behaviors.push({
+      type: "spawnShape",
+      config: h
+    });
   }
+  return e;
 }
-const st = ft.shared, b = Symbol("Position particle per emitter position"), M = class M {
+class O {
   /**
-   * @param particleParent The container to add the particles to.
-   * @param particleImages A texture or array of textures to use
-   *                       for the particles. Strings will be turned
-   *                       into textures via Texture.from().
-   * @param config A configuration object containing settings for the emitter.
-   * @param config.emit If config.emit is explicitly passed as false, the
-   *                    Emitter will start disabled.
-   * @param config.autoUpdate If config.autoUpdate is explicitly passed as
-   *                          true, the Emitter will automatically call
-   *                          update via the PIXI shared ticker.
+   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
    */
-  constructor(t, e) {
-    /**
-     * Active initialization behaviors for this emitter.
-     */
-    s(this, "initBehaviors");
+  constructor(t) {
     /**
-     * Active update behaviors for this emitter.
+     * List of segment objects in the chain.
      */
-    s(this, "updateBehaviors");
+    s(this, "segments");
     /**
-     * Active recycle behaviors for this emitter.
+     * Total length of all segments of the chain.
      */
-    s(this, "recycleBehaviors");
-    // properties for individual particles
+    s(this, "totalLength");
     /**
-     * The minimum lifetime for a particle, in seconds.
+     * Total length of segments up to and including the segment of the same index.
+     * Used for weighted random selection of segment.
      */
-    s(this, "minLifetime");
+    s(this, "countingLengths");
+    this.segments = [], this.countingLengths = [], this.totalLength = 0, this.init(t);
+  }
+  /**
+   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
+   */
+  init(t) {
+    if (!t || !t.length)
+      this.segments.push({ p1: { x: 0, y: 0 }, p2: { x: 0, y: 0 }, l: 0 });
+    else if (Array.isArray(t[0]))
+      for (let e = 0; e < t.length; ++e) {
+        const a = t[e];
+        let r = a[0];
+        for (let l = 1; l < a.length; ++l) {
+          const n = a[l];
+          this.segments.push({ p1: r, p2: n, l: 0 }), r = n;
+        }
+      }
+    else {
+      let e = t[0];
+      for (let a = 1; a < t.length; ++a) {
+        const r = t[a];
+        this.segments.push({ p1: e, p2: r, l: 0 }), e = r;
+      }
+    }
+    for (let e = 0; e < this.segments.length; ++e) {
+      const { p1: a, p2: r } = this.segments[e], l = Math.sqrt((r.x - a.x) * (r.x - a.x) + (r.y - a.y) * (r.y - a.y));
+      this.segments[e].l = l, this.totalLength += l, this.countingLengths.push(this.totalLength);
+    }
+  }
+  /**
+   * Gets a random point in the chain.
+   * @param out The point to store the selected position in.
+   */
+  getRandPos(t) {
+    const e = Math.random() * this.totalLength;
+    let a, r;
+    if (this.segments.length === 1)
+      a = this.segments[0], r = e;
+    else
+      for (let o = 0; o < this.countingLengths.length; ++o)
+        if (e < this.countingLengths[o]) {
+          a = this.segments[o], r = o === 0 ? e : e - this.countingLengths[o - 1];
+          break;
+        }
+    r /= a.l || 1;
+    const { p1: l, p2: n } = a;
+    t.x = l.x + r * (n.x - l.x), t.y = l.y + r * (n.y - l.y);
+  }
+}
+s(O, "type", "polygonalChain"), s(O, "editorConfig", null);
+class A {
+  constructor(t) {
     /**
-     * The maximum lifetime for a particle, in seconds.
+     * X (left) position of the rectangle.
      */
-    s(this, "maxLifetime");
+    s(this, "x");
     /**
-     * An easing function for nonlinear interpolation of values. Accepts a single
-     * parameter of time as a value from 0-1, inclusive. Expected outputs are values
-     * from 0-1, inclusive.
+     * Y (top) position of the rectangle.
      */
-    s(this, "customEase");
-    // properties for spawning particles
+    s(this, "y");
     /**
-     * Time between particle spawns in seconds.
+     * Width of the rectangle.
      */
-    s(this, "_frequency");
+    s(this, "w");
     /**
-     * Chance that a particle will be spawned on each opportunity to spawn one.
-     * 0 is 0%, 1 is 100%.
+     * Height of the rectangle.
      */
-    s(this, "spawnChance");
+    s(this, "h");
+    this.x = t.x, this.y = t.y, this.w = t.w, this.h = t.h;
+  }
+  getRandPos(t) {
+    t.x = Math.random() * this.w + this.x, t.y = Math.random() * this.h + this.y;
+  }
+}
+s(A, "type", "rect"), s(A, "editorConfig", null);
+class T {
+  constructor(t) {
     /**
-     * Maximum number of particles to keep alive at a time. If this limit
-     * is reached, no more particles will spawn until some have died.
+     * X position of the center of the shape.
      */
-    s(this, "maxParticles");
+    s(this, "x");
     /**
-     * The amount of time in seconds to emit for before setting emit to false.
-     * A value of -1 is an unlimited amount of time.
+     * Y position of the center of the shape.
      */
-    s(this, "emitterLifetime");
+    s(this, "y");
     /**
-     * Position at which to spawn particles, relative to the emitter's owner's origin.
-     * For example, the flames of a rocket travelling right might have a spawnPos
-     * of {x:-50, y:0}.
-     * to spawn at the rear of the rocket.
-     * To change this, use updateSpawnPos().
+     * Radius of circle, or outer radius of a ring.
      */
-    s(this, "spawnPos");
+    s(this, "radius");
     /**
-     * Number of particles to spawn time that the frequency allows for particles to spawn.
+     * Inner radius of a ring. Use 0 to have a circle.
      */
-    s(this, "particlesPerWave");
+    s(this, "innerRadius");
     /**
-     * Rotation of the emitter or emitter's owner in degrees. This is added to
-     * the calculated spawn angle.
-     * To change this, use rotate().
+     * If rotation should be applied to particles.
      */
     s(this, "rotation");
+    this.x = t.x || 0, this.y = t.y || 0, this.radius = t.radius, this.innerRadius = t.innerRadius || 0, this.rotation = !!t.affectRotation;
+  }
+  getRandPos(t) {
+    this.innerRadius !== this.radius ? t.x = Math.random() * (this.radius - this.innerRadius) + this.innerRadius : t.x = this.radius, t.y = 0;
+    const e = Math.random() * Math.PI * 2;
+    this.rotation && (t.rotation += e), w(e, t.position), t.position.x += this.x, t.position.y += this.y;
+  }
+}
+s(T, "type", "torus"), s(T, "editorConfig", null);
+const St = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PolygonalChain: O,
+  Rectangle: A,
+  Torus: T
+}, Symbol.toStringTag, { value: "Module" })), bt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+class I {
+  constructor(t) {
+    // doesn't _really_ need to be late, but doing so ensures that we can override any
+    // rotation behavior that is mistakenly added
+    s(this, "order", p.Late);
+    s(this, "minStart");
+    s(this, "maxStart");
+    s(this, "accel");
+    s(this, "rotate");
+    s(this, "maxSpeed");
+    this.minStart = t.minStart, this.maxStart = t.maxStart, this.accel = t.accel, this.rotate = !!t.rotate, this.maxSpeed = t.maxSpeed ?? 0;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.random() * (this.maxStart - this.minStart) + this.minStart;
+      e.config.velocity ? e.config.velocity.set(a, 0) : e.config.velocity = new C(a, 0), w(e.rotation, e.config.velocity), e = e.next;
+    }
+  }
+  updateParticle(t, e) {
+    const a = t.config.velocity, r = a.x, l = a.y;
+    if (a.x += this.accel.x * e, a.y += this.accel.y * e, this.maxSpeed) {
+      const n = at(a);
+      n > this.maxSpeed && rt(a, this.maxSpeed / n);
+    }
+    t.x += (r + a.x) / 2 * e, t.y += (l + a.y) / 2 * e, this.rotate && (t.rotation = Math.atan2(a.y, a.x));
+  }
+}
+s(I, "type", "moveAcceleration"), s(I, "editorConfig", null);
+function Lt(i) {
+  return this.ease && (i = this.ease(i)), (this.first.next.value - this.first.value) * i + this.first.value;
+}
+function Mt(i) {
+  this.ease && (i = this.ease(i));
+  const t = this.first.value, e = this.first.next.value, a = (e.r - t.r) * i + t.r, r = (e.g - t.g) * i + t.g, l = (e.b - t.b) * i + t.b;
+  return k(a, r, l);
+}
+function Et(i) {
+  this.ease && (i = this.ease(i));
+  let t = this.first, { next: e } = t;
+  for (; i > e.time; )
+    t = e, e = e.next;
+  return i = (i - t.time) / (e.time - t.time), (e.value - t.value) * i + t.value;
+}
+function Ft(i) {
+  this.ease && (i = this.ease(i));
+  let t = this.first, { next: e } = t;
+  for (; i > e.time; )
+    t = e, e = e.next;
+  i = (i - t.time) / (e.time - t.time);
+  const a = t.value, r = e.value, l = (r.r - a.r) * i + a.r, n = (r.g - a.g) * i + a.g, o = (r.b - a.b) * i + a.b;
+  return k(l, n, o);
+}
+function Tt(i) {
+  this.ease && (i = this.ease(i));
+  let t = this.first;
+  for (; t.next && i > t.next.time; )
+    t = t.next;
+  return t.value;
+}
+function Bt(i) {
+  this.ease && (i = this.ease(i));
+  let t = this.first;
+  for (; t.next && i > t.next.time; )
+    t = t.next;
+  const e = t.value;
+  return k(e.r, e.g, e.b);
+}
+class R {
+  /**
+   * @param isColor If this list handles color values
+   */
+  constructor(t = !1) {
     /**
-     * The world position of the emitter's owner, to add spawnPos to when
-     * spawning particles. To change this, use updateOwnerPos().
-     */
-    s(this, "ownerPos");
-    /**
-     * The origin + spawnPos in the previous update, so that the spawn position
-     * can be interpolated to space out particles better.
-     */
-    s(this, "_prevEmitterPos");
-    /**
-     * If _prevEmitterPos is valid, to prevent interpolation on the first update
-     */
-    s(this, "_prevPosIsValid");
-    /**
-     * If either ownerPos or spawnPos has changed since the previous update.
-     */
-    s(this, "_posChanged");
-    /**
-     * The container to add particles to.
-     */
-    s(this, "_parent");
-    /**
-     * If particles should be added at the back of the display list instead of the front.
-     */
-    s(this, "addAtBack");
-    /**
-     * The current number of active particles.
-     */
-    s(this, "particleCount");
-    /**
-     * If particles should be emitted during update() calls. Setting this to false
-     * stops new particles from being created, but allows existing ones to die out.
-     */
-    s(this, "_emit");
-    /**
-     * The timer for when to spawn particles in seconds, where numbers less
-     * than 0 mean that particles should be spawned.
-     */
-    s(this, "_spawnTimer");
-    /**
-     * The life of the emitter in seconds.
-     */
-    s(this, "_emitterLife");
-    /**
-     * The particles that are active and on the display list. This is the first particle in a
-     * linked list.
-     */
-    s(this, "_activeParticlesFirst");
-    /**
-     * The particles that are active and on the display list. This is the last particle in a
-     * linked list.
-     */
-    s(this, "_activeParticlesLast");
-    /**
-     * The particles that are not currently being used. This is the first particle in a
-     * linked list.
-     */
-    s(this, "_poolFirst");
-    /**
-     * The original config object that this emitter was initialized with.
-     */
-    s(this, "_origConfig");
-    /**
-     * If the update function is called automatically from the shared ticker.
-     * Setting this to false requires calling the update function manually.
+     * The first property node in the linked list.
      */
-    s(this, "_autoUpdate");
+    s(this, "first");
     /**
-     * Родитель является PIXI.ParticleContainer (частицы добавляются через addParticle)
+     * Calculates the correct value for the current interpolation value. This method is set in
+     * the reset() method.
+     * @param lerp The interpolation value from 0-1.
+     * @return The interpolated value. Colors are converted to the hex value.
      */
-    s(this, "_isParticleContainer");
+    s(this, "interpolate");
     /**
-     * If the emitter should destroy itself when all particles have died out. This is set by
-     * playOnceAndDestroy();
+     * A custom easing method for this list.
+     * @param lerp The interpolation value from 0-1.
+     * @return The eased value, also from 0-1.
      */
-    s(this, "_destroyWhenComplete");
+    s(this, "ease");
     /**
-     * A callback for when all particles have died out. This is set by
-     * playOnceAndDestroy() or playOnce();
+     * If this list manages colors, which requires a different method for interpolation.
      */
-    s(this, "_completeCallback");
-    this.initBehaviors = [], this.updateBehaviors = [], this.recycleBehaviors = [], this.minLifetime = 0, this.maxLifetime = 0, this.customEase = null, this._frequency = 1, this.spawnChance = 1, this.maxParticles = 1e3, this.emitterLifetime = -1, this.spawnPos = new C(), this.particlesPerWave = 1, this.rotation = 0, this.ownerPos = new C(), this._prevEmitterPos = new C(), this._prevPosIsValid = !1, this._posChanged = !1, this._parent = null, this._isParticleContainer = !1, this.addAtBack = !1, this.particleCount = 0, this._emit = !1, this._spawnTimer = 0, this._emitterLife = -1, this._activeParticlesFirst = null, this._activeParticlesLast = null, this._poolFirst = null, this._origConfig = null, this._autoUpdate = !1, this._destroyWhenComplete = !1, this._completeCallback = null, this.parent = t, e && this.init(e), this.recycle = this.recycle, this.update = this.update, this.rotate = this.rotate, this.updateSpawnPos = this.updateSpawnPos, this.updateOwnerPos = this.updateOwnerPos;
-  }
-  /**
-   * Registers a new behavior, so that it will be recognized when initializing emitters.
-   * Behaviors registered later with duplicate types will override older ones, although there is no limit on
-   * the allowed types.
-   * @param constructor The behavior class to register.
-   */
-  static registerBehavior(t) {
-    M.knownBehaviors[t.type] = t;
+    s(this, "isColor");
+    this.first = null, this.isColor = !!t, this.interpolate = null, this.ease = null;
   }
   /**
-   * Time between particle spawns in seconds. If this value is not a number greater than 0,
-   * it will be set to 1 (particle per second) to prevent infinite loops.
+   * Resets the list for use.
+   * @param first The first node in the list.
+   * @param first.isStepped If the values should be stepped instead of interpolated linearly.
    */
-  get frequency() {
-    return this._frequency;
+  reset(t) {
+    this.first = t, t.next && t.next.time >= 1 ? this.interpolate = this.isColor ? Mt : Lt : t.isStepped ? this.interpolate = this.isColor ? Bt : Tt : this.interpolate = this.isColor ? Ft : Et, this.ease = this.first.ease;
   }
-  set frequency(t) {
-    typeof t == "number" && t > 0 ? this._frequency = t : this._frequency = 1;
+}
+class V {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "list");
+    this.list = new R(!1), this.list.reset(P.createList(t.alpha));
   }
-  /**
-   * The container to add particles to. Settings this will dump any active particles.
-   */
-  get parent() {
-    return this._parent;
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.alpha = this.list.first.value, e = e.next;
   }
-  set parent(t) {
-    this.cleanup();
-    const e = t instanceof xt;
-    e !== this._isParticleContainer && (this._poolFirst = null), this._isParticleContainer = e, this._parent = t;
+  updateParticle(t) {
+    t.alpha = this.list.interpolate(t.agePercent);
   }
-  /**
-   * Создать частицу подходящего класса: лёгкую для ParticleContainer или спрайтовую для обычного контейнера
-   */
-  _createParticle() {
-    return this._isParticleContainer ? new kt(this) : new Rt(this);
+}
+s(V, "type", "alpha"), s(V, "editorConfig", null);
+class q {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "value");
+    this.value = t.alpha;
   }
-  /**
-   * Добавить частицу в контейнер (addParticle для ParticleContainer, addChild для обычного)
-   */
-  _addParticleToParent(t) {
-    this._isParticleContainer ? this._parent.addParticle(t) : this.addAtBack ? this._parent.addChildAt(t, 0) : this._parent.addChild(t);
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.alpha = this.value, e = e.next;
   }
-  /**
-   * Sets up the emitter based on the config settings.
-   * @param config A configuration object containing settings for the emitter.
-   */
-  init(t) {
-    if (!t)
-      return;
-    this.cleanup(), this._origConfig = t, this.minLifetime = t.lifetime.min, this.maxLifetime = t.lifetime.max, t.ease ? this.customEase = typeof t.ease == "function" ? t.ease : nt(t.ease) : this.customEase = null, this.particlesPerWave = 1, t.particlesPerWave && t.particlesPerWave > 1 && (this.particlesPerWave = t.particlesPerWave), this.frequency = t.frequency, this.spawnChance = typeof t.spawnChance == "number" && t.spawnChance > 0 ? t.spawnChance : 1, this.emitterLifetime = t.emitterLifetime || -1, this.maxParticles = t.maxParticles > 0 ? t.maxParticles : 1e3, this.addAtBack = !!t.addAtBack, this.rotation = 0, this.ownerPos.set(0), t.pos ? this.spawnPos.copyFrom(t.pos) : this.spawnPos.set(0), this._prevEmitterPos.copyFrom(this.spawnPos), this._prevPosIsValid = !1, this._spawnTimer = 0, this.emit = t.emit === void 0 ? !0 : !!t.emit, this.autoUpdate = !!t.autoUpdate;
-    const e = t.behaviors.map((a) => {
-      const r = M.knownBehaviors[a.type];
-      return r ? new r(a.config) : (console.error(`Unknown behavior: ${a.type}`), null);
-    }).filter((a) => !!a);
-    e.push(b), e.sort((a, r) => a === b ? r.order === p.Spawn ? 1 : -1 : r === b ? a.order === p.Spawn ? -1 : 1 : a.order - r.order), this.initBehaviors = e.slice(), this.updateBehaviors = e.filter((a) => a !== b && a.updateParticle), this.recycleBehaviors = e.filter(
-      (a) => a !== b && a.recycleParticle
-    );
+}
+s(q, "type", "alphaStatic"), s(q, "editorConfig", null);
+function ht(i) {
+  const t = [];
+  for (let e = 0; e < i.length; ++e) {
+    let a = i[e];
+    if (typeof a == "string")
+      t.push(F(a));
+    else if (a instanceof B)
+      t.push(a);
+    else {
+      let r = a.count || 1;
+      for (typeof a.texture == "string" ? a = F(a.texture) : a = a.texture; r > 0; --r)
+        t.push(a);
+    }
   }
-  /**
-   * Gets the instantiated behavior of the specified type, if it is present on this emitter.
-   * @param type The behavior type to find.
-   */
-  getBehavior(t) {
-    return M.knownBehaviors[t] && this.initBehaviors.find((e) => e instanceof M.knownBehaviors[t]) || null;
+  return t;
+}
+class N {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "anims");
+    this.anims = [];
+    for (let e = 0; e < t.anims.length; ++e) {
+      const a = t.anims[e], r = ht(a.textures), l = a.framerate < 0 ? -1 : a.framerate > 0 ? a.framerate : 60, n = {
+        textures: r,
+        duration: l > 0 ? r.length / l : 0,
+        framerate: l,
+        loop: l > 0 ? !!a.loop : !1
+      };
+      this.anims.push(n);
+    }
   }
-  /**
-   * Fills the pool with the specified number of particles, so that they don't have to be instantiated later.
-   * @param count The number of particles to create.
-   */
-  fillPool(t) {
-    for (; t > 0; --t) {
-      const e = this._createParticle();
-      e.next = this._poolFirst, this._poolFirst = e;
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.floor(Math.random() * this.anims.length), r = e.config.anim = this.anims[a];
+      e.texture = r.textures[0], e.config.animElapsed = 0, r.framerate === -1 ? (e.config.animDuration = e.maxLife, e.config.animFramerate = r.textures.length / e.maxLife) : (e.config.animDuration = r.duration, e.config.animFramerate = r.framerate), e = e.next;
     }
   }
-  /**
-   * Recycles an individual particle. For internal use only.
-   * @param particle The particle to recycle.
-   * @param fromCleanup If this is being called to manually clean up all particles.
-   * @internal
-   */
-  recycle(t, e = !1) {
-    var a;
-    for (let r = 0; r < this.recycleBehaviors.length; ++r)
-      this.recycleBehaviors[r].recycleParticle(t, !e);
-    t.next && (t.next.prev = t.prev), t.prev && (t.prev.next = t.next), t === this._activeParticlesLast && (this._activeParticlesLast = t.prev), t === this._activeParticlesFirst && (this._activeParticlesFirst = t.next), t.prev = null, t.next = this._poolFirst, this._poolFirst = t, this._isParticleContainer ? (a = this._parent) == null || a.removeParticle(t) : t.parent && t.parent.removeChild(t), --this.particleCount;
+  updateParticle(t, e) {
+    const { config: a } = t, { anim: r } = a;
+    a.animElapsed += e, a.animElapsed >= a.animDuration && (a.anim.loop ? a.animElapsed = a.animElapsed % a.animDuration : a.animElapsed = a.animDuration - 1e-6);
+    const l = a.animElapsed * a.animFramerate + 1e-7 | 0;
+    t.texture = r.textures[l] || r.textures[r.textures.length - 1] || B.EMPTY;
   }
-  /**
-   * Sets the rotation of the emitter to a new value. This rotates the spawn position in addition
-   * to particle direction.
-   * @param newRot The new rotation, in degrees.
-   */
-  rotate(t) {
-    if (this.rotation === t) return;
-    const e = t - this.rotation;
-    this.rotation = t, w(e, this.spawnPos), this._posChanged = !0;
+}
+s(N, "type", "animatedRandom"), s(N, "editorConfig", null);
+class U {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "anim");
+    const { anim: e } = t, a = ht(e.textures), r = e.framerate < 0 ? -1 : e.framerate > 0 ? e.framerate : 60;
+    this.anim = {
+      textures: a,
+      duration: r > 0 ? a.length / r : 0,
+      framerate: r,
+      loop: r > 0 ? !!e.loop : !1
+    };
   }
-  /**
-   * Changes the spawn position of the emitter.
-   * @param x The new x value of the spawn position for the emitter.
-   * @param y The new y value of the spawn position for the emitter.
-   */
-  updateSpawnPos(t, e) {
-    this._posChanged = !0, this.spawnPos.x = t, this.spawnPos.y = e;
+  initParticles(t) {
+    let e = t;
+    const { anim: a } = this;
+    for (; e; )
+      e.texture = a.textures[0], e.config.animElapsed = 0, a.framerate === -1 ? (e.config.animDuration = e.maxLife, e.config.animFramerate = a.textures.length / e.maxLife) : (e.config.animDuration = a.duration, e.config.animFramerate = a.framerate), e = e.next;
   }
-  /**
-   * Changes the position of the emitter's owner. You should call this if you are adding
-   * particles to the world container that your emitter's owner is moving around in.
-   * @param x The new x value of the emitter's owner.
-   * @param y The new y value of the emitter's owner.
-   */
-  updateOwnerPos(t, e) {
-    this._posChanged = !0, this.ownerPos.x = t, this.ownerPos.y = e;
+  updateParticle(t, e) {
+    const { anim: a } = this, { config: r } = t;
+    r.animElapsed += e, r.animElapsed >= r.animDuration && (a.loop ? r.animElapsed = r.animElapsed % r.animDuration : r.animElapsed = r.animDuration - 1e-6);
+    const l = r.animElapsed * r.animFramerate + 1e-7 | 0;
+    t.texture = a.textures[l] || a.textures[a.textures.length - 1] || B.EMPTY;
+  }
+}
+s(U, "type", "animatedSingle"), s(U, "editorConfig", null);
+class W {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "value");
+    this.value = t.blendMode;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.blendMode = ot(this.value), e = e.next;
+  }
+}
+s(W, "type", "blendMode"), s(W, "editorConfig", null);
+class Y {
+  constructor(t) {
+    s(this, "order", p.Spawn);
+    s(this, "spacing");
+    s(this, "start");
+    s(this, "distance");
+    this.spacing = t.spacing * _, this.start = t.start * _, this.distance = t.distance;
   }
-  /**
-   * Prevents emitter position interpolation in the next update.
-   * This should be used if you made a major position change of your emitter's owner
-   * that was not normal movement.
-   */
-  resetPositionTracking() {
-    this._prevPosIsValid = !1;
+  initParticles(t) {
+    let e = 0, a = t;
+    for (; a; ) {
+      let r;
+      this.spacing ? r = this.start + this.spacing * e : r = Math.random() * Math.PI * 2, a.rotation = r, this.distance && (a.position.x = this.distance, w(r, a.position)), a = a.next, ++e;
+    }
   }
-  /**
-   * If particles should be emitted during update() calls. Setting this to false
-   * stops new particles from being created, but allows existing ones to die out.
-   */
-  get emit() {
-    return this._emit;
+}
+s(Y, "type", "spawnBurst"), s(Y, "editorConfig", null);
+class D {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "list");
+    this.list = new R(!0), this.list.reset(P.createList(t.color));
   }
-  set emit(t) {
-    this._emit = !!t, this._emitterLife = this.emitterLifetime;
+  initParticles(t) {
+    let e = t;
+    const a = this.list.first.value, r = k(a.r, a.g, a.b);
+    for (; e; )
+      e.tint = r, e = e.next;
   }
-  /**
-   * If the update function is called automatically from the shared ticker.
-   * Setting this to false requires calling the update function manually.
-   */
-  get autoUpdate() {
-    return this._autoUpdate;
+  updateParticle(t) {
+    t.tint = this.list.interpolate(t.agePercent);
   }
-  set autoUpdate(t) {
-    this._autoUpdate && !t ? st.remove(this.update, this) : !this._autoUpdate && t && st.add(this.update, this), this._autoUpdate = !!t;
+}
+s(D, "type", "color"), s(D, "editorConfig", null);
+class X {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "value");
+    let { color: e } = t;
+    e.charAt(0) === "#" ? e = e.substr(1) : e.indexOf("0x") === 0 && (e = e.substr(2)), this.value = parseInt(e, 16);
   }
-  /**
-   * Starts emitting particles, sets autoUpdate to true, and sets up the Emitter to destroy itself
-   * when particle emission is complete.
-   * @param callback Callback for when emission is complete (all particles have died off)
-   */
-  playOnceAndDestroy(t) {
-    this.autoUpdate = !0, this.emit = !0, this._destroyWhenComplete = !0, this._completeCallback = t;
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.tint = this.value, e = e.next;
   }
-  /**
-   * Starts emitting particles and optionally calls a callback when particle emission is complete.
-   * @param callback Callback for when emission is complete (all particles have died off)
-   */
-  playOnce(t) {
-    this.emit = !0, this._completeCallback = t;
+}
+s(X, "type", "colorStatic"), s(X, "editorConfig", null);
+class j {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "textures");
+    s(this, "index");
+    this.index = 0, this.textures = t.textures.map((e) => typeof e == "string" ? F(e) : e);
   }
-  /**
-   * Updates all particles spawned by this emitter and emits new ones.
-   * @param delta Time elapsed since the previous frame, in __seconds__.
-   */
-  update(t) {
-    if (typeof t != "number" && (t = t.deltaMS * 1e-3), this._autoUpdate && (t = st.elapsedMS * 1e-3), !this._parent) return;
-    for (let n = this._activeParticlesFirst, o; n; n = o)
-      if (o = n.next, n.age += t, n.age > n.maxLife || n.age < 0)
-        this.recycle(n);
-      else {
-        let c = n.age * n.oneOverLife;
-        this.customEase && (this.customEase.length === 4 ? c = this.customEase(c, 0, 1, 1) : c = this.customEase(c)), n.agePercent = c;
-        for (let u = 0; u < this.updateBehaviors.length; ++u)
-          if (this.updateBehaviors[u].updateParticle(n, t)) {
-            this.recycle(n);
-            break;
-          }
-      }
-    let e, a;
-    this._prevPosIsValid && (e = this._prevEmitterPos.x, a = this._prevEmitterPos.y);
-    const r = this.ownerPos.x + this.spawnPos.x, l = this.ownerPos.y + this.spawnPos.y;
-    if (this._emit)
-      for (this._spawnTimer -= t < 0 ? 0 : t; this._spawnTimer <= 0; ) {
-        if (this._emitterLife >= 0 && (this._emitterLife -= this._frequency, this._emitterLife <= 0)) {
-          this._spawnTimer = 0, this._emitterLife = 0, this.emit = !1;
-          break;
-        }
-        if (this.particleCount >= this.maxParticles) {
-          this._spawnTimer += this._frequency;
-          continue;
-        }
-        let n, o;
-        if (this._prevPosIsValid && this._posChanged) {
-          const d = 1 + this._spawnTimer / t;
-          n = (r - e) * d + e, o = (l - a) * d + a;
-        } else
-          n = r, o = l;
-        let c = null, u = null;
-        for (let d = Math.min(this.particlesPerWave, this.maxParticles - this.particleCount), y = 0; y < d; ++y) {
-          if (this.spawnChance < 1 && Math.random() >= this.spawnChance)
-            continue;
-          let f;
-          if (this.minLifetime === this.maxLifetime ? f = this.minLifetime : f = Math.random() * (this.maxLifetime - this.minLifetime) + this.minLifetime, -this._spawnTimer >= f)
-            continue;
-          let x;
-          this._poolFirst ? (x = this._poolFirst, this._poolFirst = this._poolFirst.next, x.next = null) : x = this._createParticle(), x.init(f), this._addParticleToParent(x), c ? (u.next = x, x.prev = u, u = x) : u = c = x, ++this.particleCount;
-        }
-        if (c) {
-          this._activeParticlesLast ? (this._activeParticlesLast.next = c, c.prev = this._activeParticlesLast, this._activeParticlesLast = u) : (this._activeParticlesFirst = c, this._activeParticlesLast = u);
-          for (let d = 0; d < this.initBehaviors.length; ++d) {
-            const y = this.initBehaviors[d];
-            if (y === b)
-              for (let f = c, x; f; f = x) {
-                x = f.next, this.rotation !== 0 && (w(this.rotation, f.position), f.rotation += this.rotation), f.position.x += n, f.position.y += o, f.age += -this._spawnTimer;
-                let h = f.age * f.oneOverLife;
-                this.customEase && (this.customEase.length === 4 ? h = this.customEase(h, 0, 1, 1) : h = this.customEase(h)), f.agePercent = h;
-              }
-            else
-              y.initParticles(c);
-          }
-          for (let d = c, y; d; d = y) {
-            y = d.next;
-            for (let f = 0; f < this.updateBehaviors.length; ++f)
-              if (this.updateBehaviors[f].updateParticle(d, -this._spawnTimer)) {
-                this.recycle(d);
-                break;
-              }
-          }
-        }
-        this._spawnTimer += this._frequency;
-      }
-    if (this._posChanged && (this._prevEmitterPos.x = r, this._prevEmitterPos.y = l, this._prevPosIsValid = !0, this._posChanged = !1), !this._emit && !this._activeParticlesFirst) {
-      if (this._completeCallback) {
-        const n = this._completeCallback;
-        this._completeCallback = null, n();
-      }
-      this._destroyWhenComplete && this.destroy();
-    }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.texture = this.textures[this.index], ++this.index >= this.textures.length && (this.index = 0), e = e.next;
   }
-  /**
-   * Emits a single wave of particles, using standard spawnChance & particlesPerWave settings. Does not affect
-   * regular spawning through the frequency, and ignores the emit property. The max particle count is respected, however,
-   * so if there are already too many particles then nothing will happen.
-   */
-  emitNow() {
-    const t = this.ownerPos.x + this.spawnPos.x, e = this.ownerPos.y + this.spawnPos.y;
-    let a = null, r = null;
-    for (let l = Math.min(this.particlesPerWave, this.maxParticles - this.particleCount), n = 0; n < l; ++n) {
-      if (this.spawnChance < 1 && Math.random() >= this.spawnChance)
-        continue;
-      let o;
-      this._poolFirst ? (o = this._poolFirst, this._poolFirst = this._poolFirst.next, o.next = null) : o = this._createParticle();
-      let c;
-      this.minLifetime === this.maxLifetime ? c = this.minLifetime : c = Math.random() * (this.maxLifetime - this.minLifetime) + this.minLifetime, o.init(c), this._addParticleToParent(o), a ? (r.next = o, o.prev = r, r = o) : r = a = o, ++this.particleCount;
-    }
-    if (a) {
-      this._activeParticlesLast ? (this._activeParticlesLast.next = a, a.prev = this._activeParticlesLast, this._activeParticlesLast = r) : (this._activeParticlesFirst = a, this._activeParticlesLast = r);
-      for (let l = 0; l < this.initBehaviors.length; ++l) {
-        const n = this.initBehaviors[l];
-        if (n === b)
-          for (let o = a, c; o; o = c)
-            c = o.next, this.rotation !== 0 && (w(this.rotation, o.position), o.rotation += this.rotation), o.position.x += t, o.position.y += e;
-        else
-          n.initParticles(a);
-      }
+}
+s(j, "type", "textureOrdered"), s(j, "editorConfig", null);
+const E = new C(), ct = [
+  "E",
+  "LN2",
+  "LN10",
+  "LOG2E",
+  "LOG10E",
+  "PI",
+  "SQRT1_2",
+  "SQRT2",
+  "abs",
+  "acos",
+  "acosh",
+  "asin",
+  "asinh",
+  "atan",
+  "atanh",
+  "atan2",
+  "cbrt",
+  "ceil",
+  "cos",
+  "cosh",
+  "exp",
+  "expm1",
+  "floor",
+  "fround",
+  "hypot",
+  "log",
+  "log1p",
+  "log10",
+  "log2",
+  "max",
+  "min",
+  "pow",
+  "random",
+  "round",
+  "sign",
+  "sin",
+  "sinh",
+  "sqrt",
+  "tan",
+  "tanh"
+], kt = new RegExp(
+  [
+    // Allow the 4 basic operations, parentheses and all numbers/decimals, as well
+    // as 'x', for the variable usage.
+    "[01234567890\\.\\*\\-\\+\\/\\(\\)x ,]"
+  ].concat(ct).join("|"),
+  "g"
+);
+function Rt(i) {
+  const t = i.match(kt);
+  for (let e = t.length - 1; e >= 0; --e)
+    ct.indexOf(t[e]) >= 0 && (t[e] = `Math.${t[e]}`);
+  return i = t.join(""), new Function("x", `return ${i};`);
+}
+class G {
+  constructor(t) {
+    // *MUST* happen after other behaviors do initialization so that we can read initial transformations
+    s(this, "order", p.Late);
+    /**
+     * The function representing the path the particle should take.
+     */
+    s(this, "path");
+    s(this, "list");
+    s(this, "minMult");
+    if (t.path)
+      if (typeof t.path == "function")
+        this.path = t.path;
+      else
+        try {
+          this.path = Rt(t.path);
+        } catch {
+          this.path = null;
+        }
+    else
+      this.path = (e) => e;
+    this.list = new R(!1), this.list.reset(P.createList(t.speed)), this.minMult = t.minMult ?? 1;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      e.config.initRotation = e.rotation, e.config.initPosition ? e.config.initPosition.copyFrom(e.position) : e.config.initPosition = new C(e.x, e.y), e.config.movement = 0;
+      const a = Math.random() * (1 - this.minMult) + this.minMult;
+      e.config.speedMult = a, e = e.next;
     }
   }
-  /**
-   * Kills all active particles immediately.
-   */
-  cleanup() {
-    let t, e;
-    for (t = this._activeParticlesFirst; t; t = e)
-      e = t.next, this.recycle(t, !0);
-    this._activeParticlesFirst = this._activeParticlesLast = null, this.particleCount = 0;
+  updateParticle(t, e) {
+    const a = this.list.interpolate(t.agePercent) * t.config.speedMult;
+    t.config.movement += a * e, E.x = t.config.movement, E.y = this.path(E.x), w(t.config.initRotation, E), t.position.x = t.config.initPosition.x + E.x, t.position.y = t.config.initPosition.y + E.y;
   }
-  /**
-   * If this emitter has been destroyed. Note that a destroyed emitter can still be reused, after
-   * having a new parent set and being reinitialized.
-   */
-  get destroyed() {
-    return !(this._parent && this.initBehaviors.length);
+}
+s(G, "type", "movePath"), s(G, "editorConfig", null);
+class z {
+  constructor() {
+    s(this, "order", p.Spawn);
   }
-  /**
-   * Destroys the emitter and all of its particles.
-   */
-  destroy() {
-    this.autoUpdate = !1, this.cleanup();
-    let t;
-    for (let e = this._poolFirst; e; e = t)
-      t = e.next, e.destroy();
-    this._poolFirst = this._parent = this.spawnPos = this.ownerPos = this.customEase = this._completeCallback = null, this.initBehaviors.length = this.updateBehaviors.length = this.recycleBehaviors.length = 0;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  initParticles(t) {
   }
-};
-s(M, "knownBehaviors", {});
-let m = M;
-function qt(i, t) {
-  var a, r, l, n, o, c, u, d, y, f, x;
-  if ("behaviors" in i)
-    return i;
-  const e = {
-    lifetime: i.lifetime,
-    ease: i.ease,
-    particlesPerWave: i.particlesPerWave,
-    frequency: i.frequency,
-    spawnChance: i.spawnChance,
-    emitterLifetime: i.emitterLifetime,
-    maxParticles: i.maxParticles,
-    addAtBack: i.addAtBack,
-    pos: i.pos,
-    emit: i.emit,
-    autoUpdate: i.autoUpdate,
-    behaviors: []
-  };
-  if (i.alpha)
-    if ("start" in i.alpha)
-      if (i.alpha.start === i.alpha.end)
-        i.alpha.start !== 1 && e.behaviors.push({
-          type: "alphaStatic",
-          config: { alpha: i.alpha.start }
-        });
-      else {
-        const h = {
-          list: [
-            { time: 0, value: i.alpha.start },
-            { time: 1, value: i.alpha.end }
-          ]
-        };
-        e.behaviors.push({
-          type: "alpha",
-          config: { alpha: h }
-        });
-      }
-    else i.alpha.list.length === 1 ? i.alpha.list[0].value !== 1 && e.behaviors.push({
-      type: "alphaStatic",
-      config: { alpha: i.alpha.list[0].value }
-    }) : e.behaviors.push({
-      type: "alpha",
-      config: { alpha: i.alpha }
-    });
-  if (i.acceleration && (i.acceleration.x || i.acceleration.y)) {
-    let h, v;
-    "start" in i.speed ? (h = i.speed.start * (i.speed.minimumSpeedMultiplier ?? 1), v = i.speed.start) : (h = i.speed.list[0].value * (i.minimumSpeedMultiplier ?? 1), v = i.speed.list[0].value), e.behaviors.push({
-      type: "moveAcceleration",
-      config: {
-        accel: i.acceleration,
-        minStart: h,
-        maxStart: v,
-        rotate: !i.noRotation,
-        maxSpeed: i.maxSpeed
-      }
-    });
-  } else if ((a = i.extraData) != null && a.path) {
-    let h, v;
-    "start" in i.speed ? (v = i.speed.minimumSpeedMultiplier ?? 1, i.speed.start === i.speed.end ? h = {
-      list: [{ time: 0, value: i.speed.start }]
-    } : h = {
-      list: [
-        { time: 0, value: i.speed.start },
-        { time: 1, value: i.speed.end }
-      ]
-    }) : (h = i.speed, v = i.minimumSpeedMultiplier ?? 1), e.behaviors.push({
-      type: "movePath",
-      config: {
-        path: i.extraData.path,
-        speed: h,
-        minMult: v
-      }
-    });
-  } else if (i.speed)
-    if ("start" in i.speed)
-      if (i.speed.start === i.speed.end)
-        e.behaviors.push({
-          type: "moveSpeedStatic",
-          config: {
-            min: i.speed.start * (i.speed.minimumSpeedMultiplier ?? 1),
-            max: i.speed.start
-          }
-        });
-      else {
-        const h = {
-          list: [
-            { time: 0, value: i.speed.start },
-            { time: 1, value: i.speed.end }
-          ]
-        };
-        e.behaviors.push({
-          type: "moveSpeed",
-          config: { speed: h, minMult: i.speed.minimumSpeedMultiplier }
-        });
-      }
-    else i.speed.list.length === 1 ? e.behaviors.push({
-      type: "moveSpeedStatic",
-      config: {
-        min: i.speed.list[0].value * (i.minimumSpeedMultiplier ?? 1),
-        max: i.speed.list[0].value
-      }
-    }) : e.behaviors.push({
-      type: "moveSpeed",
-      config: { speed: i.speed, minMult: i.minimumSpeedMultiplier ?? 1 }
-    });
-  if (i.scale)
-    if ("start" in i.scale) {
-      const h = i.scale.minimumScaleMultiplier ?? 1;
-      if (i.scale.start === i.scale.end)
-        e.behaviors.push({
-          type: "scaleStatic",
-          config: {
-            min: i.scale.start * h,
-            max: i.scale.start
-          }
-        });
-      else {
-        const v = {
-          list: [
-            { time: 0, value: i.scale.start },
-            { time: 1, value: i.scale.end }
-          ]
-        };
-        e.behaviors.push({
-          type: "scale",
-          config: { scale: v, minMult: h }
-        });
-      }
-    } else if (i.scale.list.length === 1) {
-      const h = i.minimumScaleMultiplier ?? 1, v = i.scale.list[0].value;
-      e.behaviors.push({
-        type: "scaleStatic",
-        config: { min: v * h, max: v }
-      });
-    } else
-      e.behaviors.push({
-        type: "scale",
-        config: { scale: i.scale, minMult: i.minimumScaleMultiplier ?? 1 }
-      });
-  if (i.color)
-    if ("start" in i.color)
-      if (i.color.start === i.color.end)
-        i.color.start !== "ffffff" && e.behaviors.push({
-          type: "colorStatic",
-          config: { color: i.color.start }
-        });
-      else {
-        const h = {
-          list: [
-            { time: 0, value: i.color.start },
-            { time: 1, value: i.color.end }
-          ]
-        };
-        e.behaviors.push({
-          type: "color",
-          config: { color: h }
-        });
-      }
-    else i.color.list.length === 1 ? i.color.list[0].value !== "ffffff" && e.behaviors.push({
-      type: "colorStatic",
-      config: { color: i.color.list[0].value }
-    }) : e.behaviors.push({
-      type: "color",
-      config: { color: i.color }
-    });
-  if (i.rotationAcceleration || (r = i.rotationSpeed) != null && r.min || (l = i.rotationSpeed) != null && l.max ? e.behaviors.push({
-    type: "rotation",
-    config: {
-      accel: i.rotationAcceleration || 0,
-      minSpeed: ((n = i.rotationSpeed) == null ? void 0 : n.min) || 0,
-      maxSpeed: ((o = i.rotationSpeed) == null ? void 0 : o.max) || 0,
-      minStart: ((c = i.startRotation) == null ? void 0 : c.min) || 0,
-      maxStart: ((u = i.startRotation) == null ? void 0 : u.max) || 0
-    }
-  }) : ((d = i.startRotation) != null && d.min || (y = i.startRotation) != null && y.max) && e.behaviors.push({
-    type: "rotationStatic",
-    config: {
-      min: ((f = i.startRotation) == null ? void 0 : f.min) || 0,
-      max: ((x = i.startRotation) == null ? void 0 : x.max) || 0
-    }
-  }), i.noRotation && e.behaviors.push({
-    type: "noRotation",
-    config: {}
-  }), i.blendMode && i.blendMode !== "normal" && e.behaviors.push({
-    type: "blendMode",
-    config: {
-      blendMode: i.blendMode
-    }
-  }), Array.isArray(t) && typeof t[0] != "string" && "framerate" in t[0]) {
-    for (let h = 0; h < t.length; ++h)
-      t[h].framerate === "matchLife" && (t[h].framerate = -1);
-    e.behaviors.push({
-      type: "animatedRandom",
-      config: {
-        anims: t
-      }
-    });
-  } else typeof t != "string" && "framerate" in t ? (t.framerate === "matchLife" && (t.framerate = -1), e.behaviors.push({
-    type: "animatedSingle",
-    config: {
-      anim: t
+}
+s(z, "type", "spawnPoint"), s(z, "editorConfig", null);
+class $ {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "textures");
+    this.textures = t.textures.map((e) => typeof e == "string" ? F(e) : e);
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.floor(Math.random() * this.textures.length);
+      e.texture = this.textures[a], e = e.next;
     }
-  })) : i.orderedArt && Array.isArray(t) ? e.behaviors.push({
-    type: "textureOrdered",
-    config: {
-      textures: t
+  }
+}
+s($, "type", "textureRandom"), s($, "editorConfig", null);
+class Q {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "minStart");
+    s(this, "maxStart");
+    s(this, "minSpeed");
+    s(this, "maxSpeed");
+    s(this, "accel");
+    this.minStart = t.minStart * _, this.maxStart = t.maxStart * _, this.minSpeed = t.minSpeed * _, this.maxSpeed = t.maxSpeed * _, this.accel = t.accel * _;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      this.minStart === this.maxStart ? e.rotation += this.maxStart : e.rotation += Math.random() * (this.maxStart - this.minStart) + this.minStart, e.config.rotSpeed = Math.random() * (this.maxSpeed - this.minSpeed) + this.minSpeed, e = e.next;
+  }
+  updateParticle(t, e) {
+    if (this.accel) {
+      const a = t.config.rotSpeed;
+      t.config.rotSpeed += this.accel * e, t.rotation += (t.config.rotSpeed + a) / 2 * e;
+    } else
+      t.rotation += t.config.rotSpeed * e;
+  }
+}
+s(Q, "type", "rotation"), s(Q, "editorConfig", null);
+class H {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "min");
+    s(this, "max");
+    this.min = t.min * _, this.max = t.max * _;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      this.min === this.max ? e.rotation += this.max : e.rotation += Math.random() * (this.max - this.min) + this.min, e = e.next;
+  }
+}
+s(H, "type", "rotationStatic"), s(H, "editorConfig", null);
+class J {
+  constructor(t) {
+    s(this, "order", p.Late + 1);
+    s(this, "rotation");
+    this.rotation = (t.rotation || 0) * _;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.rotation = this.rotation, e = e.next;
+  }
+}
+s(J, "type", "noRotation"), s(J, "editorConfig", null);
+class K {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "list");
+    s(this, "minMult");
+    this.list = new R(!1), this.list.reset(P.createList(t.scale)), this.minMult = t.minMult ?? 1;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.random() * (1 - this.minMult) + this.minMult;
+      e.config.scaleMult = a, e.scale.x = e.scale.y = this.list.first.value * a, e = e.next;
     }
-  }) : Array.isArray(t) ? e.behaviors.push({
-    type: "textureRandom",
-    config: {
-      textures: t
+  }
+  updateParticle(t) {
+    t.scale.x = t.scale.y = this.list.interpolate(t.agePercent) * t.config.scaleMult;
+  }
+}
+s(K, "type", "scale"), s(K, "editorConfig", null);
+class Z {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "min");
+    s(this, "max");
+    this.min = t.min, this.max = t.max;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.random() * (this.max - this.min) + this.min;
+      e.scale.x = e.scale.y = a, e = e.next;
     }
-  }) : e.behaviors.push({
-    type: "textureSingle",
-    config: {
-      texture: t
+  }
+}
+s(Z, "type", "scaleStatic"), s(Z, "editorConfig", null);
+const M = class M {
+  constructor(t) {
+    s(this, "order", p.Spawn);
+    s(this, "shape");
+    const e = M.shapes[t.type];
+    if (!e)
+      throw new Error(`No shape found with type '${t.type}'`);
+    this.shape = new e(t.data);
+  }
+  /**
+   * Registers a shape to be used by the ShapeSpawn behavior.
+   * @param constructor The shape class constructor to use, with a static `type` property to reference it by.
+   * @param typeOverride An optional type override, primarily for registering a shape under multiple names.
+   */
+  static registerShape(t, e) {
+    M.shapes[e || t.type] = t;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      this.shape.getRandPos(e), e = e.next;
+  }
+};
+s(M, "type", "spawnShape"), s(M, "editorConfig", null), /**
+ * Dictionary of all registered shape classes.
+ */
+s(M, "shapes", {});
+let S = M;
+S.registerShape(O);
+S.registerShape(A);
+S.registerShape(T);
+S.registerShape(T, "circle");
+class tt {
+  constructor(t) {
+    s(this, "order", p.Normal);
+    s(this, "texture");
+    this.texture = typeof t.texture == "string" ? F(t.texture) : t.texture;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.texture = this.texture, e = e.next;
+  }
+}
+s(tt, "type", "textureSingle"), s(tt, "editorConfig", null);
+class et {
+  constructor(t) {
+    s(this, "order", p.Late);
+    s(this, "list");
+    s(this, "minMult");
+    this.list = new R(!1), this.list.reset(P.createList(t.speed)), this.minMult = t.minMult ?? 1;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.random() * (1 - this.minMult) + this.minMult;
+      e.config.speedMult = a, e.config.velocity ? e.config.velocity.set(this.list.first.value * a, 0) : e.config.velocity = new C(this.list.first.value * a, 0), w(e.rotation, e.config.velocity), e = e.next;
     }
-  });
-  if (i.spawnType === "burst")
-    e.behaviors.push({
-      type: "spawnBurst",
-      config: {
-        start: i.angleStart || 0,
-        spacing: i.particleSpacing,
-        // older formats bursted from a single point
-        distance: 0
-      }
-    });
-  else if (i.spawnType === "point")
-    e.behaviors.push({
-      type: "spawnPoint",
-      config: {}
-    });
-  else {
-    let h;
-    i.spawnType === "ring" ? h = {
-      type: "torus",
-      data: {
-        x: i.spawnCircle.x,
-        y: i.spawnCircle.y,
-        radius: i.spawnCircle.r,
-        innerRadius: i.spawnCircle.minR,
-        affectRotation: !0
-      }
-    } : i.spawnType === "circle" ? h = {
-      type: "torus",
-      data: {
-        x: i.spawnCircle.x,
-        y: i.spawnCircle.y,
-        radius: i.spawnCircle.r,
-        innerRadius: 0,
-        affectRotation: !1
-      }
-    } : i.spawnType === "rect" ? h = {
-      type: "rect",
-      data: i.spawnRect
-    } : i.spawnType === "polygonalChain" && (h = {
-      type: "polygonalChain",
-      data: i.spawnPolygon
-    }), h && e.behaviors.push({
-      type: "spawnShape",
-      config: h
-    });
   }
-  return e;
+  updateParticle(t, e) {
+    const a = this.list.interpolate(t.agePercent) * t.config.speedMult, r = t.config.velocity;
+    lt(r), rt(r, a), t.x += r.x * e, t.y += r.y * e;
+  }
+}
+s(et, "type", "moveSpeed"), s(et, "editorConfig", null);
+class it {
+  constructor(t) {
+    s(this, "order", p.Late);
+    s(this, "min");
+    s(this, "max");
+    this.min = t.min, this.max = t.max;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; ) {
+      const a = Math.random() * (this.max - this.min) + this.min;
+      e.config.velocity ? e.config.velocity.set(a, 0) : e.config.velocity = new C(a, 0), w(e.rotation, e.config.velocity), e = e.next;
+    }
+  }
+  updateParticle(t, e) {
+    const { velocity: a } = t.config;
+    t.x += a.x * e, t.y += a.y * e;
+  }
 }
+s(it, "type", "moveSpeedStatic"), s(it, "editorConfig", null);
+const qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AccelerationBehavior: I,
+  AlphaBehavior: V,
+  BehaviorOrder: p,
+  BlendModeBehavior: W,
+  BurstSpawnBehavior: Y,
+  ColorBehavior: D,
+  NoRotationBehavior: J,
+  OrderedTextureBehavior: j,
+  PathBehavior: G,
+  PointSpawnBehavior: z,
+  RandomAnimatedTextureBehavior: N,
+  RandomTextureBehavior: $,
+  RotationBehavior: Q,
+  ScaleBehavior: K,
+  ShapeSpawnBehavior: S,
+  SingleAnimatedTextureBehavior: U,
+  SingleTextureBehavior: tt,
+  SpeedBehavior: et,
+  StaticAlphaBehavior: q,
+  StaticColorBehavior: X,
+  StaticRotationBehavior: H,
+  StaticScaleBehavior: Z,
+  StaticSpeedBehavior: it,
+  editor: bt,
+  spawnShapes: St
+}, Symbol.toStringTag, { value: "Module" }));
 m.registerBehavior(I);
 m.registerBehavior(V);
 m.registerBehavior(q);
@@ -1801,12 +1799,12 @@ m.registerBehavior(tt);
 m.registerBehavior(et);
 m.registerBehavior(it);
 export {
-  kt as ContainerParticle,
+  _t as ContainerParticle,
   m as Emitter,
-  Rt as Particle,
+  wt as Particle,
   It as ParticleUtils,
   R as PropertyList,
   P as PropertyNode,
-  Vt as behaviors,
-  qt as upgradeConfig
+  qt as behaviors,
+  Vt as upgradeConfig
 };