@truelab/truengine 3.0.0 → 4.0.0-rc.1

package/dist/libs/particles.js

@@ -0,0 +1,1812 @@
+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 {
+  /**
+   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
+   */
+  constructor(t) {
+    /**
+     * List of segment objects in the chain.
+     */
+    s(this, "segments");
+    /**
+     * Total length of all segments of the chain.
+     */
+    s(this, "totalLength");
+    /**
+     * Total length of segments up to and including the segment of the same index.
+     * Used for weighted random selection of segment.
+     */
+    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) {
+    /**
+     * X (left) position of the rectangle.
+     */
+    s(this, "x");
+    /**
+     * Y (top) position of the rectangle.
+     */
+    s(this, "y");
+    /**
+     * Width of the rectangle.
+     */
+    s(this, "w");
+    /**
+     * Height of the rectangle.
+     */
+    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 P {
+  /**
+   * @param value The value for this node
+   * @param time The time for this node, between 0-1
+   * @param [ease] Custom ease for this list. Only relevant for the first node.
+   */
+  constructor(t, e, a) {
+    /**
+     * Value for the node.
+     */
+    s(this, "value");
+    /**
+     * Time value for the node. Between 0-1.
+     */
+    s(this, "time");
+    /**
+     * The next node in line.
+     */
+    s(this, "next");
+    /**
+     * If this is the first node in the list, controls if the entire list is stepped or not.
+     */
+    s(this, "isStepped");
+    s(this, "ease");
+    this.value = t, this.time = e, this.next = null, this.isStepped = !1, a ? this.ease = typeof a == "function" ? a : nt(a) : this.ease = null;
+  }
+  /**
+   * Creates a list of property values from a data object {list, isStepped} with a list of objects in
+   * the form {value, time}. Alternatively, the data object can be in the deprecated form of
+   * {start, end}.
+   * @param data The data for the list.
+   * @param data.list The array of value and time objects.
+   * @param data.isStepped If the list is stepped rather than interpolated.
+   * @param data.ease Custom ease for this list.
+   * @return The first node in the list
+   */
+  // eslint-disable-next-line max-len
+  static createList(t) {
+    if ("list" in t) {
+      const a = t.list;
+      let r;
+      const { value: l, time: n } = a[0], o = r = new P(
+        typeof l == "string" ? g(l) : l,
+        n,
+        t.ease
+      );
+      if (a.length > 2 || a.length === 2 && a[1].value !== l)
+        for (let c = 1; c < a.length; ++c) {
+          const { value: u, time: d } = a[c];
+          r.next = new P(typeof u == "string" ? g(u) : u, d), r = r.next;
+        }
+      return o.isStepped = !!t.isStepped, o;
+    }
+    const e = new P(typeof t.start == "string" ? g(t.start) : t.start, 0);
+    return t.end !== t.start && (e.next = new P(typeof t.end == "string" ? g(t.end) : t.end, 1)), e;
+  }
+}
+let F = B.from;
+const yt = !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;
+  t.x = r, t.y = l;
+}
+function k(i, t, e) {
+  return (
+    /* a << 24 |*/
+    i << 16 | t << 8 | e
+  );
+}
+function at(i) {
+  return Math.sqrt(i.x * i.x + i.y * i.y);
+}
+function lt(i) {
+  let t = 1 / at(i);
+  (t !== t || t === 1 / 0) && (t = 0), i.x *= t, i.y *= t;
+}
+function rt(i, t) {
+  i.x *= t, i.y *= t;
+}
+function g(i, t) {
+  t || (t = {}), i.charAt(0) === "#" ? i = i.substr(1) : i.indexOf("0x") === 0 && (i = i.substr(2));
+  let e;
+  return i.length === 8 && (e = i.substr(0, 2), i = i.substr(2)), t.r = parseInt(i.substr(0, 2), 16), t.g = parseInt(i.substr(2, 2), 16), t.b = parseInt(i.substr(4, 2), 16), e && (t.a = parseInt(e, 16)), t;
+}
+function nt(i) {
+  const t = i.length, e = 1 / t;
+  return function(a) {
+    const r = t * a | 0, l = (a - r * e) * t, n = i[r] || i[t - 1];
+    return n.s + l * (2 * (1 - l) * (n.cp - n.s) + l * (n.e - n.s));
+  };
+}
+function ot(i) {
+  return i ? i.toLowerCase().replace(/_/g, "-").replace(/ /g, "-") : "normal";
+}
+function vt(i, t = 10) {
+  (typeof t != "number" || t <= 0) && (t = 10);
+  const e = new P(g(i[0].value), i[0].time);
+  e.isStepped = !0;
+  let a = e, r = i[0], l = 1, n = i[l];
+  for (let o = 1; o < t; ++o) {
+    let c = o / t;
+    for (; c > n.time; )
+      r = n, n = i[++l];
+    c = (c - r.time) / (n.time - r.time);
+    const u = g(r.value), d = g(n.value), y = {
+      r: (d.r - u.r) * c + u.r,
+      g: (d.g - u.g) * c + u.g,
+      b: (d.b - u.b) * c + u.b
+    };
+    a.next = new P(y, o / t), a = a.next;
+  }
+  return e;
+}
+const It = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DEG_TO_RADS: _,
+  GetTextureFromString: F,
+  combineRGBComponents: k,
+  createSteppedGradient: vt,
+  generateEase: nt,
+  getBlendMode: ot,
+  hexToRGB: g,
+  length: at,
+  normalize: lt,
+  rotatePoint: w,
+  scaleBy: rt,
+  verbose: yt
+}, Symbol.toStringTag, { value: "Module" }));
+class T {
+  constructor(t) {
+    /**
+     * X position of the center of the shape.
+     */
+    s(this, "x");
+    /**
+     * Y position of the center of the shape.
+     */
+    s(this, "y");
+    /**
+     * Radius of circle, or outer radius of a ring.
+     */
+    s(this, "radius");
+    /**
+     * Inner radius of a ring. Use 0 to have a circle.
+     */
+    s(this, "innerRadius");
+    /**
+     * 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 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.
+     */
+    s(this, "first");
+    /**
+     * 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, "interpolate");
+    /**
+     * 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, "ease");
+    /**
+     * If this list manages colors, which requires a different method for interpolation.
+     */
+    s(this, "isColor");
+    this.first = null, this.isColor = !!t, this.interpolate = null, this.ease = null;
+  }
+  /**
+   * 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.
+   */
+  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));
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.alpha = this.list.first.value, e = e.next;
+  }
+  updateParticle(t) {
+    t.alpha = this.list.interpolate(t.agePercent);
+  }
+}
+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;
+  }
+}
+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);
+    }
+  }
+  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);
+    }
+  }
+  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;
+    }
+  }
+  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;
+  }
+}
+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
+    };
+  }
+  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;
+  }
+  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;
+  }
+  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;
+    }
+  }
+}
+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));
+  }
+  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;
+  }
+  updateParticle(t) {
+    t.tint = this.list.interpolate(t.agePercent);
+  }
+}
+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);
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      e.tint = this.value, e = e.next;
+  }
+}
+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);
+  }
+  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;
+        }
+    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;
+    }
+  }
+  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;
+    }
+  }
+}
+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;
+    }
+  }
+  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);
+  }
+  /**
+   * 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) {
+    L.shapes[e || t.type] = t;
+  }
+  initParticles(t) {
+    let e = t;
+    for (; e; )
+      this.shape.getRandPos(e), e = e.next;
+  }
+};
+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();
+  }
+}
+const st = ft.shared, b = Symbol("Position particle per emitter position"), M = class M {
+  /**
+   * @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) {
+    /**
+     * Active initialization behaviors for this emitter.
+     */
+    s(this, "initBehaviors");
+    /**
+     * Active update behaviors for this emitter.
+     */
+    s(this, "updateBehaviors");
+    /**
+     * Active recycle behaviors for this emitter.
+     */
+    s(this, "recycleBehaviors");
+    // properties for individual particles
+    /**
+     * The minimum lifetime for a particle, in seconds.
+     */
+    s(this, "minLifetime");
+    /**
+     * 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");
+    /**
+     * 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.
+     */
+    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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  set frequency(t) {
+    typeof t == "number" && t > 0 ? this._frequency = t : this._frequency = 1;
+  }
+  /**
+   * The container to add particles to. Settings this will dump any active particles.
+   */
+  get parent() {
+    return this._parent;
+  }
+  set parent(t) {
+    this.cleanup();
+    const e = t instanceof xt;
+    e !== this._isParticleContainer && (this._poolFirst = null), this._isParticleContainer = e, this._parent = t;
+  }
+  /**
+   * Создать частицу подходящего класса: лёгкую для ParticleContainer или спрайтовую для обычного контейнера
+   */
+  _createParticle() {
+    return this._isParticleContainer ? new kt(this) : new Rt(this);
+  }
+  /**
+   * Добавить частицу в контейнер (addParticle для ParticleContainer, addChild для обычного)
+   */
+  _addParticleToParent(t) {
+    this._isParticleContainer ? this._parent.addParticle(t) : this.addAtBack ? this._parent.addChildAt(t, 0) : this._parent.addChild(t);
+  }
+  /**
+   * 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
+    );
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  set emit(t) {
+    this._emit = !!t, this._emitterLife = this.emitterLifetime;
+  }
+  /**
+   * 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;
+  }
+  set autoUpdate(t) {
+    this._autoUpdate && !t ? st.remove(this.update, this) : !this._autoUpdate && t && st.add(this.update, this), this._autoUpdate = !!t;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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();
+    }
+  }
+  /**
+   * 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);
+      }
+    }
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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;
+  }
+};
+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
+    }
+  })) : 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;
+}
+m.registerBehavior(I);
+m.registerBehavior(V);
+m.registerBehavior(q);
+m.registerBehavior(N);
+m.registerBehavior(U);
+m.registerBehavior(W);
+m.registerBehavior(Y);
+m.registerBehavior(D);
+m.registerBehavior(X);
+m.registerBehavior(j);
+m.registerBehavior(G);
+m.registerBehavior(z);
+m.registerBehavior($);
+m.registerBehavior(Q);
+m.registerBehavior(H);
+m.registerBehavior(J);
+m.registerBehavior(K);
+m.registerBehavior(Z);
+m.registerBehavior(S);
+m.registerBehavior(tt);
+m.registerBehavior(et);
+m.registerBehavior(it);
+export {
+  kt as ContainerParticle,
+  m as Emitter,
+  Rt as Particle,
+  It as ParticleUtils,
+  R as PropertyList,
+  P as PropertyNode,
+  Vt as behaviors,
+  qt as upgradeConfig
+};