@rb-games/core 0.1.0

package/dist/particle/index.js

@@ -0,0 +1,2845 @@
+import { Texture, Ticker, Point, Sprite, Container } from 'pixi.js';
+import { Spine } from '@esotericsoftware/spine-pixi-v8';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// particle/ParticleUtils.ts
+var ParticleUtils_exports = {};
+__export(ParticleUtils_exports, {
+  DEG_TO_RADS: () => DEG_TO_RADS,
+  GetTextureFromString: () => GetTextureFromString,
+  combineRGBComponents: () => combineRGBComponents,
+  createSteppedGradient: () => createSteppedGradient,
+  generateEase: () => generateEase,
+  getBlendMode: () => getBlendMode,
+  hexToRGB: () => hexToRGB,
+  length: () => length,
+  normalize: () => normalize,
+  rotatePoint: () => rotatePoint,
+  scaleBy: () => scaleBy,
+  verbose: () => verbose
+});
+
+// particle/PropertyNode.ts
+var PropertyNode = class _PropertyNode {
+  /**
+   * Value for the node.
+   */
+  value;
+  /**
+   * Time value for the node. Between 0-1.
+   */
+  time;
+  /**
+   * The next node in line.
+   */
+  next;
+  /**
+   * If this is the first node in the list, controls if the entire list is stepped or not.
+   */
+  isStepped;
+  ease;
+  /**
+   * @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(value, time, ease) {
+    this.value = value;
+    this.time = time;
+    this.next = null;
+    this.isStepped = false;
+    if (ease) {
+      this.ease = typeof ease === "function" ? ease : generateEase(ease);
+    } else {
+      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(data) {
+    if ("list" in data) {
+      const array = data.list;
+      let node;
+      const { value, time } = array[0];
+      const first = node = new _PropertyNode(typeof value === "string" ? hexToRGB(value) : value, time, data.ease);
+      if (array.length > 2 || array.length === 2 && array[1].value !== value) {
+        for (let i = 1; i < array.length; ++i) {
+          const { value: value2, time: time2 } = array[i];
+          node.next = new _PropertyNode(typeof value2 === "string" ? hexToRGB(value2) : value2, time2);
+          node = node.next;
+        }
+      }
+      first.isStepped = !!data.isStepped;
+      return first;
+    }
+    const start = new _PropertyNode(typeof data.start === "string" ? hexToRGB(data.start) : data.start, 0);
+    if (data.end !== data.start) {
+      start.next = new _PropertyNode(typeof data.end === "string" ? hexToRGB(data.end) : data.end, 1);
+    }
+    return start;
+  }
+};
+
+// particle/ParticleUtils.ts
+var GetTextureFromString = Texture.from;
+var verbose = false;
+var DEG_TO_RADS = Math.PI / 180;
+function rotatePoint(angle, p) {
+  if (!angle) return;
+  const s = Math.sin(angle);
+  const c = Math.cos(angle);
+  const xnew = p.x * c - p.y * s;
+  const ynew = p.x * s + p.y * c;
+  p.x = xnew;
+  p.y = ynew;
+}
+function combineRGBComponents(r, g, b) {
+  return (
+    /* a << 24 |*/
+    r << 16 | g << 8 | b
+  );
+}
+function length(point) {
+  return Math.sqrt(point.x * point.x + point.y * point.y);
+}
+function normalize(point) {
+  const oneOverLen = 1 / length(point);
+  point.x *= oneOverLen;
+  point.y *= oneOverLen;
+}
+function scaleBy(point, value) {
+  point.x *= value;
+  point.y *= value;
+}
+function hexToRGB(color, output) {
+  if (!output) {
+    output = {};
+  }
+  if (color.charAt(0) === "#") {
+    color = color.substr(1);
+  } else if (color.indexOf("0x") === 0) {
+    color = color.substr(2);
+  }
+  let alpha;
+  if (color.length === 8) {
+    alpha = color.substr(0, 2);
+    color = color.substr(2);
+  }
+  output.r = parseInt(color.substr(0, 2), 16);
+  output.g = parseInt(color.substr(2, 2), 16);
+  output.b = parseInt(color.substr(4, 2), 16);
+  if (alpha) {
+    output.a = parseInt(alpha, 16);
+  }
+  return output;
+}
+function generateEase(segments) {
+  const qty = segments.length;
+  const oneOverQty = 1 / qty;
+  return function(time) {
+    const i = qty * time | 0;
+    const t = (time - i * oneOverQty) * qty;
+    const s = segments[i] || segments[qty - 1];
+    return s.s + t * (2 * (1 - t) * (s.cp - s.s) + t * (s.e - s.s));
+  };
+}
+function getBlendMode(name) {
+  if (!name) return "normal";
+  return name;
+}
+function createSteppedGradient(list, numSteps = 10) {
+  if (typeof numSteps !== "number" || numSteps <= 0) {
+    numSteps = 10;
+  }
+  const first = new PropertyNode(hexToRGB(list[0].value), list[0].time);
+  first.isStepped = true;
+  let currentNode = first;
+  let current = list[0];
+  let nextIndex = 1;
+  let next = list[nextIndex];
+  for (let i = 1; i < numSteps; ++i) {
+    let lerp = i / numSteps;
+    while (lerp > next.time) {
+      current = next;
+      next = list[++nextIndex];
+    }
+    lerp = (lerp - current.time) / (next.time - current.time);
+    const curVal = hexToRGB(current.value);
+    const nextVal = hexToRGB(next.value);
+    const output = {
+      r: (nextVal.r - curVal.r) * lerp + curVal.r,
+      g: (nextVal.g - curVal.g) * lerp + curVal.g,
+      b: (nextVal.b - curVal.b) * lerp + curVal.b
+    };
+    currentNode.next = new PropertyNode(output, i / numSteps);
+    currentNode = currentNode.next;
+  }
+  return first;
+}
+var Particle = class extends Sprite {
+  /**
+   * The emitter that controls this particle.
+   */
+  emitter;
+  /**
+   * The maximum lifetime of this particle, in seconds.
+   */
+  maxLife;
+  /**
+   * The current age of the particle, in seconds.
+   */
+  age;
+  /**
+   * The current age of the particle as a normalized value between 0 and 1.
+   */
+  agePercent;
+  /**
+   * One divided by the max life of the particle, saved for slightly faster math.
+   */
+  oneOverLife;
+  /**
+   * Reference to the next particle in the list.
+   */
+  next;
+  /**
+   * Reference to the previous particle in the list.
+   */
+  prev;
+  prevChild;
+  nextChild;
+  /**
+   * Static per-particle configuration for behaviors to use. Is not cleared when recycling.
+   */
+  config;
+  /**
+   * @param emitter The emitter that controls this particle.
+   */
+  constructor(emitter) {
+    super();
+    this.prevChild = this.nextChild = null;
+    this.emitter = emitter;
+    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(maxLife) {
+    this.maxLife = maxLife;
+    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 = true;
+  }
+  /**
+   * 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() {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+    this.emitter = this.next = this.prev = null;
+    super.destroy();
+  }
+};
+
+// particle/behaviors/Behaviors.ts
+var BehaviorOrder = /* @__PURE__ */ ((BehaviorOrder2) => {
+  BehaviorOrder2[BehaviorOrder2["Spawn"] = 0] = "Spawn";
+  BehaviorOrder2[BehaviorOrder2["Normal"] = 2] = "Normal";
+  BehaviorOrder2[BehaviorOrder2["Late"] = 5] = "Late";
+  return BehaviorOrder2;
+})(BehaviorOrder || {});
+var ticker = Ticker.shared;
+var PositionParticle = Symbol("Position particle per emitter position");
+var Emitter = class _Emitter {
+  static knownBehaviors = {};
+  /**
+   * 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(constructor) {
+    _Emitter.knownBehaviors[constructor.type] = constructor;
+  }
+  /**
+   * Active initialization behaviors for this emitter.
+   */
+  initBehaviors;
+  /**
+   * Active update behaviors for this emitter.
+   */
+  updateBehaviors;
+  /**
+   * Active recycle behaviors for this emitter.
+   */
+  recycleBehaviors;
+  // properties for individual particles
+  /**
+   * The minimum lifetime for a particle, in seconds.
+   */
+  minLifetime;
+  /**
+   * The maximum lifetime for a particle, in seconds.
+   */
+  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.
+   */
+  customEase;
+  // properties for spawning particles
+  /**
+   * Time between particle spawns in seconds.
+   */
+  _frequency;
+  /**
+   * Chance that a particle will be spawned on each opportunity to spawn one.
+   * 0 is 0%, 1 is 100%.
+   */
+  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.
+   */
+  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.
+   */
+  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().
+   */
+  spawnPos;
+  /**
+   * Number of particles to spawn time that the frequency allows for particles to spawn.
+   */
+  particlesPerWave;
+  /**
+   * Rotation of the emitter or emitter's owner in degrees. This is added to
+   * the calculated spawn angle.
+   * To change this, use rotate().
+   */
+  rotation;
+  /**
+   * The world position of the emitter's owner, to add spawnPos to when
+   * spawning particles. To change this, use updateOwnerPos().
+   */
+  ownerPos;
+  /**
+   * The origin + spawnPos in the previous update, so that the spawn position
+   * can be interpolated to space out particles better.
+   */
+  _prevEmitterPos;
+  /**
+   * If _prevEmitterPos is valid, to prevent interpolation on the first update
+   */
+  _prevPosIsValid;
+  /**
+   * If either ownerPos or spawnPos has changed since the previous update.
+   */
+  _posChanged;
+  /**
+   * The container to add particles to.
+   */
+  _parent;
+  /**
+   * If particles should be added at the back of the display list instead of the front.
+   */
+  addAtBack;
+  /**
+   * The current number of active particles.
+   */
+  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.
+   */
+  _emit;
+  /**
+   * The timer for when to spawn particles in seconds, where numbers less
+   * than 0 mean that particles should be spawned.
+   */
+  _spawnTimer;
+  /**
+   * The life of the emitter in seconds.
+   */
+  _emitterLife;
+  /**
+   * The particles that are active and on the display list. This is the first particle in a
+   * linked list.
+   */
+  _activeParticlesFirst;
+  /**
+   * The particles that are active and on the display list. This is the last particle in a
+   * linked list.
+   */
+  _activeParticlesLast;
+  /**
+   * The particles that are not currently being used. This is the first particle in a
+   * linked list.
+   */
+  _poolFirst;
+  /**
+   * The original config object that this emitter was initialized with.
+   */
+  _origConfig;
+  /**
+   * If the update function is called automatically from the shared ticker.
+   * Setting this to false requires calling the update function manually.
+   */
+  _autoUpdate;
+  /**
+   * If the emitter should destroy itself when all particles have died out. This is set by
+   * playOnceAndDestroy();
+   */
+  _destroyWhenComplete;
+  /**
+   * A callback for when all particles have died out. This is set by
+   * playOnceAndDestroy() or playOnce();
+   */
+  _completeCallback;
+  /**
+   * Factory method to create a new particle. Override this in subclasses
+   * to create custom particle types (e.g., SpineParticle).
+   */
+  createParticle() {
+    return new Particle(this);
+  }
+  /**
+   * @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(particleParent, config) {
+    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 Point();
+    this.particlesPerWave = 1;
+    this.rotation = 0;
+    this.ownerPos = new Point();
+    this._prevEmitterPos = new Point();
+    this._prevPosIsValid = false;
+    this._posChanged = false;
+    this._parent = null;
+    this.addAtBack = false;
+    this.particleCount = 0;
+    this._emit = false;
+    this._spawnTimer = 0;
+    this._emitterLife = -1;
+    this._activeParticlesFirst = null;
+    this._activeParticlesLast = null;
+    this._poolFirst = null;
+    this._origConfig = null;
+    this._autoUpdate = false;
+    this._destroyWhenComplete = false;
+    this._completeCallback = null;
+    this.parent = particleParent;
+    if (config) {
+      this.init(config);
+    }
+    this.recycle = this.recycle;
+    this.update = this.update;
+    this.rotate = this.rotate;
+    this.updateSpawnPos = this.updateSpawnPos;
+    this.updateOwnerPos = this.updateOwnerPos;
+  }
+  /**
+   * 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(value) {
+    if (typeof value === "number" && value > 0) {
+      this._frequency = value;
+    } else {
+      this._frequency = 1;
+    }
+  }
+  /**
+  * The container to add particles to. Settings this will dump any active particles.
+  */
+  get parent() {
+    return this._parent;
+  }
+  set parent(value) {
+    this.cleanup();
+    this._parent = value;
+  }
+  /**
+   * Sets up the emitter based on the config settings.
+   * @param config A configuration object containing settings for the emitter.
+   */
+  init(config) {
+    if (!config) {
+      return;
+    }
+    this.cleanup();
+    this._origConfig = config;
+    this.minLifetime = config.lifetime.min;
+    this.maxLifetime = config.lifetime.max;
+    if (config.ease) {
+      this.customEase = typeof config.ease === "function" ? config.ease : generateEase(config.ease);
+    } else {
+      this.customEase = null;
+    }
+    this.particlesPerWave = 1;
+    if (config.particlesPerWave && config.particlesPerWave > 1) {
+      this.particlesPerWave = config.particlesPerWave;
+    }
+    this.frequency = config.frequency;
+    this.spawnChance = typeof config.spawnChance === "number" && config.spawnChance > 0 ? config.spawnChance : 1;
+    this.emitterLifetime = config.emitterLifetime || -1;
+    this.maxParticles = config.maxParticles ?? 1e3;
+    this.addAtBack = !!config.addAtBack;
+    this.rotation = 0;
+    this.ownerPos.set(0);
+    if (config.pos) {
+      this.spawnPos.copyFrom(config.pos);
+    } else {
+      this.spawnPos.set(0);
+    }
+    this._prevEmitterPos.copyFrom(this.spawnPos);
+    this._prevPosIsValid = false;
+    this._spawnTimer = 0;
+    this.emit = config.emit === void 0 ? true : !!config.emit;
+    this.autoUpdate = !!config.autoUpdate;
+    const behaviors = config.behaviors.map((data) => {
+      const constructor = _Emitter.knownBehaviors[data.type];
+      if (!constructor) {
+        console.error(`Unknown behavior: ${data.type}`);
+        return null;
+      }
+      return new constructor(data.config);
+    }).filter((b) => !!b);
+    behaviors.push(PositionParticle);
+    behaviors.sort((a, b) => {
+      if (a === PositionParticle) {
+        return b.order === 0 /* Spawn */ ? 1 : -1;
+      } else if (b === PositionParticle) {
+        return a.order === 0 /* Spawn */ ? -1 : 1;
+      }
+      return a.order - b.order;
+    });
+    this.initBehaviors = behaviors.slice();
+    this.updateBehaviors = behaviors.filter((b) => b !== PositionParticle && b.updateParticle);
+    this.recycleBehaviors = behaviors.filter((b) => b !== PositionParticle && b.recycleParticle);
+  }
+  /**
+   * Gets the instantiated behavior of the specified type, if it is present on this emitter.
+   * @param type The behavior type to find.
+   */
+  getBehavior(type) {
+    if (!_Emitter.knownBehaviors[type]) return null;
+    return this.initBehaviors.find((b) => b instanceof _Emitter.knownBehaviors[type]) || 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(count) {
+    for (; count > 0; --count) {
+      const p = new Particle(this);
+      p.next = this._poolFirst;
+      this._poolFirst = p;
+    }
+  }
+  /**
+   * 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(particle, fromCleanup = false) {
+    var _a, _b;
+    for (let i = 0; i < this.recycleBehaviors.length; ++i) {
+      (_b = (_a = this.recycleBehaviors[i]).recycleParticle) == null ? void 0 : _b.call(_a, particle, !fromCleanup);
+    }
+    if (particle.next) {
+      particle.next.prev = particle.prev;
+    }
+    if (particle.prev) {
+      particle.prev.next = particle.next;
+    }
+    if (particle === this._activeParticlesLast) {
+      this._activeParticlesLast = particle.prev;
+    }
+    if (particle === this._activeParticlesFirst) {
+      this._activeParticlesFirst = particle.next;
+    }
+    particle.prev = null;
+    particle.next = this._poolFirst;
+    this._poolFirst = particle;
+    if (particle.parent) {
+      particle.parent.removeChild(particle);
+    }
+    --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(newRot) {
+    if (this.rotation === newRot) return;
+    const diff = newRot - this.rotation;
+    this.rotation = newRot;
+    rotatePoint(diff, this.spawnPos);
+    this._posChanged = true;
+  }
+  /**
+   * 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(x, y) {
+    this._posChanged = true;
+    this.spawnPos.x = x;
+    this.spawnPos.y = y;
+  }
+  /**
+   * 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(x, y) {
+    this._posChanged = true;
+    this.ownerPos.x = x;
+    this.ownerPos.y = y;
+  }
+  /**
+   * 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 = false;
+  }
+  /**
+   * 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(value) {
+    this._emit = !!value;
+    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(value) {
+    if (this._autoUpdate && !value) {
+      ticker.remove(this._update, this);
+    } else if (!this._autoUpdate && value) {
+      ticker.add(this._update, this);
+    }
+    this._autoUpdate = !!value;
+  }
+  /**
+   * 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(callback) {
+    this.autoUpdate = true;
+    this.emit = true;
+    this._destroyWhenComplete = true;
+    this._completeCallback = callback;
+  }
+  /**
+   * 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(callback) {
+    this.emit = true;
+    this._completeCallback = callback;
+  }
+  _update(ticker2) {
+    this.update(ticker2.deltaTime);
+  }
+  /**
+   * Updates all particles spawned by this emitter and emits new ones.
+   * @param delta Time elapsed since the previous frame, in __seconds__.
+   */
+  update(delta) {
+    if (this._autoUpdate) {
+      delta = ticker.elapsedMS * 1e-3;
+    }
+    if (!this._parent) return;
+    for (let particle = this._activeParticlesFirst, next; particle; particle = next) {
+      next = particle.next;
+      particle.age += delta;
+      if (particle.age > particle.maxLife || particle.age < 0) {
+        this.recycle(particle);
+      } else {
+        let lerp = particle.age * particle.oneOverLife;
+        if (this.customEase) {
+          if (this.customEase.length === 4) {
+            lerp = this.customEase(lerp, 0, 1, 1);
+          } else {
+            lerp = this.customEase(lerp);
+          }
+        }
+        particle.agePercent = lerp;
+        for (let i = 0; i < this.updateBehaviors.length; ++i) {
+          if (this.updateBehaviors[i].updateParticle(particle, delta)) {
+            this.recycle(particle);
+            break;
+          }
+        }
+      }
+    }
+    let prevX = 0;
+    let prevY = 0;
+    if (this._prevPosIsValid) {
+      prevX = this._prevEmitterPos.x;
+      prevY = this._prevEmitterPos.y;
+    }
+    const curX = this.ownerPos.x + this.spawnPos.x;
+    const curY = this.ownerPos.y + this.spawnPos.y;
+    if (this._emit) {
+      this._spawnTimer -= delta < 0 ? 0 : delta;
+      while (this._spawnTimer <= 0) {
+        if (this._emitterLife >= 0) {
+          this._emitterLife -= this._frequency;
+          if (this._emitterLife <= 0) {
+            this._spawnTimer = 0;
+            this._emitterLife = 0;
+            this.emit = false;
+            break;
+          }
+        }
+        if (this.particleCount >= this.maxParticles) {
+          this._spawnTimer += this._frequency;
+          continue;
+        }
+        let emitPosX;
+        let emitPosY;
+        if (this._prevPosIsValid && this._posChanged) {
+          const lerp = 1 + this._spawnTimer / delta;
+          emitPosX = (curX - prevX) * lerp + prevX;
+          emitPosY = (curY - prevY) * lerp + prevY;
+        } else {
+          emitPosX = curX;
+          emitPosY = curY;
+        }
+        let waveFirst = null;
+        let waveLast = null;
+        for (let len = Math.min(this.particlesPerWave, this.maxParticles - this.particleCount), i = 0; i < len; ++i) {
+          if (this.spawnChance < 1 && Math.random() >= this.spawnChance) {
+            continue;
+          }
+          let lifetime;
+          if (this.minLifetime === this.maxLifetime) {
+            lifetime = this.minLifetime;
+          } else {
+            lifetime = Math.random() * (this.maxLifetime - this.minLifetime) + this.minLifetime;
+          }
+          if (-this._spawnTimer >= lifetime) {
+            continue;
+          }
+          let p;
+          if (this._poolFirst) {
+            p = this._poolFirst;
+            this._poolFirst = this._poolFirst.next;
+            p.next = null;
+          } else {
+            p = this.createParticle();
+          }
+          p.init(lifetime);
+          if (this.addAtBack) {
+            this._parent.addChildAt(p, 0);
+          } else {
+            this._parent.addChild(p);
+          }
+          if (waveFirst) {
+            waveLast.next = p;
+            p.prev = waveLast;
+            waveLast = p;
+          } else {
+            waveLast = waveFirst = p;
+          }
+          ++this.particleCount;
+        }
+        if (waveFirst) {
+          if (this._activeParticlesLast) {
+            this._activeParticlesLast.next = waveFirst;
+            waveFirst.prev = this._activeParticlesLast;
+            this._activeParticlesLast = waveLast;
+          } else {
+            this._activeParticlesFirst = waveFirst;
+            this._activeParticlesLast = waveLast;
+          }
+          for (let i = 0; i < this.initBehaviors.length; ++i) {
+            const behavior = this.initBehaviors[i];
+            if (behavior === PositionParticle) {
+              for (let particle = waveFirst, next; particle; particle = next) {
+                next = particle.next;
+                if (this.rotation !== 0) {
+                  rotatePoint(this.rotation, particle.position);
+                  particle.rotation += this.rotation;
+                }
+                particle.position.x += emitPosX;
+                particle.position.y += emitPosY;
+                particle.age += -this._spawnTimer;
+                let lerp = particle.age * particle.oneOverLife;
+                if (this.customEase) {
+                  if (this.customEase.length === 4) {
+                    lerp = this.customEase(lerp, 0, 1, 1);
+                  } else {
+                    lerp = this.customEase(lerp);
+                  }
+                }
+                particle.agePercent = lerp;
+              }
+            } else {
+              behavior.initParticles(waveFirst);
+            }
+          }
+          for (let particle = waveFirst, next; particle; particle = next) {
+            next = particle.next;
+            for (let i = 0; i < this.updateBehaviors.length; ++i) {
+              if (this.updateBehaviors[i].updateParticle(particle, -this._spawnTimer)) {
+                this.recycle(particle);
+                break;
+              }
+            }
+          }
+        }
+        this._spawnTimer += this._frequency;
+      }
+    }
+    if (this._posChanged) {
+      this._prevEmitterPos.x = curX;
+      this._prevEmitterPos.y = curY;
+      this._prevPosIsValid = true;
+      this._posChanged = false;
+    }
+    if (!this._emit && !this._activeParticlesFirst) {
+      if (this._completeCallback) {
+        const cb = this._completeCallback;
+        this._completeCallback = null;
+        cb();
+      }
+      if (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 emitPosX = this.ownerPos.x + this.spawnPos.x;
+    const emitPosY = this.ownerPos.y + this.spawnPos.y;
+    let waveFirst = null;
+    let waveLast = null;
+    for (let len = Math.min(this.particlesPerWave, this.maxParticles - this.particleCount), i = 0; i < len; ++i) {
+      if (this.spawnChance < 1 && Math.random() >= this.spawnChance) {
+        continue;
+      }
+      let p;
+      if (this._poolFirst) {
+        p = this._poolFirst;
+        this._poolFirst = this._poolFirst.next;
+        p.next = null;
+      } else {
+        p = this.createParticle();
+      }
+      let lifetime;
+      if (this.minLifetime === this.maxLifetime) {
+        lifetime = this.minLifetime;
+      } else {
+        lifetime = Math.random() * (this.maxLifetime - this.minLifetime) + this.minLifetime;
+      }
+      p.init(lifetime);
+      if (this.addAtBack) {
+        this._parent.addChildAt(p, 0);
+      } else {
+        this._parent.addChild(p);
+      }
+      if (waveFirst) {
+        waveLast.next = p;
+        p.prev = waveLast;
+        waveLast = p;
+      } else {
+        waveLast = waveFirst = p;
+      }
+      ++this.particleCount;
+    }
+    if (waveFirst) {
+      if (this._activeParticlesLast) {
+        this._activeParticlesLast.next = waveFirst;
+        waveFirst.prev = this._activeParticlesLast;
+        this._activeParticlesLast = waveLast;
+      } else {
+        this._activeParticlesFirst = waveFirst;
+        this._activeParticlesLast = waveLast;
+      }
+      for (let i = 0; i < this.initBehaviors.length; ++i) {
+        const behavior = this.initBehaviors[i];
+        if (behavior === PositionParticle) {
+          for (let particle = waveFirst, next; particle; particle = next) {
+            next = particle.next;
+            if (this.rotation !== 0) {
+              rotatePoint(this.rotation, particle.position);
+              particle.rotation += this.rotation;
+            }
+            particle.position.x += emitPosX;
+            particle.position.y += emitPosY;
+          }
+        } else {
+          behavior.initParticles(waveFirst);
+        }
+      }
+    }
+  }
+  /**
+   * Kills all active particles immediately.
+   */
+  cleanup() {
+    let particle;
+    let next;
+    for (particle = this._activeParticlesFirst; particle; particle = next) {
+      next = particle.next;
+      this.recycle(particle, true);
+    }
+    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 = false;
+    this.cleanup();
+    let next;
+    for (let particle = this._poolFirst; particle; particle = next) {
+      next = particle.next;
+      particle.destroy();
+    }
+    this._poolFirst = this._parent = this.spawnPos = this.ownerPos = this.customEase = this._completeCallback = null;
+    this.initBehaviors.length = this.updateBehaviors.length = this.recycleBehaviors.length = 0;
+  }
+};
+
+// particle/behaviors/index.ts
+var behaviors_exports = {};
+__export(behaviors_exports, {
+  AccelerationBehavior: () => AccelerationBehavior,
+  AlphaBehavior: () => AlphaBehavior,
+  BehaviorOrder: () => BehaviorOrder,
+  BlendModeBehavior: () => BlendModeBehavior,
+  BurstSpawnBehavior: () => BurstSpawnBehavior,
+  ColorBehavior: () => ColorBehavior,
+  MultiStateAnimatedTextureBehavior: () => MultiStateAnimatedTextureBehavior,
+  NoRotationBehavior: () => NoRotationBehavior,
+  OrderedTextureBehavior: () => OrderedTextureBehavior,
+  PathBehavior: () => PathBehavior,
+  PointSpawnBehavior: () => PointSpawnBehavior,
+  RandomAnimatedTextureBehavior: () => RandomAnimatedTextureBehavior,
+  RandomColor: () => RandomColor,
+  RandomTextureBehavior: () => RandomTextureBehavior,
+  RotationBehavior: () => RotationBehavior,
+  ScaleBehavior: () => ScaleBehavior,
+  ShapeSpawnBehavior: () => ShapeSpawnBehavior,
+  SingleAnimatedTextureBehavior: () => SingleAnimatedTextureBehavior,
+  SingleTextureBehavior: () => SingleTextureBehavior,
+  SpeedBehavior: () => SpeedBehavior,
+  SpineAnimationBehavior: () => SpineAnimationBehavior,
+  SpineAnimationSequenceBehavior: () => SpineAnimationSequenceBehavior,
+  SpineRandomSkinBehavior: () => SpineRandomSkinBehavior,
+  StaticAlphaBehavior: () => StaticAlphaBehavior,
+  StaticColorBehavior: () => StaticColorBehavior,
+  StaticRotationBehavior: () => StaticRotationBehavior,
+  StaticScaleBehavior: () => StaticScaleBehavior,
+  StaticSpeedBehavior: () => StaticSpeedBehavior,
+  ZIndexBehavior: () => ZIndexBehavior,
+  editor: () => Types_exports,
+  spawnShapes: () => shapes_exports
+});
+
+// particle/behaviors/shapes/index.ts
+var shapes_exports = {};
+__export(shapes_exports, {
+  PolygonalChain: () => PolygonalChain,
+  Rectangle: () => Rectangle,
+  Torus: () => Torus
+});
+
+// particle/behaviors/shapes/Rectangle.ts
+var Rectangle = class {
+  static type = "rect";
+  static editorConfig = null;
+  /**
+   * X (left) position of the rectangle.
+   */
+  x;
+  /**
+   * Y (top) position of the rectangle.
+   */
+  y;
+  /**
+   * Width of the rectangle.
+   */
+  w;
+  /**
+   * Height of the rectangle.
+   */
+  h;
+  constructor(config) {
+    this.x = config.x;
+    this.y = config.y;
+    this.w = config.w;
+    this.h = config.h;
+  }
+  getRandPos(particle) {
+    particle.x = Math.random() * this.w + this.x;
+    particle.y = Math.random() * this.h + this.y;
+  }
+};
+
+// particle/behaviors/shapes/Torus.ts
+var Torus = class {
+  static type = "torus";
+  static editorConfig = null;
+  /**
+   * X position of the center of the shape.
+   */
+  x;
+  /**
+   * Y position of the center of the shape.
+   */
+  y;
+  /**
+   * Radius of circle, or outer radius of a ring.
+   */
+  radius;
+  /**
+   * Inner radius of a ring. Use 0 to have a circle.
+   */
+  innerRadius;
+  /**
+   * If rotation should be applied to particles.
+   */
+  rotation;
+  constructor(config) {
+    this.x = config.x || 0;
+    this.y = config.y || 0;
+    this.radius = config.radius;
+    this.innerRadius = config.innerRadius || 0;
+    this.rotation = !!config.affectRotation;
+  }
+  getRandPos(particle) {
+    if (this.innerRadius !== this.radius) {
+      particle.x = Math.random() * (this.radius - this.innerRadius) + this.innerRadius;
+    } else {
+      particle.x = this.radius;
+    }
+    particle.y = 0;
+    const angle = Math.random() * Math.PI * 2;
+    if (this.rotation) {
+      particle.rotation += angle;
+    }
+    rotatePoint(angle, particle.position);
+    particle.position.x += this.x;
+    particle.position.y += this.y;
+  }
+};
+
+// particle/behaviors/shapes/PolygonalChain.ts
+var PolygonalChain = class {
+  static type = "polygonalChain";
+  static editorConfig = null;
+  /**
+   * List of segment objects in the chain.
+   */
+  segments;
+  /**
+   * Total length of all segments of the chain.
+   */
+  totalLength;
+  /**
+   * Total length of segments up to and including the segment of the same index.
+   * Used for weighted random selection of segment.
+   */
+  countingLengths;
+  /**
+   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
+   */
+  constructor(data) {
+    this.segments = [];
+    this.countingLengths = [];
+    this.totalLength = 0;
+    this.init(data);
+  }
+  /**
+   * @param data Point data for polygon chains. Either a list of points for a single chain, or a list of chains.
+   */
+  init(data) {
+    if (!data || !data.length) {
+      this.segments.push({ p1: { x: 0, y: 0 }, p2: { x: 0, y: 0 }, l: 0 });
+    } else if (Array.isArray(data[0])) {
+      for (let i = 0; i < data.length; ++i) {
+        const chain = data[i];
+        let prevPoint = chain[0];
+        for (let j = 1; j < chain.length; ++j) {
+          const second = chain[j];
+          this.segments.push({ p1: prevPoint, p2: second, l: 0 });
+          prevPoint = second;
+        }
+      }
+    } else {
+      let prevPoint = data[0];
+      for (let i = 1; i < data.length; ++i) {
+        const second = data[i];
+        this.segments.push({ p1: prevPoint, p2: second, l: 0 });
+        prevPoint = second;
+      }
+    }
+    for (let i = 0; i < this.segments.length; ++i) {
+      const { p1, p2 } = this.segments[i];
+      const segLength = Math.sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
+      this.segments[i].l = segLength;
+      this.totalLength += segLength;
+      this.countingLengths.push(this.totalLength);
+    }
+  }
+  /**
+   * Gets a random point in the chain.
+   * @param out The point to store the selected position in.
+   */
+  getRandPos(out) {
+    const rand = Math.random() * this.totalLength;
+    let chosenSeg;
+    let lerp;
+    if (this.segments.length === 1) {
+      chosenSeg = this.segments[0];
+      lerp = rand;
+    } else {
+      for (let i = 0; i < this.countingLengths.length; ++i) {
+        if (rand < this.countingLengths[i]) {
+          chosenSeg = this.segments[i];
+          lerp = i === 0 ? rand : rand - this.countingLengths[i - 1];
+          break;
+        }
+      }
+    }
+    lerp /= chosenSeg.l || 1;
+    const { p1, p2 } = chosenSeg;
+    out.x = p1.x + lerp * (p2.x - p1.x);
+    out.y = p1.y + lerp * (p2.y - p1.y);
+  }
+};
+
+// particle/behaviors/editor/Types.ts
+var Types_exports = {};
+var AccelerationBehavior = class {
+  static type = "moveAcceleration";
+  static editorConfig = null;
+  // doesn't _really_ need to be late, but doing so ensures that we can override any
+  // rotation behavior that is mistakenly added
+  order = 5 /* Late */;
+  minStart;
+  maxStart;
+  accel;
+  rotate;
+  maxSpeed;
+  constructor(config) {
+    this.minStart = config.minStart;
+    this.maxStart = config.maxStart;
+    this.accel = config.accel;
+    this.rotate = !!config.rotate;
+    this.maxSpeed = config.maxSpeed ?? 0;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const speed = Math.random() * (this.maxStart - this.minStart) + this.minStart;
+      if (!next.config.velocity) {
+        next.config.velocity = new Point(speed, 0);
+      } else {
+        next.config.velocity.set(speed, 0);
+      }
+      rotatePoint(next.rotation, next.config.velocity);
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const vel = particle.config.velocity;
+    const oldVX = vel.x;
+    const oldVY = vel.y;
+    vel.x += this.accel.x * deltaSec;
+    vel.y += this.accel.y * deltaSec;
+    if (this.maxSpeed) {
+      const currentSpeed = length(vel);
+      if (currentSpeed > this.maxSpeed) {
+        scaleBy(vel, this.maxSpeed / currentSpeed);
+      }
+    }
+    particle.x += (oldVX + vel.x) / 2 * deltaSec;
+    particle.y += (oldVY + vel.y) / 2 * deltaSec;
+    if (this.rotate) {
+      particle.rotation = Math.atan2(vel.y, vel.x);
+    }
+  }
+};
+
+// particle/PropertyList.ts
+function intValueSimple(lerp) {
+  if (this.ease) lerp = this.ease(lerp);
+  return (this.first.next.value - this.first.value) * lerp + this.first.value;
+}
+function intColorSimple(lerp) {
+  if (this.ease) lerp = this.ease(lerp);
+  const curVal = this.first.value;
+  const nextVal = this.first.next.value;
+  const r = (nextVal.r - curVal.r) * lerp + curVal.r;
+  const g = (nextVal.g - curVal.g) * lerp + curVal.g;
+  const b = (nextVal.b - curVal.b) * lerp + curVal.b;
+  return combineRGBComponents(r, g, b);
+}
+function intValueComplex(lerp) {
+  if (this.ease) lerp = this.ease(lerp);
+  let current = this.first;
+  let next = current.next;
+  while (lerp > next.time) {
+    current = next;
+    next = next.next;
+  }
+  lerp = (lerp - current.time) / (next.time - current.time);
+  return (next.value - current.value) * lerp + current.value;
+}
+function intColorComplex(lerp) {
+  if (this.ease) lerp = this.ease(lerp);
+  let current = this.first;
+  let next = current.next;
+  while (lerp > next.time) {
+    current = next;
+    next = next.next;
+  }
+  lerp = (lerp - current.time) / (next.time - current.time);
+  const curVal = current.value;
+  const nextVal = next.value;
+  const r = (nextVal.r - curVal.r) * lerp + curVal.r;
+  const g = (nextVal.g - curVal.g) * lerp + curVal.g;
+  const b = (nextVal.b - curVal.b) * lerp + curVal.b;
+  return combineRGBComponents(r, g, b);
+}
+function intValueStepped(lerp) {
+  if (this.ease) lerp = this.ease(lerp);
+  let current = this.first;
+  while (current.next && lerp > current.next.time) {
+    current = current.next;
+  }
+  return current.value;
+}
+function intColorStepped(lerp) {
+  if (this.ease) lerp = this.ease(lerp);
+  let current = this.first;
+  while (current.next && lerp > current.next.time) {
+    current = current.next;
+  }
+  const curVal = current.value;
+  return combineRGBComponents(curVal.r, curVal.g, curVal.b);
+}
+var PropertyList = class {
+  /**
+   * The first property node in the linked list.
+   */
+  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.
+   */
+  interpolate;
+  /**
+   * A custom easing method for this list.
+   * @param lerp The interpolation value from 0-1.
+   * @return The eased value, also from 0-1.
+   */
+  ease;
+  /**
+   * If this list manages colors, which requires a different method for interpolation.
+   */
+  isColor;
+  /**
+   * @param isColor If this list handles color values
+   */
+  constructor(isColor = false) {
+    this.first = null;
+    this.isColor = !!isColor;
+    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(first) {
+    this.first = first;
+    const isSimple = first.next && first.next.time >= 1;
+    if (isSimple) {
+      this.interpolate = this.isColor ? intColorSimple : intValueSimple;
+    } else if (first.isStepped) {
+      this.interpolate = this.isColor ? intColorStepped : intValueStepped;
+    } else {
+      this.interpolate = this.isColor ? intColorComplex : intValueComplex;
+    }
+    this.ease = this.first.ease;
+  }
+};
+
+// particle/behaviors/Alpha.ts
+var AlphaBehavior = class {
+  static type = "alpha";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  list;
+  constructor(config) {
+    this.list = new PropertyList(false);
+    this.list.reset(PropertyNode.createList(config.alpha));
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.alpha = this.list.first.value;
+      next = next.next;
+    }
+  }
+  updateParticle(particle) {
+    particle.alpha = this.list.interpolate(particle.agePercent);
+  }
+};
+var StaticAlphaBehavior = class {
+  static type = "alphaStatic";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  value;
+  constructor(config) {
+    this.value = config.alpha;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.alpha = this.value;
+      next = next.next;
+    }
+  }
+};
+function getTextures(textures) {
+  const outTextures = [];
+  for (let j = 0; j < textures.length; ++j) {
+    let tex = textures[j];
+    if (typeof tex === "string") {
+      outTextures.push(GetTextureFromString(tex));
+    } else if (tex instanceof Texture) {
+      outTextures.push(tex);
+    } else {
+      let dupe = tex.count || 1;
+      if (typeof tex.texture === "string") {
+        tex = GetTextureFromString(tex.texture);
+      } else {
+        tex = tex.texture;
+      }
+      for (; dupe > 0; --dupe) {
+        outTextures.push(tex);
+      }
+    }
+  }
+  return outTextures;
+}
+var RandomAnimatedTextureBehavior = class {
+  static type = "animatedRandom";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  anims;
+  constructor(config) {
+    this.anims = [];
+    for (let i = 0; i < config.anims.length; ++i) {
+      const anim = config.anims[i];
+      const textures = getTextures(anim.textures);
+      const framerate = anim.framerate < 0 ? -1 : anim.framerate > 0 ? anim.framerate : 60;
+      const parsedAnim = {
+        textures,
+        duration: framerate > 0 ? textures.length / framerate : 0,
+        framerate,
+        loop: framerate > 0 ? !!anim.loop : false
+      };
+      this.anims.push(parsedAnim);
+    }
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const index = Math.floor(Math.random() * this.anims.length);
+      const anim = next.config.anim = this.anims[index];
+      next.texture = anim.textures[0];
+      next.config.animElapsed = 0;
+      if (anim.framerate === -1) {
+        next.config.animDuration = next.maxLife;
+        next.config.animFramerate = anim.textures.length / next.maxLife;
+      } else {
+        next.config.animDuration = anim.duration;
+        next.config.animFramerate = anim.framerate;
+      }
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const config = particle.config;
+    const anim = config.anim;
+    config.animElapsed += deltaSec;
+    if (config.animElapsed >= config.animDuration) {
+      if (config.anim.loop) {
+        config.animElapsed = config.animElapsed % config.animDuration;
+      } else {
+        config.animElapsed = config.animDuration - 1e-6;
+      }
+    }
+    const frame = config.animElapsed * config.animFramerate + 1e-7 | 0;
+    particle.texture = anim.textures[frame] || anim.textures[anim.textures.length - 1] || Texture.EMPTY;
+  }
+};
+var SingleAnimatedTextureBehavior = class {
+  static type = "animatedSingle";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  anim;
+  constructor(config) {
+    const anim = config.anim;
+    const textures = getTextures(anim.textures);
+    const framerate = anim.framerate < 0 ? -1 : anim.framerate > 0 ? anim.framerate : 60;
+    this.anim = {
+      textures,
+      duration: framerate > 0 ? textures.length / framerate : 0,
+      framerate,
+      loop: framerate > 0 ? !!anim.loop : false
+    };
+  }
+  initParticles(first) {
+    let next = first;
+    const anim = this.anim;
+    while (next) {
+      next.texture = anim.textures[0];
+      next.config.animElapsed = 0;
+      if (anim.framerate === -1) {
+        next.config.animDuration = next.maxLife;
+        next.config.animFramerate = anim.textures.length / next.maxLife;
+      } else {
+        next.config.animDuration = anim.duration;
+        next.config.animFramerate = anim.framerate;
+      }
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const anim = this.anim;
+    const config = particle.config;
+    config.animElapsed += deltaSec;
+    if (config.animElapsed >= config.animDuration) {
+      if (anim.loop) {
+        config.animElapsed = config.animElapsed % config.animDuration;
+      } else {
+        config.animElapsed = config.animDuration - 1e-6;
+      }
+    }
+    const frame = config.animElapsed * config.animFramerate + 1e-7 | 0;
+    particle.texture = anim.textures[frame] || anim.textures[anim.textures.length - 1] || Texture.EMPTY;
+  }
+};
+
+// particle/behaviors/BlendMode.ts
+var BlendModeBehavior = class {
+  static type = "blendMode";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  value;
+  constructor(config) {
+    this.value = config.blendMode;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.blendMode = getBlendMode(this.value);
+      next = next.next;
+    }
+  }
+};
+
+// particle/behaviors/BurstSpawn.ts
+var BurstSpawnBehavior = class {
+  static type = "spawnBurst";
+  static editorConfig = null;
+  order = 0 /* Spawn */;
+  spacing;
+  start;
+  distance;
+  constructor(config) {
+    this.spacing = config.spacing * DEG_TO_RADS;
+    this.start = config.start * DEG_TO_RADS;
+    this.distance = config.distance;
+  }
+  initParticles(first) {
+    let count = 0;
+    let next = first;
+    while (next) {
+      let angle;
+      if (this.spacing) {
+        angle = this.start + this.spacing * count;
+      } else {
+        angle = Math.random() * Math.PI * 2;
+      }
+      next.rotation = angle;
+      if (this.distance) {
+        next.position.x = this.distance;
+        rotatePoint(angle, next.position);
+      }
+      next = next.next;
+      ++count;
+    }
+  }
+};
+
+// particle/behaviors/Color.ts
+var ColorBehavior = class {
+  static type = "color";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  list;
+  constructor(config) {
+    this.list = new PropertyList(true);
+    this.list.reset(PropertyNode.createList(config.color));
+  }
+  initParticles(first) {
+    let next = first;
+    const color = this.list.first.value;
+    const tint = combineRGBComponents(color.r, color.g, color.b);
+    while (next) {
+      next.tint = tint;
+      next = next.next;
+    }
+  }
+  updateParticle(particle) {
+    particle.tint = this.list.interpolate(particle.agePercent);
+  }
+};
+var StaticColorBehavior = class {
+  static type = "colorStatic";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  value;
+  constructor(config) {
+    let color = config.color;
+    if (color.charAt(0) === "#") {
+      color = color.substr(1);
+    } else if (color.indexOf("0x") === 0) {
+      color = color.substr(2);
+    }
+    this.value = parseInt(color, 16);
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.tint = this.value;
+      next = next.next;
+    }
+  }
+};
+
+// particle/behaviors/OrderedTexture.ts
+var OrderedTextureBehavior = class {
+  static type = "textureOrdered";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  textures;
+  index;
+  constructor(config) {
+    this.index = 0;
+    this.textures = config.textures.map((tex) => typeof tex === "string" ? GetTextureFromString(tex) : tex);
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.texture = this.textures[this.index];
+      if (++this.index >= this.textures.length) {
+        this.index = 0;
+      }
+      next = next.next;
+    }
+  }
+};
+var helperPoint = new Point();
+var MATH_FUNCS = [
+  "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"
+];
+var WHITELISTER = new RegExp(
+  [
+    // Allow the 4 basic operations, parentheses and all numbers/decimals, as well
+    // as 'x', for the variable usage.
+    "[01234567890\\.\\*\\-\\+\\/\\(\\)x ,]"
+  ].concat(MATH_FUNCS).join("|"),
+  "g"
+);
+function parsePath(pathString) {
+  const matches = pathString.match(WHITELISTER);
+  for (let i = matches.length - 1; i >= 0; --i) {
+    if (MATH_FUNCS.indexOf(matches[i]) >= 0) {
+      matches[i] = `Math.${matches[i]}`;
+    }
+  }
+  pathString = matches.join("");
+  return new Function("x", `return ${pathString};`);
+}
+var PathBehavior = class {
+  static type = "movePath";
+  static editorConfig = null;
+  // *MUST* happen after other behaviors do initialization so that we can read initial transformations
+  order = 5 /* Late */;
+  /**
+   * The function representing the path the particle should take.
+   */
+  path;
+  list;
+  minMult;
+  constructor(config) {
+    if (config.path) {
+      if (typeof config.path === "function") {
+        this.path = config.path;
+      } else {
+        try {
+          this.path = parsePath(config.path);
+        } catch (e) {
+          this.path = null;
+        }
+      }
+    } else {
+      this.path = (x) => x;
+    }
+    this.list = new PropertyList(false);
+    this.list.reset(PropertyNode.createList(config.speed));
+    this.minMult = config.minMult ?? 1;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.config.initRotation = next.rotation;
+      if (!next.config.initPosition) {
+        next.config.initPosition = new Point(next.x, next.y);
+      } else {
+        next.config.initPosition.copyFrom(next.position);
+      }
+      next.config.movement = 0;
+      const mult = Math.random() * (1 - this.minMult) + this.minMult;
+      next.config.speedMult = mult;
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const speed = this.list.interpolate(particle.agePercent) * particle.config.speedMult;
+    particle.config.movement += speed * deltaSec;
+    helperPoint.x = particle.config.movement;
+    helperPoint.y = this.path(helperPoint.x);
+    rotatePoint(particle.config.initRotation, helperPoint);
+    particle.position.x = particle.config.initPosition.x + helperPoint.x;
+    particle.position.y = particle.config.initPosition.y + helperPoint.y;
+  }
+};
+
+// particle/behaviors/PointSpawn.ts
+var PointSpawnBehavior = class {
+  static type = "spawnPoint";
+  static editorConfig = null;
+  order = 0 /* Spawn */;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  initParticles(_first) {
+  }
+};
+
+// particle/behaviors/RandomTexture.ts
+var RandomTextureBehavior = class {
+  static type = "textureRandom";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  textures;
+  constructor(config) {
+    this.textures = config.textures.map((tex) => typeof tex === "string" ? GetTextureFromString(tex) : tex);
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const index = Math.floor(Math.random() * this.textures.length);
+      next.texture = this.textures[index];
+      next = next.next;
+    }
+  }
+};
+
+// particle/behaviors/Rotation.ts
+var RotationBehavior = class {
+  static type = "rotation";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  minStart;
+  maxStart;
+  minSpeed;
+  maxSpeed;
+  accel;
+  constructor(config) {
+    this.minStart = config.minStart * DEG_TO_RADS;
+    this.maxStart = config.maxStart * DEG_TO_RADS;
+    this.minSpeed = config.minSpeed * DEG_TO_RADS;
+    this.maxSpeed = config.maxSpeed * DEG_TO_RADS;
+    this.accel = config.accel * DEG_TO_RADS;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      if (this.minStart === this.maxStart) {
+        next.rotation += this.maxStart;
+      } else {
+        next.rotation += Math.random() * (this.maxStart - this.minStart) + this.minStart;
+      }
+      next.config.rotSpeed = Math.random() * (this.maxSpeed - this.minSpeed) + this.minSpeed;
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    if (this.accel) {
+      const oldSpeed = particle.config.rotSpeed;
+      particle.config.rotSpeed += this.accel * deltaSec;
+      particle.rotation += (particle.config.rotSpeed + oldSpeed) / 2 * deltaSec;
+    } else {
+      particle.rotation += particle.config.rotSpeed * deltaSec;
+    }
+  }
+};
+var StaticRotationBehavior = class {
+  static type = "rotationStatic";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  min;
+  max;
+  constructor(config) {
+    this.min = config.min * DEG_TO_RADS;
+    this.max = config.max * DEG_TO_RADS;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      if (this.min === this.max) {
+        next.rotation += this.max;
+      } else {
+        next.rotation += Math.random() * (this.max - this.min) + this.min;
+      }
+      next = next.next;
+    }
+  }
+};
+var NoRotationBehavior = class {
+  static type = "noRotation";
+  static editorConfig = null;
+  order = 5 /* Late */ + 1;
+  rotation;
+  constructor(config) {
+    this.rotation = (config.rotation || 0) * DEG_TO_RADS;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.rotation = this.rotation;
+      next = next.next;
+    }
+  }
+};
+
+// particle/behaviors/Scale.ts
+var ScaleBehavior = class {
+  static type = "scale";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  list;
+  minMult;
+  constructor(config) {
+    this.list = new PropertyList(false);
+    this.list.reset(PropertyNode.createList(config.scale));
+    this.minMult = config.minMult ?? 1;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const mult = Math.random() * (1 - this.minMult) + this.minMult;
+      next.config.scaleMult = mult;
+      next.scale.x = next.scale.y = this.list.first.value * mult;
+      next = next.next;
+    }
+  }
+  updateParticle(particle) {
+    particle.scale.x = particle.scale.y = this.list.interpolate(particle.agePercent) * particle.config.scaleMult;
+  }
+};
+var StaticScaleBehavior = class {
+  static type = "scaleStatic";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  min;
+  max;
+  constructor(config) {
+    this.min = config.min;
+    this.max = config.max;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const scale = Math.random() * (this.max - this.min) + this.min;
+      next.scale.x = next.scale.y = scale;
+      next = next.next;
+    }
+  }
+};
+
+// particle/behaviors/ShapeSpawn.ts
+var ShapeSpawnBehavior = class _ShapeSpawnBehavior {
+  static type = "spawnShape";
+  static editorConfig = null;
+  /**
+   * Dictionary of all registered shape classes.
+   */
+  static shapes = {};
+  /**
+   * 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(constructor, typeOverride) {
+    _ShapeSpawnBehavior.shapes[typeOverride || constructor.type] = constructor;
+  }
+  order = 0 /* Spawn */;
+  shape;
+  constructor(config) {
+    const ShapeClass = _ShapeSpawnBehavior.shapes[config.type];
+    if (!ShapeClass) {
+      throw new Error(`No shape found with type '${config.type}'`);
+    }
+    this.shape = new ShapeClass(config.data);
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      this.shape.getRandPos(next);
+      next = next.next;
+    }
+  }
+};
+ShapeSpawnBehavior.registerShape(PolygonalChain);
+ShapeSpawnBehavior.registerShape(Rectangle);
+ShapeSpawnBehavior.registerShape(Torus);
+ShapeSpawnBehavior.registerShape(Torus, "circle");
+
+// particle/behaviors/SingleTexture.ts
+var SingleTextureBehavior = class {
+  static type = "textureSingle";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  texture;
+  constructor(config) {
+    this.texture = typeof config.texture === "string" ? GetTextureFromString(config.texture) : config.texture;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next.texture = this.texture;
+      next = next.next;
+    }
+  }
+};
+var SpeedBehavior = class {
+  static type = "moveSpeed";
+  static editorConfig = null;
+  order = 5 /* Late */;
+  list;
+  minMult;
+  constructor(config) {
+    this.list = new PropertyList(false);
+    this.list.reset(PropertyNode.createList(config.speed));
+    this.minMult = config.minMult ?? 1;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const mult = Math.random() * (1 - this.minMult) + this.minMult;
+      next.config.speedMult = mult;
+      if (!next.config.velocity) {
+        next.config.velocity = new Point(this.list.first.value * mult, 0);
+      } else {
+        next.config.velocity.set(this.list.first.value * mult, 0);
+      }
+      rotatePoint(next.rotation, next.config.velocity);
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const speed = this.list.interpolate(particle.agePercent) * particle.config.speedMult;
+    const vel = particle.config.velocity;
+    normalize(vel);
+    scaleBy(vel, speed);
+    particle.x += vel.x * deltaSec;
+    particle.y += vel.y * deltaSec;
+  }
+};
+var StaticSpeedBehavior = class {
+  static type = "moveSpeedStatic";
+  static editorConfig = null;
+  order = 5 /* Late */;
+  min;
+  max;
+  constructor(config) {
+    this.min = config.min;
+    this.max = config.max;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const speed = Math.random() * (this.max - this.min) + this.min;
+      if (!next.config.velocity) {
+        next.config.velocity = new Point(speed, 0);
+      } else {
+        next.config.velocity.set(speed, 0);
+      }
+      rotatePoint(next.rotation, next.config.velocity);
+      next = next.next;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const velocity = particle.config.velocity;
+    particle.x += velocity.x * deltaSec;
+    particle.y += velocity.y * deltaSec;
+  }
+};
+
+// particle/behaviors/RandomColor.ts
+var RandomColor = class {
+  static type = "rngcolor";
+  static editorConfig;
+  order = 2 /* Normal */;
+  list;
+  constructor(config) {
+    this.list = config.colour.map((color) => hexToRGB(color));
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const index = Math.floor(Math.random() * this.list.length);
+      const color = this.list[index];
+      const tint = combineRGBComponents(color.r, color.g, color.b);
+      next.tint = tint;
+      next = next.next;
+    }
+  }
+};
+
+// particle/behaviors/ZindexBehavior.ts
+var ZIndexBehavior = class {
+  static type = "zIndex";
+  static editorConfig;
+  order = 2 /* Normal */;
+  list;
+  constructor(config) {
+    this.list = new PropertyList(false);
+    this.list.reset(PropertyNode.createList(config.zIndex));
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      next = next.next;
+    }
+  }
+  updateParticle(particle) {
+    particle.zIndex = this.list.interpolate(particle.agePercent);
+  }
+};
+function getTextures2(textures) {
+  const outTextures = [];
+  for (let j = 0; j < textures.length; ++j) {
+    let tex = textures[j];
+    if (typeof tex === "string") {
+      outTextures.push(GetTextureFromString(tex));
+    } else if (tex instanceof Texture) {
+      outTextures.push(tex);
+    } else {
+      let dupe = tex.count || 1;
+      if (typeof tex.texture === "string") {
+        tex = GetTextureFromString(tex.texture);
+      } else {
+        tex = tex.texture;
+      }
+      for (; dupe > 0; --dupe) {
+        outTextures.push(tex);
+      }
+    }
+  }
+  return outTextures;
+}
+function parseAnimationState(state) {
+  const textures = getTextures2(state.textures);
+  const framerate = state.framerate < 0 ? -1 : state.framerate > 0 ? state.framerate : 60;
+  return {
+    textures,
+    duration: framerate > 0 ? textures.length / framerate : 0,
+    framerate,
+    loop: framerate > 0 ? !!state.loop : false
+  };
+}
+var MultiStateAnimatedTextureBehavior = class {
+  static type = "multiStateAnimated";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  sets;
+  initialState;
+  constructor(config) {
+    this.initialState = config.initialState || "default";
+    this.sets = [];
+    for (const set of config.sets) {
+      const parsedSet = {
+        id: set.id,
+        states: {}
+      };
+      for (const [stateName, stateConfig] of Object.entries(set.states)) {
+        parsedSet.states[stateName] = parseAnimationState(stateConfig);
+      }
+      this.sets.push(parsedSet);
+    }
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const particle = next;
+      const setIndex = Math.floor(Math.random() * this.sets.length);
+      const set = this.sets[setIndex];
+      particle.config.animSet = set;
+      particle.config.animSetId = set.id;
+      particle.config.animStateName = this.initialState;
+      this.applyState(particle, this.initialState);
+      particle.config.setState = (stateName) => {
+        if (particle.config.animStateName !== stateName) {
+          this.applyState(particle, stateName);
+        }
+      };
+      next = next.next;
+    }
+  }
+  applyState(particle, stateName) {
+    const set = particle.config.animSet;
+    const state = set.states[stateName];
+    if (!state) {
+      console.warn(`[MultiStateAnimatedTexture] State '${stateName}' not found in set '${set.id}'`);
+      return;
+    }
+    particle.config.animStateName = stateName;
+    particle.config.anim = state;
+    particle.config.animElapsed = 0;
+    particle.texture = state.textures[0] || Texture.EMPTY;
+    if (state.framerate === -1) {
+      particle.config.animDuration = particle.maxLife;
+      particle.config.animFramerate = state.textures.length / particle.maxLife;
+    } else {
+      particle.config.animDuration = state.duration;
+      particle.config.animFramerate = state.framerate;
+    }
+  }
+  updateParticle(particle, deltaSec) {
+    const config = particle.config;
+    const anim = config.anim;
+    if (!anim || !anim.textures.length) return;
+    config.animElapsed += deltaSec;
+    if (config.animElapsed >= config.animDuration) {
+      if (anim.loop) {
+        config.animElapsed = config.animElapsed % config.animDuration;
+      } else {
+        config.animElapsed = config.animDuration - 1e-6;
+      }
+    }
+    const frame = config.animElapsed * config.animFramerate + 1e-7 | 0;
+    particle.texture = anim.textures[frame] || anim.textures[anim.textures.length - 1] || Texture.EMPTY;
+  }
+};
+
+// particle/behaviors/SpineTexture.ts
+var SpineAnimationBehavior = class {
+  static type = "spineAnimation";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  animation;
+  loop;
+  timeScale;
+  skin;
+  skins;
+  constructor(config) {
+    this.animation = config.animation;
+    this.loop = config.loop ?? false;
+    this.timeScale = config.timeScale ?? 1;
+    this.skin = config.skin ?? null;
+    this.skins = config.skins ?? null;
+  }
+  /**
+   * Initialize particles with Spine animation and skin
+   */
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const particle = next;
+      if (particle.spine) {
+        if (this.skins && this.skins.length > 0) {
+          const randomIndex = Math.floor(Math.random() * this.skins.length);
+          const skinName = this.skins[randomIndex];
+          particle.spine.skeleton.setSkinByName(skinName);
+          particle.spine.skeleton.setSlotsToSetupPose();
+        } else if (this.skin) {
+          particle.spine.skeleton.setSkinByName(this.skin);
+          particle.spine.skeleton.setSlotsToSetupPose();
+        }
+        const trackEntry = particle.spine.state.setAnimation(0, this.animation, this.loop);
+        if (trackEntry) {
+          trackEntry.timeScale = this.timeScale;
+        }
+      }
+      next = particle.next;
+    }
+  }
+  /**
+   * Update is not needed - Spine handles its own animation updates
+   */
+  updateParticle(_particle, _deltaSec) {
+  }
+};
+var SpineRandomSkinBehavior = class {
+  static type = "spineRandomSkin";
+  static editorConfig = null;
+  order = 2 /* Normal */ - 1;
+  // Run before animation behavior
+  skins;
+  constructor(config) {
+    this.skins = config.skins;
+  }
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const particle = next;
+      if (particle.spine && this.skins.length > 0) {
+        const randomIndex = Math.floor(Math.random() * this.skins.length);
+        const skinName = this.skins[randomIndex];
+        particle.spine.skeleton.setSkinByName(skinName);
+        particle.spine.skeleton.setSlotsToSetupPose();
+      }
+      next = particle.next;
+    }
+  }
+};
+var SpineAnimationSequenceBehavior = class {
+  static type = "spineAnimationSequence";
+  static editorConfig = null;
+  order = 2 /* Normal */;
+  animationList;
+  loop;
+  timeScale;
+  skin;
+  skins;
+  constructor(config) {
+    this.animationList = config.animation.list;
+    this.loop = config.loop ?? false;
+    this.timeScale = config.timeScale ?? 1;
+    this.skin = config.skin ?? null;
+    this.skins = config.skins ?? null;
+  }
+  /**
+   * Initialize particles with skin and first animation
+   */
+  initParticles(first) {
+    let next = first;
+    while (next) {
+      const particle = next;
+      if (particle.spine) {
+        if (this.skins && this.skins.length > 0) {
+          const randomIndex = Math.floor(Math.random() * this.skins.length);
+          const skinName = this.skins[randomIndex];
+          particle.spine.skeleton.setSkinByName(skinName);
+          particle.spine.skeleton.setSlotsToSetupPose();
+        } else if (this.skin) {
+          particle.spine.skeleton.setSkinByName(this.skin);
+          particle.spine.skeleton.setSlotsToSetupPose();
+        }
+        if (this.animationList.length > 0) {
+          const firstAnim = this.animationList[0];
+          const trackEntry = particle.spine.state.setAnimation(0, firstAnim.value, this.loop);
+          if (trackEntry) {
+            trackEntry.timeScale = this.timeScale;
+          }
+        }
+        particle.config.spineAnimIndex = 0;
+      }
+      next = particle.next;
+    }
+  }
+  /**
+   * Update particle - check if we need to switch to next animation
+   */
+  updateParticle(particle, _deltaSec) {
+    const spineParticle = particle;
+    if (!spineParticle.spine) return;
+    const currentIndex = spineParticle.config.spineAnimIndex ?? 0;
+    const agePercent = spineParticle.agePercent;
+    for (let i = currentIndex + 1; i < this.animationList.length; i++) {
+      const keyframe = this.animationList[i];
+      if (agePercent >= keyframe.time) {
+        const trackEntry = spineParticle.spine.state.setAnimation(0, keyframe.value, this.loop);
+        if (trackEntry) {
+          trackEntry.timeScale = this.timeScale;
+        }
+        spineParticle.config.spineAnimIndex = i;
+      }
+    }
+  }
+};
+
+// particle/EmitterConfig.ts
+function upgradeConfig(config, art) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  if ("behaviors" in config) {
+    return config;
+  }
+  const out = {
+    lifetime: config.lifetime,
+    ease: config.ease,
+    particlesPerWave: config.particlesPerWave,
+    frequency: config.frequency,
+    spawnChance: config.spawnChance,
+    emitterLifetime: config.emitterLifetime,
+    maxParticles: config.maxParticles,
+    addAtBack: config.addAtBack,
+    pos: config.pos,
+    emit: config.emit,
+    autoUpdate: config.autoUpdate,
+    behaviors: []
+  };
+  if (config.alpha) {
+    if ("start" in config.alpha) {
+      if (config.alpha.start === config.alpha.end) {
+        if (config.alpha.start !== 1) {
+          out.behaviors.push({
+            type: "alphaStatic",
+            config: { alpha: config.alpha.start }
+          });
+        }
+      } else {
+        const list = {
+          list: [
+            { time: 0, value: config.alpha.start },
+            { time: 1, value: config.alpha.end }
+          ]
+        };
+        out.behaviors.push({
+          type: "alpha",
+          config: { alpha: list }
+        });
+      }
+    } else if (config.alpha.list.length === 1) {
+      if (config.alpha.list[0].value !== 1) {
+        out.behaviors.push({
+          type: "alphaStatic",
+          config: { alpha: config.alpha.list[0].value }
+        });
+      }
+    } else {
+      out.behaviors.push({
+        type: "alpha",
+        config: { alpha: config.alpha }
+      });
+    }
+  }
+  if (config.acceleration && (config.acceleration.x || config.acceleration.y)) {
+    let minStart;
+    let maxStart;
+    if ("start" in config.speed) {
+      minStart = config.speed.start * (config.speed.minimumSpeedMultiplier ?? 1);
+      maxStart = config.speed.start;
+    } else {
+      minStart = config.speed.list[0].value * (config.minimumSpeedMultiplier ?? 1);
+      maxStart = config.speed.list[0].value;
+    }
+    out.behaviors.push({
+      type: "moveAcceleration",
+      config: {
+        accel: config.acceleration,
+        minStart,
+        maxStart,
+        rotate: !config.noRotation,
+        maxSpeed: config.maxSpeed
+      }
+    });
+  } else if ((_a = config.extraData) == null ? void 0 : _a.path) {
+    let list;
+    let mult;
+    if ("start" in config.speed) {
+      mult = config.speed.minimumSpeedMultiplier ?? 1;
+      if (config.speed.start === config.speed.end) {
+        list = {
+          list: [{ time: 0, value: config.speed.start }]
+        };
+      } else {
+        list = {
+          list: [
+            { time: 0, value: config.speed.start },
+            { time: 1, value: config.speed.end }
+          ]
+        };
+      }
+    } else {
+      list = config.speed;
+      mult = config.minimumSpeedMultiplier ?? 1;
+    }
+    out.behaviors.push({
+      type: "movePath",
+      config: {
+        path: config.extraData.path,
+        speed: list,
+        minMult: mult
+      }
+    });
+  } else {
+    if (config.speed) {
+      if ("start" in config.speed) {
+        if (config.speed.start === config.speed.end) {
+          out.behaviors.push({
+            type: "moveSpeedStatic",
+            config: {
+              min: config.speed.start * (config.speed.minimumSpeedMultiplier ?? 1),
+              max: config.speed.start
+            }
+          });
+        } else {
+          const list = {
+            list: [
+              { time: 0, value: config.speed.start },
+              { time: 1, value: config.speed.end }
+            ]
+          };
+          out.behaviors.push({
+            type: "moveSpeed",
+            config: { speed: list, minMult: config.speed.minimumSpeedMultiplier }
+          });
+        }
+      } else if (config.speed.list.length === 1) {
+        out.behaviors.push({
+          type: "moveSpeedStatic",
+          config: {
+            min: config.speed.list[0].value * (config.minimumSpeedMultiplier ?? 1),
+            max: config.speed.list[0].value
+          }
+        });
+      } else {
+        out.behaviors.push({
+          type: "moveSpeed",
+          config: { speed: config.speed, minMult: config.minimumSpeedMultiplier ?? 1 }
+        });
+      }
+    }
+  }
+  if (config.scale) {
+    if ("start" in config.scale) {
+      const mult = config.scale.minimumScaleMultiplier ?? 1;
+      if (config.scale.start === config.scale.end) {
+        out.behaviors.push({
+          type: "scaleStatic",
+          config: {
+            min: config.scale.start * mult,
+            max: config.scale.start
+          }
+        });
+      } else {
+        const list = {
+          list: [
+            { time: 0, value: config.scale.start },
+            { time: 1, value: config.scale.end }
+          ]
+        };
+        out.behaviors.push({
+          type: "scale",
+          config: { scale: list, minMult: mult }
+        });
+      }
+    } else if (config.scale.list.length === 1) {
+      const mult = config.minimumScaleMultiplier ?? 1;
+      const scale = config.scale.list[0].value;
+      out.behaviors.push({
+        type: "scaleStatic",
+        config: { min: scale * mult, max: scale }
+      });
+    } else {
+      out.behaviors.push({
+        type: "scale",
+        config: { scale: config.scale, minMult: config.minimumScaleMultiplier ?? 1 }
+      });
+    }
+  }
+  if (config.color) {
+    if ("start" in config.color) {
+      if (config.color.start === config.color.end) {
+        if (config.color.start !== "ffffff") {
+          out.behaviors.push({
+            type: "colorStatic",
+            config: { color: config.color.start }
+          });
+        }
+      } else {
+        const list = {
+          list: [
+            { time: 0, value: config.color.start },
+            { time: 1, value: config.color.end }
+          ]
+        };
+        out.behaviors.push({
+          type: "color",
+          config: { color: list }
+        });
+      }
+    } else if (config.color.list.length === 1) {
+      if (config.color.list[0].value !== "ffffff") {
+        out.behaviors.push({
+          type: "colorStatic",
+          config: { color: config.color.list[0].value }
+        });
+      }
+    } else {
+      out.behaviors.push({
+        type: "color",
+        config: { color: config.color }
+      });
+    }
+  }
+  if (config.rotationAcceleration || ((_b = config.rotationSpeed) == null ? void 0 : _b.min) || ((_c = config.rotationSpeed) == null ? void 0 : _c.max)) {
+    out.behaviors.push({
+      type: "rotation",
+      config: {
+        accel: config.rotationAcceleration || 0,
+        minSpeed: ((_d = config.rotationSpeed) == null ? void 0 : _d.min) || 0,
+        maxSpeed: ((_e = config.rotationSpeed) == null ? void 0 : _e.max) || 0,
+        minStart: ((_f = config.startRotation) == null ? void 0 : _f.min) || 0,
+        maxStart: ((_g = config.startRotation) == null ? void 0 : _g.max) || 0
+      }
+    });
+  } else if (((_h = config.startRotation) == null ? void 0 : _h.min) || ((_i = config.startRotation) == null ? void 0 : _i.max)) {
+    out.behaviors.push({
+      type: "rotationStatic",
+      config: {
+        min: ((_j = config.startRotation) == null ? void 0 : _j.min) || 0,
+        max: ((_k = config.startRotation) == null ? void 0 : _k.max) || 0
+      }
+    });
+  }
+  if (config.noRotation) {
+    out.behaviors.push({
+      type: "noRotation",
+      config: {}
+    });
+  }
+  if (config.blendMode && config.blendMode !== "normal") {
+    out.behaviors.push({
+      type: "blendMode",
+      config: {
+        blendMode: config.blendMode
+      }
+    });
+  }
+  if (Array.isArray(art) && typeof art[0] !== "string" && "framerate" in art[0]) {
+    for (let i = 0; i < art.length; ++i) {
+      if (art[i].framerate === "matchLife") {
+        art[i].framerate = -1;
+      }
+    }
+    out.behaviors.push({
+      type: "animatedRandom",
+      config: {
+        anims: art
+      }
+    });
+  } else if (typeof art !== "string" && "framerate" in art) {
+    if (art.framerate === "matchLife") {
+      art.framerate = -1;
+    }
+    out.behaviors.push({
+      type: "animatedSingle",
+      config: {
+        anim: art
+      }
+    });
+  } else if (config.orderedArt && Array.isArray(art)) {
+    out.behaviors.push({
+      type: "textureOrdered",
+      config: {
+        textures: art
+      }
+    });
+  } else if (Array.isArray(art)) {
+    out.behaviors.push({
+      type: "textureRandom",
+      config: {
+        textures: art
+      }
+    });
+  } else {
+    out.behaviors.push({
+      type: "textureSingle",
+      config: {
+        texture: art
+      }
+    });
+  }
+  if (config.spawnType === "burst") {
+    out.behaviors.push({
+      type: "spawnBurst",
+      config: {
+        start: config.angleStart || 0,
+        spacing: config.particleSpacing,
+        // older formats bursted from a single point
+        distance: 0
+      }
+    });
+  } else if (config.spawnType === "point") {
+    out.behaviors.push({
+      type: "spawnPoint",
+      config: {}
+    });
+  } else {
+    let shape;
+    if (config.spawnType === "ring") {
+      shape = {
+        type: "torus",
+        data: {
+          x: config.spawnCircle.x,
+          y: config.spawnCircle.y,
+          radius: config.spawnCircle.r,
+          innerRadius: config.spawnCircle.minR,
+          affectRotation: true
+        }
+      };
+    } else if (config.spawnType === "circle") {
+      shape = {
+        type: "torus",
+        data: {
+          x: config.spawnCircle.x,
+          y: config.spawnCircle.y,
+          radius: config.spawnCircle.r,
+          innerRadius: 0,
+          affectRotation: false
+        }
+      };
+    } else if (config.spawnType === "rect") {
+      shape = {
+        type: "rect",
+        data: config.spawnRect
+      };
+    } else if (config.spawnType === "polygonalChain") {
+      shape = {
+        type: "polygonalChain",
+        data: config.spawnPolygon
+      };
+    }
+    if (shape) {
+      out.behaviors.push({
+        type: "spawnShape",
+        config: shape
+      });
+    }
+  }
+  return out;
+}
+var SpineParticle = class extends Container {
+  /**
+   * The Spine instance for this particle.
+   */
+  spine;
+  /**
+   * The emitter that controls this particle.
+   * Using any to avoid circular dependency with SpineEmitter.
+   */
+  emitter;
+  /**
+   * The maximum lifetime of this particle, in seconds.
+   */
+  maxLife;
+  /**
+   * The current age of the particle, in seconds.
+   */
+  age;
+  /**
+   * The current age of the particle as a normalized value between 0 and 1.
+   */
+  agePercent;
+  /**
+   * One divided by the max life of the particle, saved for slightly faster math.
+   */
+  oneOverLife;
+  /**
+   * Reference to the next particle in the list.
+   */
+  next;
+  /**
+   * Reference to the previous particle in the list.
+   */
+  prev;
+  prevChild;
+  nextChild;
+  /**
+   * Static per-particle configuration for behaviors to use. Is not cleared when recycling.
+   */
+  config;
+  /**
+   * @param emitter The emitter that controls this particle.
+   */
+  constructor(emitter) {
+    super();
+    this.prevChild = this.nextChild = null;
+    this.emitter = emitter;
+    this.config = {};
+    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;
+  }
+  /**
+   * Sets the Spine instance for this particle.
+   * Called by SpineEmitter when creating the particle.
+   */
+  setSpine(spine) {
+    this.spine = spine;
+    this.addChild(spine);
+  }
+  /**
+   * Initializes the particle for use, based on the properties that have to
+   * have been set already on the particle.
+   */
+  init(maxLife) {
+    this.maxLife = maxLife;
+    this.age = this.agePercent = 0;
+    this.rotation = 0;
+    this.position.x = this.position.y = 0;
+    this.scale.x = this.scale.y = 1;
+    this.alpha = 1;
+    this.oneOverLife = 1 / this.maxLife;
+    this.visible = true;
+    if (this.spine) {
+      this.spine.state.clearTracks();
+      this.spine.skeleton.setToSetupPose();
+    }
+  }
+  /**
+   * 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() {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+    if (this.spine) {
+      this.spine.destroy();
+    }
+    this.emitter = this.next = this.prev = null;
+    super.destroy();
+  }
+};
+var SpineEmitter = class extends Emitter {
+  /**
+   * Skeleton asset key for creating Spine instances
+   */
+  skeletonKey;
+  /**
+   * Atlas asset key for creating Spine instances
+   */
+  atlasKey;
+  constructor(particleParent, config) {
+    const fullConfig = {
+      ...config,
+      pos: config.pos ?? { x: 0, y: 0 }
+    };
+    super(particleParent, fullConfig);
+    this.skeletonKey = "";
+    this.atlasKey = "";
+    if (config.spineData) {
+      this.skeletonKey = config.spineData.skeleton;
+      this.atlasKey = config.spineData.atlas;
+    }
+  }
+  /**
+   * Override createParticle to return SpineParticle instead of Particle.
+   * This is called by the base Emitter when spawning new particles.
+   * Returns any to satisfy base class signature while actually returning SpineParticle.
+   */
+  createParticle() {
+    const particle = new SpineParticle(this);
+    const spine = Spine.from({
+      skeleton: this.skeletonKey,
+      atlas: this.atlasKey
+    });
+    particle.setSpine(spine);
+    return particle;
+  }
+};
+
+// particle/index.ts
+Emitter.registerBehavior(AccelerationBehavior);
+Emitter.registerBehavior(AlphaBehavior);
+Emitter.registerBehavior(StaticAlphaBehavior);
+Emitter.registerBehavior(RandomAnimatedTextureBehavior);
+Emitter.registerBehavior(SingleAnimatedTextureBehavior);
+Emitter.registerBehavior(BlendModeBehavior);
+Emitter.registerBehavior(BurstSpawnBehavior);
+Emitter.registerBehavior(ColorBehavior);
+Emitter.registerBehavior(StaticColorBehavior);
+Emitter.registerBehavior(OrderedTextureBehavior);
+Emitter.registerBehavior(PathBehavior);
+Emitter.registerBehavior(PointSpawnBehavior);
+Emitter.registerBehavior(RandomTextureBehavior);
+Emitter.registerBehavior(RotationBehavior);
+Emitter.registerBehavior(StaticRotationBehavior);
+Emitter.registerBehavior(NoRotationBehavior);
+Emitter.registerBehavior(ScaleBehavior);
+Emitter.registerBehavior(StaticScaleBehavior);
+Emitter.registerBehavior(ShapeSpawnBehavior);
+Emitter.registerBehavior(SingleTextureBehavior);
+Emitter.registerBehavior(SpeedBehavior);
+Emitter.registerBehavior(StaticSpeedBehavior);
+Emitter.registerBehavior(MultiStateAnimatedTextureBehavior);
+Emitter.registerBehavior(ZIndexBehavior);
+Emitter.registerBehavior(SpineAnimationBehavior);
+Emitter.registerBehavior(SpineRandomSkinBehavior);
+Emitter.registerBehavior(SpineAnimationSequenceBehavior);
+
+export { Emitter, Particle, ParticleUtils_exports as ParticleUtils, PropertyList, PropertyNode, SpineEmitter, SpineParticle, behaviors_exports as behaviors, upgradeConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map