@gamebob/axon-surge 0.5.0

package/dist/axon-surge.js

@@ -0,0 +1,1872 @@
+class G {
+  listeners = /* @__PURE__ */ new Map();
+  on(t, i) {
+    return this.listeners.has(t) || this.listeners.set(t, /* @__PURE__ */ new Set()), this.listeners.get(t).add(i), () => this.off(t, i);
+  }
+  off(t, i) {
+    const e = this.listeners.get(t);
+    e && e.delete(i);
+  }
+  emit(t, i) {
+    const e = this.listeners.get(t);
+    e && e.forEach((s) => s(i));
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+class B {
+  animationFrameId = null;
+  lastTime = 0;
+  isRunning = !1;
+  updateCallback;
+  renderCallback;
+  constructor(t, i) {
+    this.updateCallback = t, this.renderCallback = i;
+  }
+  start() {
+    this.isRunning || (this.isRunning = !0, this.lastTime = performance.now(), this.tick = this.tick.bind(this), this.animationFrameId = requestAnimationFrame(this.tick));
+  }
+  stop() {
+    this.isRunning = !1, this.animationFrameId !== null && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = null);
+  }
+  tick(t) {
+    if (!this.isRunning) return;
+    const i = Math.min((t - this.lastTime) / 1e3, 0.1);
+    this.lastTime = t, this.updateCallback(i), this.renderCallback(), this.animationFrameId = requestAnimationFrame(this.tick);
+  }
+}
+class U {
+  position;
+  radius = 44;
+  integrity = 3;
+  maxIntegrity = 3;
+  pulsePhase = 0;
+  organicSeed;
+  constructor(t, i) {
+    this.position = { x: t, y: i }, this.organicSeed = Math.random() * 100;
+  }
+  update(t) {
+    this.pulsePhase += t * 2.8;
+  }
+  getMembraneRadius(t) {
+    const i = Math.sin(t * 5 + this.pulsePhase * 1.5 + this.organicSeed) * 5, e = Math.cos(t * 3 - this.pulsePhase * 2.2) * 3, s = Math.sin(t * 7 + this.pulsePhase * 3.1) * 2;
+    return this.radius + i + e + s;
+  }
+  takeDamage() {
+    return this.integrity > 0 ? (this.integrity -= 1, !0) : !1;
+  }
+  reset(t, i) {
+    this.position = { x: t, y: i }, this.integrity = this.maxIntegrity, this.pulsePhase = 0;
+  }
+}
+class P {
+  id;
+  position = { x: 0, y: 0 };
+  velocity = { x: 0, y: 0 };
+  radius = 20;
+  type = "piercer";
+  active = !1;
+  isGrabbed = !1;
+  isThrown = !1;
+  wasManipulated = !1;
+  rotation = 0;
+  color = "#ff2a5f";
+  strategy = null;
+  hitRadiusPadding = 0.5;
+  isDying = !1;
+  deathType = "none";
+  deathTimer = 0;
+  maxDeathTimer = 0.4;
+  sliceAngle = 0;
+  constructor(t) {
+    this.id = t;
+  }
+  getHitRadius() {
+    return this.radius * (1 + this.hitRadiusPadding);
+  }
+  triggerDissolveDeath() {
+    this.isDying || (this.isDying = !0, this.deathType = "dissolve", this.deathTimer = 0, this.maxDeathTimer = 0.45, this.velocity = { x: 0, y: 0 });
+  }
+  triggerSliceDeath(t) {
+    this.isDying || (this.isDying = !0, this.deathType = "sliced", this.deathTimer = 0, this.maxDeathTimer = 0.35, this.sliceAngle = t, this.velocity = { x: 0, y: 0 });
+  }
+  update(t) {
+    if (this.active) {
+      if (this.isDying) {
+        this.deathTimer += t, this.deathTimer >= this.maxDeathTimer && (this.active = !1, this.isDying = !1);
+        return;
+      }
+      this.isGrabbed || (this.position.x += this.velocity.x * t, this.position.y += this.velocity.y * t, (this.velocity.x !== 0 || this.velocity.y !== 0) && (this.rotation = Math.atan2(this.velocity.y, this.velocity.x)));
+    }
+  }
+  reset() {
+    this.active = !1, this.isGrabbed = !1, this.isThrown = !1, this.wasManipulated = !1, this.isDying = !1, this.deathType = "none", this.deathTimer = 0, this.sliceAngle = 0, this.position = { x: 0, y: 0 }, this.velocity = { x: 0, y: 0 }, this.rotation = 0, this.strategy = null;
+  }
+}
+class H {
+  pointerPosition = { x: 0, y: 0 };
+  isPointerDown = !1;
+  grabbedEnemy = null;
+  dragStart = null;
+  pointerHistory = [];
+  canvas;
+  constructor(t) {
+    this.canvas = t, this.bindEvents();
+  }
+  updatePointerPos(t, i) {
+    const e = this.canvas.getBoundingClientRect(), s = performance.now() / 1e3;
+    this.pointerPosition = {
+      x: t - e.left,
+      y: i - e.top
+    }, this.pointerHistory.push({
+      x: this.pointerPosition.x,
+      y: this.pointerPosition.y,
+      time: s
+    });
+    const a = s - 0.08;
+    this.pointerHistory = this.pointerHistory.filter((c) => c.time >= a), this.grabbedEnemy && (this.grabbedEnemy.position = { ...this.pointerPosition });
+  }
+  bindEvents() {
+    this.canvas.addEventListener("mousemove", (t) => {
+      this.updatePointerPos(t.clientX, t.clientY);
+    }), this.canvas.addEventListener("mousedown", (t) => {
+      t.button === 0 && (this.isPointerDown = !0, this.pointerHistory = [], this.updatePointerPos(t.clientX, t.clientY));
+    }), this.canvas.addEventListener("mouseup", (t) => {
+      t.button === 0 && (this.isPointerDown = !1);
+    }), this.canvas.addEventListener("touchstart", (t) => {
+      if (t.touches.length > 0) {
+        const i = t.touches[0];
+        this.isPointerDown = !0, this.pointerHistory = [], this.updatePointerPos(i.clientX, i.clientY);
+      }
+    }, { passive: !0 }), this.canvas.addEventListener("touchmove", (t) => {
+      if (t.touches.length > 0) {
+        const i = t.touches[0];
+        this.updatePointerPos(i.clientX, i.clientY);
+      }
+    }, { passive: !0 }), this.canvas.addEventListener("touchend", () => {
+      this.isPointerDown = !1;
+    }), this.canvas.addEventListener("touchcancel", () => {
+      this.isPointerDown = !1;
+    }), this.canvas.addEventListener("contextmenu", (t) => {
+      t.preventDefault();
+    });
+  }
+  tryGrab(t) {
+    if (this.grabbedEnemy) return this.grabbedEnemy;
+    for (const i of t) {
+      if (!i.active || i.isGrabbed || i.isThrown || i.wasManipulated) continue;
+      const e = this.pointerPosition.x - i.position.x, s = this.pointerPosition.y - i.position.y;
+      if (Math.hypot(e, s) <= i.getHitRadius())
+        return i.isGrabbed = !0, this.grabbedEnemy = i, this.dragStart = { ...this.pointerPosition }, this.pointerHistory = [], i;
+    }
+    return null;
+  }
+  releaseAndThrow() {
+    if (!this.grabbedEnemy) return null;
+    const t = this.grabbedEnemy;
+    t.isGrabbed = !1, t.isThrown = !0, t.wasManipulated = !0;
+    const e = performance.now() / 1e3 - 0.08, s = this.pointerHistory.filter((n) => n.time >= e);
+    let a = 0, c = 0;
+    if (s.length >= 2) {
+      const n = s[0], o = s[s.length - 1], r = Math.max(0.01, o.time - n.time);
+      a = (o.x - n.x) / r, c = (o.y - n.y) / r;
+    }
+    const h = Math.hypot(a, c);
+    if (h > 30) {
+      const o = Math.min(h * 1.15, 2500), r = Math.atan2(c, a);
+      t.velocity = {
+        x: Math.cos(r) * o,
+        y: Math.sin(r) * o
+      };
+    } else if (this.dragStart) {
+      const n = t.position.x - this.dragStart.x, o = t.position.y - this.dragStart.y, r = Math.hypot(n, o);
+      if (r > 5) {
+        const l = Math.atan2(o, n), p = Math.min(r * 4, 600);
+        t.velocity = {
+          x: Math.cos(l) * p,
+          y: Math.sin(l) * p
+        };
+      } else
+        t.velocity = { x: 0, y: 0 }, t.isThrown = !1;
+    }
+    return this.grabbedEnemy = null, this.dragStart = null, this.pointerHistory = [], t;
+  }
+  reset() {
+    this.grabbedEnemy = null, this.dragStart = null, this.pointerHistory = [], this.isPointerDown = !1;
+  }
+}
+class K {
+  cellSize;
+  grid = /* @__PURE__ */ new Map();
+  constructor(t = 100) {
+    this.cellSize = t;
+  }
+  clear() {
+    this.grid.clear();
+  }
+  insert(t) {
+    const i = Math.floor((t.position.x - t.radius) / this.cellSize), e = Math.floor((t.position.x + t.radius) / this.cellSize), s = Math.floor((t.position.y - t.radius) / this.cellSize), a = Math.floor((t.position.y + t.radius) / this.cellSize);
+    for (let c = i; c <= e; c++)
+      for (let h = s; h <= a; h++) {
+        const n = `${c}:${h}`;
+        this.grid.has(n) || this.grid.set(n, /* @__PURE__ */ new Set()), this.grid.get(n).add(t);
+      }
+  }
+  getNearby(t, i) {
+    const e = /* @__PURE__ */ new Set(), s = Math.floor((t.x - i) / this.cellSize), a = Math.floor((t.x + i) / this.cellSize), c = Math.floor((t.y - i) / this.cellSize), h = Math.floor((t.y + i) / this.cellSize);
+    for (let n = s; n <= a; n++)
+      for (let o = c; o <= h; o++) {
+        const r = `${n}:${o}`, l = this.grid.get(r);
+        l && l.forEach((p) => e.add(p));
+      }
+    return e;
+  }
+}
+class F {
+  hitstopTime = 0;
+  shakeTime = 0;
+  shakeDuration = 0.14;
+  shakeIntensity = 0;
+  shakeVector = { x: 0, y: 0 };
+  flashAlpha = 0;
+  triggerHitstop(t = 0.06) {
+    this.hitstopTime = t;
+  }
+  triggerFlash(t = 0.4) {
+    this.flashAlpha = t;
+  }
+  triggerScreenShake(t, i = 1) {
+    const s = 10 + Math.min(i * 3, 30), a = Math.hypot(t.x, t.y) || 1;
+    this.shakeVector = {
+      x: t.x / a * s,
+      y: t.y / a * s
+    }, this.shakeIntensity = s, this.shakeTime = this.shakeDuration;
+  }
+  update(t, i, e) {
+    this.hitstopTime > 0 && (this.hitstopTime -= t), this.shakeTime > 0 && (this.shakeTime -= t), this.flashAlpha > 0 && (this.flashAlpha = Math.max(0, this.flashAlpha - t * 4));
+    for (let s = i.length - 1; s >= 0; s--) {
+      const a = i[s];
+      a && (a.lifetime += t, a.position.x += a.velocity.x * t, a.position.y += a.velocity.y * t, a.alpha = 1 - a.lifetime / a.maxLifetime, a.lifetime >= a.maxLifetime && i.splice(s, 1));
+    }
+    for (let s = e.length - 1; s >= 0; s--) {
+      const a = e[s];
+      a && (a.lifetime += t, a.position.x += a.velocity.x * t, a.position.y += a.velocity.y * t, a.alpha = 1 - a.lifetime / a.maxLifetime, a.lifetime >= a.maxLifetime && e.splice(s, 1));
+    }
+  }
+  getShakeOffset() {
+    if (this.shakeTime <= 0) return { x: 0, y: 0 };
+    const t = this.shakeTime / this.shakeDuration;
+    return {
+      x: (Math.random() * 2 - 1) * this.shakeVector.x * t,
+      y: (Math.random() * 2 - 1) * this.shakeVector.y * t
+    };
+  }
+}
+const I = {
+  es: {
+    title: "AXON SURGE",
+    startButton: "INICIAR ENLACE",
+    waveLabel: "NIVEL",
+    scoreLabel: "PUNTAJE",
+    settingsTitle: "CONFIGURACION",
+    languageLabel: "IDIOMA",
+    themeLabel: "TEMA VISUAL",
+    hapticsLabel: "VIBRACION / HAPTICOS",
+    hapticsOn: "ACTIVADO",
+    hapticsOff: "DESACTIVADO",
+    creditsJam: "Desarrollado para Mini Jam 216: Axon Surge",
+    closeButton: "CERRAR",
+    grabInstruction: "MANTÉN PULSADO PARA AGARRAR UN ENEMIGO",
+    throwInstruction: "ARRASTRA Y SUELTA PARA LANZARLO",
+    comboText: "¡MULTIKILL x{combo}!"
+  },
+  en: {
+    title: "AXON SURGE",
+    startButton: "START LINK",
+    waveLabel: "LEVEL",
+    scoreLabel: "SCORE",
+    settingsTitle: "SETTINGS",
+    languageLabel: "LANGUAGE",
+    themeLabel: "VISUAL THEME",
+    hapticsLabel: "HAPTICS / VIBRATION",
+    hapticsOn: "ENABLED",
+    hapticsOff: "DISABLED",
+    creditsJam: "Developed for Mini Jam 216: Axon Surge",
+    closeButton: "CLOSE",
+    grabInstruction: "HOLD TO GRAB AN ENEMY",
+    throwInstruction: "DRAG AND RELEASE TO THROW",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  fr: {
+    title: "AXON SURGE",
+    startButton: "DEMARRER LE LIEN",
+    waveLabel: "NIVEAU",
+    scoreLabel: "SCORE",
+    settingsTitle: "PARAMETRES",
+    languageLabel: "LANGUE",
+    themeLabel: "THEME VISUEL",
+    hapticsLabel: "RETROACTION HAPTIQUE",
+    hapticsOn: "ACTIVE",
+    hapticsOff: "DESACTIVE",
+    creditsJam: "Développé pour Mini Jam 216: Axon Surge",
+    closeButton: "FERMER",
+    grabInstruction: "MAINTENEZ POUR SAISIR UN ENNEMI",
+    throwInstruction: "GLISSEZ ET RELACHEZ POUR LANCER",
+    comboText: "MULTIKILL x{combo} !"
+  },
+  de: {
+    title: "AXON SURGE",
+    startButton: "LINK STARTEN",
+    waveLabel: "LEVEL",
+    scoreLabel: "PUNKTE",
+    settingsTitle: "EINSTELLUNGEN",
+    languageLabel: "SPRACHE",
+    themeLabel: "VISUELLES THEMA",
+    hapticsLabel: "HAPTISCHES FEEDBACK",
+    hapticsOn: "AKTIVIERT",
+    hapticsOff: "DEAKTIVIERT",
+    creditsJam: "Entwickelt für Mini Jam 216: Axon Surge",
+    closeButton: "SCHLIESSEN",
+    grabInstruction: "GEDRÜCKT HALTEN ZUM GREIFEN",
+    throwInstruction: "ZIEHEN UND LOSLASSEN ZUM WERFEN",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  it: {
+    title: "AXON SURGE",
+    startButton: "AVVIA COLLEGAMENTO",
+    waveLabel: "LIVELLO",
+    scoreLabel: "PUNTEGGIO",
+    settingsTitle: "IMPOSTAZIONI",
+    languageLabel: "LINGUA",
+    themeLabel: "TEMA VISIVO",
+    hapticsLabel: "FEEDBACK TATTILE",
+    hapticsOn: "ATTIVATO",
+    hapticsOff: "DISATTIVATO",
+    creditsJam: "Sviluppato per Mini Jam 216: Axon Surge",
+    closeButton: "CHIUDI",
+    grabInstruction: "TIENI PREMUTO PER AFFERRARE UN NEMICO",
+    throwInstruction: "TRASCINA E RILASCIA PER LANCIARE",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  pt: {
+    title: "AXON SURGE",
+    startButton: "INICIAR CONEXÃO",
+    waveLabel: "NÍVEL",
+    scoreLabel: "PONTUAÇÃO",
+    settingsTitle: "CONFIGURAÇÕES",
+    languageLabel: "IDIOMA",
+    themeLabel: "TEMA VISUAL",
+    hapticsLabel: "RESPOSTA TÁTIL",
+    hapticsOn: "ATIVADO",
+    hapticsOff: "DESATIVADO",
+    creditsJam: "Desenvolvido para Mini Jam 216: Axon Surge",
+    closeButton: "FECHAR",
+    grabInstruction: "SEGURE PARA AGARRAR UM INIMIGO",
+    throwInstruction: "ARRASTE E SOLTE PARA LANÇAR",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  nl: {
+    title: "AXON SURGE",
+    startButton: "VERBINDING STARTEN",
+    waveLabel: "NIVEAU",
+    scoreLabel: "SCORE",
+    settingsTitle: "INSTELLINGEN",
+    languageLabel: "TAAL",
+    themeLabel: "VISUEEL THEMA",
+    hapticsLabel: "HAPTISCHE FEEDBACK",
+    hapticsOn: "INGESCHAKELD",
+    hapticsOff: "UITGESCHAKELD",
+    creditsJam: "Ontwikkeld voor Mini Jam 216: Axon Surge",
+    closeButton: "SLUITEN",
+    grabInstruction: "HOUD INGEDRUKT OM EEN VIJAND TE PAKKEN",
+    throwInstruction: "SLEEP EN LAAT LOS OM TE GOOIEN",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  sv: {
+    title: "AXON SURGE",
+    startButton: "STARTA LÄNK",
+    waveLabel: "NIVÅ",
+    scoreLabel: "POÄNG",
+    settingsTitle: "INSTÄLLNINGAR",
+    languageLabel: "SPRÅK",
+    themeLabel: "VISUELLT TEMA",
+    hapticsLabel: "HAPTISK FEEDBACK",
+    hapticsOn: "AKTIVERAD",
+    hapticsOff: "INAKTIVERAD",
+    creditsJam: "Utvecklat för Mini Jam 216: Axon Surge",
+    closeButton: "STÄNG",
+    grabInstruction: "HÅLL INNE FÖR ATT GREPPA EN FIENDE",
+    throwInstruction: "DRA OCH SLÄPP FÖR ATT KASTA",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  pl: {
+    title: "AXON SURGE",
+    startButton: "ROZPOCZNIJ POŁĄCZENIE",
+    waveLabel: "POZIOM",
+    scoreLabel: "WYNIK",
+    settingsTitle: "USTAWIENIA",
+    languageLabel: "JĘZYK",
+    themeLabel: "MOTYW WIZUALNY",
+    hapticsLabel: "WIBRACJE HAPTYCZNE",
+    hapticsOn: "WŁĄCZONE",
+    hapticsOff: "WYŁĄCZONE",
+    creditsJam: "Stworzono dla Mini Jam 216: Axon Surge",
+    closeButton: "ZAMKNIJ",
+    grabInstruction: "PRZYTRZYMAJ, ABY CHWYCIĆ WROGA",
+    throwInstruction: "PRZECIĄGNIJ I PUŚĆ, ABY RZUCIĆ",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  id: {
+    title: "AXON SURGE",
+    startButton: "MULAILAH KONEKSI",
+    waveLabel: "TINGKAT",
+    scoreLabel: "SKOR",
+    settingsTitle: "PENGATURAN",
+    languageLabel: "BAHASA",
+    themeLabel: "TEMA VISUAL",
+    hapticsLabel: "UUMPAN BALIK HAPTIK",
+    hapticsOn: "AKTIF",
+    hapticsOff: "NONAKTIF",
+    creditsJam: "Dibuat untuk Mini Jam 216: Axon Surge",
+    closeButton: "TUTUP",
+    grabInstruction: "TAHAN UNTUK MEMEGANG MUSUH",
+    throwInstruction: "GESER DAN LEPAS UNTUK MELEMPAR",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  tr: {
+    title: "AXON SURGE",
+    startButton: "BAĞLANTIYI BAŞLAT",
+    waveLabel: "SEVİYE",
+    scoreLabel: "SKOR",
+    settingsTitle: "AYARLAR",
+    languageLabel: "DİL",
+    themeLabel: "GÖRSEL TEMA",
+    hapticsLabel: "TİTREŞİM BİLDİRİMİ",
+    hapticsOn: "AÇIK",
+    hapticsOff: "KAPALI",
+    creditsJam: "Mini Jam 216 için geliştirildi: Axon Surge",
+    closeButton: "KAPAT",
+    grabInstruction: "DÜŞMANI YAKALAMAK İÇİN BASILI TUTUN",
+    throwInstruction: "FIRLATMAK İÇİN SÜRÜKLEYİP BIRAKIN",
+    comboText: "MULTIKILL x{combo}!"
+  },
+  ru: {
+    title: "AXON SURGE",
+    startButton: "НАЧАТЬ СВЯЗЬ",
+    waveLabel: "УРОВЕНЬ",
+    scoreLabel: "СЧЕТ",
+    settingsTitle: "НАСТРОЙКИ",
+    languageLabel: "ЯЗЫК",
+    themeLabel: "ВИЗУАЛЬНАЯ ТЕМА",
+    hapticsLabel: "ТАКТИЛЬНЫЙ ОТКЛИК",
+    hapticsOn: "ВКЛЮЧЕНО",
+    hapticsOff: "ВЫКЛЮЧЕНО",
+    creditsJam: "Разработано для Mini Jam 216: Axon Surge",
+    closeButton: "ЗАКРЫТЬ",
+    grabInstruction: "УДЕРЖИВАЙТЕ, ЧТОБЫ СХВАТИТЬ ВРАГА",
+    throwInstruction: "ПЕРЕТАЩИТЕ И ОТПУСТИТЕ ДЛЯ БРОСКА",
+    comboText: "МУЛЬТИКИЛЛ x{combo}!"
+  },
+  ja: {
+    title: "AXON SURGE",
+    startButton: "リンク開始",
+    waveLabel: "レベル",
+    scoreLabel: "スコア",
+    settingsTitle: "設定",
+    languageLabel: "言語",
+    themeLabel: "ビジュアルテーマ",
+    hapticsLabel: "振動フィードバック",
+    hapticsOn: "有効",
+    hapticsOff: "無効",
+    creditsJam: "Mini Jam 216用に開発: Axon Surge",
+    closeButton: "閉じる",
+    grabInstruction: "長押しで敵をキャッチ",
+    throwInstruction: "ドラッグ＆リリースで投げる",
+    comboText: "マルチキル x{combo}!"
+  },
+  ko: {
+    title: "AXON SURGE",
+    startButton: "링크 시작",
+    waveLabel: "레벨",
+    scoreLabel: "점수",
+    settingsTitle: "설정",
+    languageLabel: "언어",
+    themeLabel: "비주얼 테마",
+    hapticsLabel: "진동 피드백",
+    hapticsOn: "켜짐",
+    hapticsOff: "꺼짐",
+    creditsJam: "Mini Jam 216 전용 개발: Axon Surge",
+    closeButton: "닫기",
+    grabInstruction: "길게 눌러 적 잡기",
+    throwInstruction: "드래그 후 놓아서 던지기",
+    comboText: "멀티킬 x{combo}!"
+  },
+  zh: {
+    title: "AXON SURGE",
+    startButton: "启动链接",
+    waveLabel: "等级",
+    scoreLabel: "得分",
+    settingsTitle: "设置",
+    languageLabel: "语言",
+    themeLabel: "视觉主题",
+    hapticsLabel: "触觉反馈",
+    hapticsOn: "已启用",
+    hapticsOff: "已禁用",
+    creditsJam: "为 Mini Jam 216 开发: Axon Surge",
+    closeButton: "关闭",
+    grabInstruction: "按住以抓住敌人",
+    throwInstruction: "拖动并释放以抛投",
+    comboText: "多重击杀 x{combo}!"
+  }
+}, k = [
+  "es",
+  "en",
+  "fr",
+  "de",
+  "it",
+  "pt",
+  "nl",
+  "sv",
+  "pl",
+  "id",
+  "tr",
+  "ru",
+  "ja",
+  "ko",
+  "zh"
+];
+function V(x) {
+  return k.includes(x);
+}
+const N = "axon_surge_language";
+class J {
+  currentLanguage;
+  constructor(t) {
+    if (t && I[t])
+      this.currentLanguage = t;
+    else {
+      let i = "es";
+      try {
+        const e = localStorage.getItem(N);
+        e && V(e) && (i = e);
+      } catch {
+      }
+      this.currentLanguage = i;
+    }
+  }
+  setLanguage(t) {
+    if (I[t]) {
+      this.currentLanguage = t;
+      try {
+        localStorage.setItem(N, t);
+      } catch {
+      }
+    }
+  }
+  getLanguage() {
+    return this.currentLanguage;
+  }
+  translate(t, i) {
+    let s = (I[this.currentLanguage] || I.es)[t] || I.es[t] || String(t);
+    return i && Object.entries(i).forEach(([a, c]) => {
+      s = s.replace(`{${a}}`, String(c));
+    }), s;
+  }
+}
+class Y {
+  execute(t) {
+    const { thrownEnemy: i, targetEnemy: e, shockwaves: s, particles: a, floatingTexts: c } = t;
+    e.active = !1, s.push({
+      id: Math.random().toString(),
+      position: { ...e.position },
+      radius: 10,
+      maxRadius: 180,
+      color: "#ff2a5f",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 0.5
+    });
+    for (let h = 0; h < 30; h++) {
+      const n = Math.random() * Math.PI * 2, o = 180 + Math.random() * 320;
+      a.push({
+        id: Math.random().toString(),
+        position: { ...e.position },
+        velocity: { x: Math.cos(n) * o, y: Math.sin(n) * o },
+        color: "#ff2a5f",
+        radius: 3 + Math.random() * 4,
+        alpha: 1,
+        lifetime: 0,
+        maxLifetime: 0.5
+      });
+    }
+    c.push({
+      id: Math.random().toString(),
+      text: "PIERCING SLICE",
+      position: { ...e.position },
+      velocity: { x: 0, y: -50 },
+      color: "#ff2a5f",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 0.8,
+      size: 20
+    });
+  }
+}
+class W {
+  execute(t) {
+    const { thrownEnemy: i, pools: e, shockwaves: s, particles: a, floatingTexts: c, eventBus: h } = t, n = i.position;
+    e.push({
+      id: Math.random().toString(),
+      position: { ...n },
+      radius: 220,
+      duration: 0,
+      maxDuration: 7,
+      damage: 50
+    }), s.push({
+      id: Math.random().toString(),
+      position: { ...n },
+      radius: 10,
+      maxRadius: 240,
+      color: "#39ff14",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 0.6
+    });
+    for (let o = 0; o < 45; o++) {
+      const r = Math.random() * Math.PI * 2, l = 120 + Math.random() * 260;
+      a.push({
+        id: Math.random().toString(),
+        position: { ...n },
+        velocity: { x: Math.cos(r) * l, y: Math.sin(r) * l },
+        color: "#39ff14",
+        radius: 4 + Math.random() * 5,
+        alpha: 1,
+        lifetime: 0,
+        maxLifetime: 0.9
+      });
+    }
+    c.push({
+      id: Math.random().toString(),
+      text: "MASSIVE SPORE NEBULA",
+      position: { ...n },
+      velocity: { x: 0, y: -60 },
+      color: "#39ff14",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 1.2,
+      size: 26
+    }), i.active = !1, h.emit("onPoolCreated", { position: n });
+  }
+}
+class X {
+  execute(t) {
+    const { thrownEnemy: i, targetEnemy: e, allEnemies: s, shockwaves: a, particles: c, floatingTexts: h } = t, n = e.position;
+    i.active = !1, e.active = !1, a.push({
+      id: Math.random().toString(),
+      position: { ...n },
+      radius: 15,
+      maxRadius: 280,
+      color: "#ffd700",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 0.6
+    });
+    for (let o = 0; o < 6; o++) {
+      const r = o * Math.PI * 2 / 6, l = {
+        x: n.x + Math.cos(r) * 15,
+        y: n.y + Math.sin(r) * 15
+      }, p = L.createEnemy("micro", l, {
+        x: l.x + Math.cos(r) * 200,
+        y: l.y + Math.sin(r) * 200
+      });
+      p.isThrown = !0, s.push(p);
+    }
+    for (let o = 0; o < 35; o++) {
+      const r = Math.random() * Math.PI * 2, l = 200 + Math.random() * 300;
+      c.push({
+        id: Math.random().toString(),
+        position: { ...n },
+        velocity: { x: Math.cos(r) * l, y: Math.sin(r) * l },
+        color: "#ffd700",
+        radius: 4 + Math.random() * 4,
+        alpha: 1,
+        lifetime: 0,
+        maxLifetime: 0.6
+      });
+    }
+    h.push({
+      id: Math.random().toString(),
+      text: "CLUSTER DETONATION",
+      position: { ...n },
+      velocity: { x: 0, y: -60 },
+      color: "#ffd700",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 1,
+      size: 24
+    });
+  }
+}
+class $ {
+  execute(t) {
+    const { thrownEnemy: i, targetEnemy: e, vortices: s, shockwaves: a } = t, c = {
+      x: (i.position.x + e.position.x) / 2,
+      y: (i.position.y + e.position.y) / 2
+    };
+    s.push({
+      id: Math.random().toString(),
+      position: c,
+      radius: 480,
+      duration: 0,
+      maxDuration: 6,
+      pullForce: 3500
+    }), a.push({
+      id: Math.random().toString(),
+      position: c,
+      radius: 20,
+      maxRadius: 480,
+      color: "#9d4edd",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 0.65
+    }), i.triggerDissolveDeath(), e.triggerDissolveDeath();
+  }
+}
+class L {
+  static createEnemy(t, i, e) {
+    const s = `enemy_${Date.now()}_${Math.random()}`, a = new P(s);
+    return this.configureEnemy(a, t, i, e), a;
+  }
+  static configureEnemy(t, i, e, s) {
+    t.type = i, t.position = { ...e }, t.active = !0, t.isGrabbed = !1, t.isThrown = !1;
+    const a = s.x - e.x, c = s.y - e.y, h = Math.atan2(c, a);
+    let n = 70, o = 20, r = "#ff2a5f", l = null;
+    i === "piercer" ? (n = 95, o = 18, r = "#ff2a5f", l = new Y()) : i === "spore" ? (n = 65, o = 24, r = "#39ff14", l = new W()) : i === "cluster" ? (n = 50, o = 26, r = "#ffd700", l = new X()) : i === "parasite" ? (n = 80, o = 22, r = "#9d4edd", l = new $()) : i === "micro" && (n = 130, o = 12, r = "#ffd700"), t.radius = o, t.color = r, t.strategy = l, t.velocity = {
+      x: Math.cos(h) * n,
+      y: Math.sin(h) * n
+    };
+  }
+}
+class z {
+  spatialHash;
+  eventBus;
+  i18n;
+  currentThrowKills = 0;
+  currentThrowPos = null;
+  constructor(t, i) {
+    this.spatialHash = new K(100), this.eventBus = t, this.i18n = i;
+  }
+  update(t, i, e, s, a, c, h, n, o, r, l, p, f, g) {
+    this.spatialHash.clear();
+    for (const d of e)
+      d.active && !d.isDying ? (d.update(t), this.spatialHash.insert(d)) : d.active && d.isDying && d.update(t);
+    for (let d = c.length - 1; d >= 0; d--) {
+      const m = c[d];
+      if (!m) continue;
+      m.lifetime += t;
+      const u = m.lifetime / m.maxLifetime;
+      m.radius = m.maxRadius * u, m.alpha = Math.max(0, 1 - u), m.lifetime >= m.maxLifetime && c.splice(d, 1);
+    }
+    for (let d = a.length - 1; d >= 0; d--) {
+      const m = a[d];
+      if (m) {
+        m.duration += t;
+        for (const u of e) {
+          if (!u.active || u.isGrabbed || u.isDying || u.isThrown && u.type === "piercer") continue;
+          const y = m.position.x - u.position.x, v = m.position.y - u.position.y, S = Math.hypot(y, v);
+          if (S > 2 && S <= m.radius) {
+            const T = Math.pow(1 - S / m.radius, 0.7), M = m.pullForce * T, E = Math.atan2(v, y);
+            u.velocity.x += Math.cos(E) * M * t, u.velocity.y += Math.sin(E) * M * t, u.position.x += Math.cos(E) * M * t * 0.8, u.position.y += Math.sin(E) * M * t * 0.8;
+          }
+        }
+        m.duration >= m.maxDuration && a.splice(d, 1);
+      }
+    }
+    for (const d of e) {
+      if (!d.active || d.isGrabbed || d.isDying) continue;
+      const m = i.position.x - d.position.x, u = i.position.y - d.position.y;
+      if (Math.hypot(m, u) <= i.radius + d.radius) {
+        d.active = !1;
+        const v = i.takeDamage();
+        this.eventBus.emit("onCoreDamaged", { currentIntegrity: i.integrity }), c.push({
+          id: Math.random().toString(),
+          position: { ...i.position },
+          radius: 20,
+          maxRadius: Math.max(p, f) * 1.3,
+          color: "#00f0ff",
+          alpha: 1,
+          lifetime: 0,
+          maxLifetime: 0.8
+        }), o.triggerScreenShake({ x: m, y: u }, 25), o.triggerHitstop(0.15), o.triggerFlash(0.6);
+        for (const S of e)
+          if (S.active && !S.isGrabbed) {
+            S.triggerDissolveDeath();
+            for (let T = 0; T < 8; T++) {
+              const M = Math.random() * Math.PI * 2, E = 100 + Math.random() * 200;
+              h.push({
+                id: Math.random().toString(),
+                position: { ...S.position },
+                velocity: { x: Math.cos(M) * E, y: Math.sin(M) * E },
+                color: "#00f0ff",
+                radius: 3 + Math.random() * 3,
+                alpha: 1,
+                lifetime: 0,
+                maxLifetime: 0.5
+              });
+            }
+          }
+        n.push({
+          id: Math.random().toString(),
+          text: "CORE OVERLOAD PULSE!",
+          position: { ...i.position },
+          velocity: { x: 0, y: -90 },
+          color: "#00f0ff",
+          alpha: 1,
+          lifetime: 0,
+          maxLifetime: 1.5,
+          size: 32
+        }), (!v || i.integrity <= 0) && this.eventBus.emit("onGameOver", { score: l.value, wave: 1 });
+        break;
+      }
+    }
+    let b = !1;
+    for (const d of e) {
+      if (!d.active || !d.isThrown || d.isDying) continue;
+      if (b = !0, d.position.x < -120 || d.position.x > p + 120 || d.position.y < -120 || d.position.y > f + 120) {
+        d.active = !1, d.isThrown = !1;
+        continue;
+      }
+      const m = this.spatialHash.getNearby(d.position, d.getHitRadius() * 2);
+      for (const u of m) {
+        if (u === d || !u.active || u.isGrabbed || u.isDying) continue;
+        const y = u.position.x - d.position.x, v = u.position.y - d.position.y;
+        if (Math.hypot(y, v) <= d.getHitRadius() + u.getHitRadius()) {
+          this.currentThrowPos = { x: d.position.x, y: d.position.y };
+          const T = Math.atan2(d.velocity.y, d.velocity.x);
+          if (d.type === "piercer") {
+            this.currentThrowKills++, this.killEnemyWithChainReaction(u, T, s, a, c, h, e), o.triggerHitstop(0.05), o.triggerScreenShake({ x: y, y: v }, 7), c.push({
+              id: Math.random().toString(),
+              position: { ...u.position },
+              radius: 10,
+              maxRadius: 180,
+              color: "#ff2a5f",
+              alpha: 1,
+              lifetime: 0,
+              maxLifetime: 0.45
+            });
+            for (let M = 0; M < 16; M++) {
+              const E = Math.random() * Math.PI * 2, w = 150 + Math.random() * 300;
+              h.push({
+                id: Math.random().toString(),
+                position: { ...u.position },
+                velocity: { x: Math.cos(E) * w, y: Math.sin(E) * w },
+                color: "#ff2a5f",
+                radius: 3 + Math.random() * 3,
+                alpha: 1,
+                lifetime: 0,
+                maxLifetime: 0.4
+              });
+            }
+            g && g();
+          } else {
+            const M = d.type === u.type;
+            c.push({
+              id: Math.random().toString(),
+              position: { ...this.currentThrowPos },
+              radius: 15,
+              maxRadius: M ? 350 : 220,
+              color: d.color,
+              alpha: 1,
+              lifetime: 0,
+              maxLifetime: 0.55
+            });
+            for (let E = 0; E < 36; E++) {
+              const w = Math.random() * Math.PI * 2, R = 180 + Math.random() * 400;
+              h.push({
+                id: Math.random().toString(),
+                position: { ...this.currentThrowPos },
+                velocity: { x: Math.cos(w) * R, y: Math.sin(w) * R },
+                color: d.color,
+                radius: 4 + Math.random() * 5,
+                alpha: 1,
+                lifetime: 0,
+                maxLifetime: 0.65
+              });
+            }
+            M ? (this.currentThrowKills += 3, o.triggerHitstop(0.12), o.triggerFlash(0.5), o.triggerScreenShake({ x: y, y: v }, 14), n.push({
+              id: Math.random().toString(),
+              text: "COLOR SYNERGY!",
+              position: { ...this.currentThrowPos },
+              velocity: { x: 0, y: -80 },
+              color: d.color,
+              alpha: 1,
+              lifetime: 0,
+              maxLifetime: 1.2,
+              size: 26
+            }), d.type === "spore" ? (s.push({
+              id: Math.random().toString(),
+              position: { ...this.currentThrowPos },
+              radius: 320,
+              duration: 0,
+              maxDuration: 10,
+              damage: 100
+            }), d.triggerDissolveDeath(), u.triggerDissolveDeath()) : d.type === "parasite" ? (a.push({
+              id: Math.random().toString(),
+              position: { ...this.currentThrowPos },
+              radius: 580,
+              duration: 0,
+              maxDuration: 7,
+              pullForce: 4500
+            }), d.triggerDissolveDeath(), u.triggerDissolveDeath()) : (d.triggerDissolveDeath(), u.triggerDissolveDeath())) : (this.currentThrowKills += 2, o.triggerHitstop(0.08), o.triggerFlash(0.35), o.triggerScreenShake({ x: y, y: v }, 8), this.killEnemyWithChainReaction(d, T, s, a, c, h, e), this.killEnemyWithChainReaction(u, T, s, a, c, h, e)), g && g();
+            break;
+          }
+        }
+      }
+    }
+    r.value = this.currentThrowKills, !b && this.currentThrowKills > 0 && (this.currentThrowKills >= 2 && this.currentThrowPos && n.push({
+      id: Math.random().toString(),
+      text: `MULTIKILL x${this.currentThrowKills}!`,
+      position: { ...this.currentThrowPos },
+      velocity: { x: 0, y: -90 },
+      color: "#ff00dd",
+      alpha: 1,
+      lifetime: 0,
+      maxLifetime: 1.4,
+      size: 32
+    }), this.eventBus.emit("onComboUpdated", { combo: r.value }), this.currentThrowKills = 0, this.currentThrowPos = null);
+    for (let d = s.length - 1; d >= 0; d--) {
+      const m = s[d];
+      if (m) {
+        m.duration += t;
+        for (const u of e) {
+          if (!u.active || u.isGrabbed || u.isDying || u.isThrown && u.type === "piercer") continue;
+          const y = u.position.x - m.position.x, v = u.position.y - m.position.y;
+          Math.hypot(y, v) <= m.radius && (this.killEnemyWithChainReaction(u, 0, s, a, c, h, e), this.currentThrowKills++, g && g());
+        }
+        m.duration >= m.maxDuration && s.splice(d, 1);
+      }
+    }
+  }
+  killEnemyWithChainReaction(t, i, e, s, a, c, h) {
+    if (!(!t.active || t.isDying))
+      if (a.push({
+        id: Math.random().toString(),
+        position: { ...t.position },
+        radius: 10,
+        maxRadius: 180,
+        color: t.color,
+        alpha: 1,
+        lifetime: 0,
+        maxLifetime: 0.5
+      }), t.type === "spore")
+        t.triggerDissolveDeath(), e.push({
+          id: Math.random().toString(),
+          position: { ...t.position },
+          radius: 200,
+          duration: 0,
+          maxDuration: 6,
+          damage: 50
+        });
+      else if (t.type === "cluster") {
+        t.triggerDissolveDeath();
+        for (let n = 0; n < 6; n++) {
+          const o = n * Math.PI * 2 / 6, r = {
+            x: t.position.x + Math.cos(o) * 15,
+            y: t.position.y + Math.sin(o) * 15
+          }, l = L.createEnemy("micro", r, {
+            x: r.x + Math.cos(o) * 200,
+            y: r.y + Math.sin(o) * 200
+          });
+          l.isThrown = !0, h.push(l);
+        }
+      } else t.type === "parasite" ? (t.triggerDissolveDeath(), s.push({
+        id: Math.random().toString(),
+        position: { ...t.position },
+        radius: 450,
+        duration: 0,
+        maxDuration: 5,
+        pullForce: 3e3
+      })) : t.type === "piercer" ? t.triggerSliceDeath(i) : t.triggerDissolveDeath();
+  }
+}
+class Z {
+  pool = [];
+  constructor(t = 500) {
+    for (let i = 0; i < t; i++) {
+      const e = new P(`pool_enemy_${i}`);
+      this.pool.push(e);
+    }
+  }
+  get() {
+    for (const i of this.pool)
+      if (!i.active)
+        return i.reset(), i;
+    const t = new P(`fallback_enemy_${Date.now()}_${Math.random()}`);
+    return this.pool.push(t), t;
+  }
+  resetAll() {
+    for (const t of this.pool)
+      t.reset();
+  }
+}
+class A {
+  static getOffscreenPosition(t, i) {
+    const e = Math.floor(Math.random() * 4), s = 70;
+    return e === 0 ? { x: Math.random() * t, y: -s } : e === 1 ? { x: t + s, y: Math.random() * i } : e === 2 ? { x: Math.random() * t, y: i + s } : { x: -s, y: Math.random() * i };
+  }
+  static spawnCircleOfDeath(t, i, e, s) {
+    const a = [], h = Math.max(e, s) * 0.55 + 80;
+    for (let n = 0; n < 18; n++) {
+      const o = n * Math.PI * 2 / 18, r = {
+        x: i.x + Math.cos(o) * h,
+        y: i.y + Math.sin(o) * h
+      }, l = t.get(), p = ["piercer", "spore", "cluster", "parasite"], f = p[n % p.length];
+      L.configureEnemy(l, f, r, i), l.velocity = {
+        x: Math.cos(o + Math.PI) * 55,
+        y: Math.sin(o + Math.PI) * 55
+      }, a.push(l);
+    }
+    return a;
+  }
+  static spawnDenseCluster(t, i, e, s) {
+    const a = [], h = Math.floor(Math.random() * 4);
+    let n = { x: -60, y: -60 };
+    h === 0 ? n = { x: Math.random() * i, y: -80 } : h === 1 ? n = { x: i + 80, y: Math.random() * e } : h === 2 ? n = { x: Math.random() * i, y: e + 80 } : n = { x: -80, y: Math.random() * e };
+    for (let o = 0; o < 14; o++) {
+      const r = {
+        x: (Math.random() - 0.5) * 60,
+        y: (Math.random() - 0.5) * 60
+      }, l = { x: n.x + r.x, y: n.y + r.y }, p = t.get();
+      L.configureEnemy(p, "spore", l, s);
+      const f = s.x - l.x, g = s.y - l.y, b = Math.atan2(g, f);
+      p.velocity = {
+        x: Math.cos(b) * (50 + Math.random() * 20),
+        y: Math.sin(b) * (50 + Math.random() * 20)
+      }, a.push(p);
+    }
+    return a;
+  }
+  static spawnSineSnake(t, i, e, s) {
+    const a = [], h = e * 0.2 + Math.random() * e * 0.6;
+    for (let n = 0; n < 12; n++) {
+      const o = {
+        x: -60 - n * 40,
+        y: h + Math.sin(n * 0.45) * 70
+      }, r = t.get();
+      L.configureEnemy(r, "cluster", o, s), r.velocity = { x: 75, y: Math.cos(n * 0.45) * 30 }, a.push(r);
+    }
+    return a;
+  }
+  static spawnDoubleSpiral(t, i, e, s) {
+    const a = [];
+    for (let h = 0; h < 14; h++) {
+      const n = h / 14, o = n * Math.PI * 4, r = 120 + n * 450, l = {
+        x: i + Math.cos(o) * r,
+        y: -60 + Math.sin(o) * r
+      }, p = t.get();
+      L.configureEnemy(p, "parasite", l, s), a.push(p);
+    }
+    return a;
+  }
+  static spawnMarchingWall(t, i, e, s) {
+    const a = [], h = Math.random() > 0.5;
+    for (let n = 0; n < 12; n++) {
+      const o = n / 11 * e, r = {
+        x: h ? -60 : i + 60,
+        y: o
+      }, l = t.get();
+      L.configureEnemy(l, "piercer", r, s), l.velocity = {
+        x: h ? 70 : -70,
+        y: 0
+      }, a.push(l);
+    }
+    return a;
+  }
+  static spawnCrossfireStreams(t, i, e, s) {
+    const a = [];
+    for (let h = 0; h < 10; h++) {
+      const n = { x: -50 - h * 35, y: -50 - h * 35 }, o = t.get();
+      L.configureEnemy(o, "spore", n, s), a.push(o);
+      const r = { x: i + 50 + h * 35, y: e + 50 + h * 35 }, l = t.get();
+      L.configureEnemy(l, "cluster", r, s), a.push(l);
+    }
+    return a;
+  }
+}
+class _ {
+  wave = 1;
+  pool;
+  spawnTimer = 0;
+  waveTimer = 0;
+  patternCooldown = 0;
+  initialGracePeriod = 25;
+  constructor() {
+    this.pool = new Z(500);
+  }
+  reset() {
+    this.wave = 1, this.spawnTimer = 0, this.waveTimer = 0, this.patternCooldown = 0;
+  }
+  update(t, i, e, s, a) {
+    this.waveTimer += t, this.spawnTimer += t, this.patternCooldown += t, this.applyFlockingBehaviors(i, t, a);
+    const c = Math.max(1.1, 4.2 - (this.wave - 1) * 0.25);
+    if (this.waveTimer > this.initialGracePeriod && this.patternCooldown > Math.max(16 - this.wave, 8) && i.length < 35) {
+      this.patternCooldown = 0;
+      const n = this.spawnPatternFormation(e, s, a);
+      for (const o of n)
+        i.push(o);
+    }
+    const h = Math.min(18 + this.wave * 4, 80);
+    return this.spawnTimer >= c && i.length < h ? (this.spawnTimer = 0, this.spawnSingleEnemy(e, s, a)) : null;
+  }
+  spawnSingleEnemy(t, i, e) {
+    const s = A.getOffscreenPosition(t, i), a = Math.random();
+    let c = "piercer";
+    a > 0.75 ? c = "parasite" : a > 0.5 ? c = "cluster" : a > 0.25 && (c = "spore");
+    const h = this.pool.get();
+    return L.configureEnemy(h, c, s, e), h;
+  }
+  spawnPatternFormation(t, i, e) {
+    const s = Math.random();
+    return s < 0.25 ? A.spawnCircleOfDeath(this.pool, e, t, i) : s < 0.5 ? A.spawnDenseCluster(this.pool, t, i, e) : s < 0.75 ? A.spawnSineSnake(this.pool, t, i, e) : A.spawnMarchingWall(this.pool, t, i, e);
+  }
+  applyFlockingBehaviors(t, i, e) {
+    for (let a = 0; a < t.length; a++) {
+      const c = t[a];
+      if (!c.active || c.isGrabbed || c.isThrown || c.isDying) continue;
+      let h = 0, n = 0, o = 0;
+      for (let f = 0; f < t.length; f++) {
+        if (a === f) continue;
+        const g = t[f];
+        if (!g.active || g.isGrabbed || g.isDying) continue;
+        const b = c.position.x - g.position.x, d = c.position.y - g.position.y, m = Math.hypot(b, d);
+        m > 0 && m < 70 && (h += b / m, n += d / m, o++);
+      }
+      o > 0 && (h /= o, n /= o, c.velocity.x += h * 60 * i, c.velocity.y += n * 60 * i);
+      const r = e.x - c.position.x, l = e.y - c.position.y, p = Math.hypot(r, l);
+      if (p > 0) {
+        const f = 80 + Math.min(this.wave * 4, 40);
+        c.velocity.x += r / p * f * i, c.velocity.y += l / p * f * i;
+      }
+    }
+  }
+}
+const C = {
+  bioluminescent: {
+    bgInner: "#081220",
+    bgMid: "#050b16",
+    bgOuter: "#020408",
+    nebulaCyan: "rgba(0, 240, 255, 0.08)",
+    nebulaMagenta: "rgba(255, 0, 221, 0.07)",
+    piercerColor: "#ff2a5f",
+    sporeColor: "#39ff14",
+    clusterColor: "#ffd700",
+    parasiteColor: "#9d4edd",
+    microColor: "#ffd700",
+    corePrimary: "#00f0ff",
+    coreGlow: "rgba(0, 240, 255, 0.85)",
+    tendrilMagenta: "#ff00dd",
+    tendrilCyan: "#00ffff"
+  },
+  dark: {
+    bgInner: "#0d0f17",
+    bgMid: "#07080f",
+    bgOuter: "#030407",
+    nebulaCyan: "rgba(0, 180, 216, 0.08)",
+    nebulaMagenta: "rgba(216, 0, 166, 0.07)",
+    piercerColor: "#ef4444",
+    sporeColor: "#10b981",
+    clusterColor: "#f59e0b",
+    parasiteColor: "#8b5cf6",
+    microColor: "#f59e0b",
+    corePrimary: "#00b4d8",
+    coreGlow: "rgba(0, 180, 216, 0.85)",
+    tendrilMagenta: "#d800a6",
+    tendrilCyan: "#00b4d8"
+  },
+  light: {
+    bgInner: "#f1f5f9",
+    bgMid: "#e2e8f0",
+    bgOuter: "#cbd5e1",
+    nebulaCyan: "rgba(0, 119, 182, 0.12)",
+    nebulaMagenta: "rgba(181, 0, 140, 0.1)",
+    piercerColor: "#dc2626",
+    sporeColor: "#16a34a",
+    clusterColor: "#d97706",
+    parasiteColor: "#7c3aed",
+    microColor: "#d97706",
+    corePrimary: "#0077b6",
+    coreGlow: "rgba(0, 119, 182, 0.85)",
+    tendrilMagenta: "#b5008c",
+    tendrilCyan: "#0077b6"
+  }
+}, D = "axon_surge_theme";
+class q {
+  currentTheme = "bioluminescent";
+  constructor(t) {
+    if (t)
+      this.setTheme(t);
+    else {
+      try {
+        const i = localStorage.getItem(D);
+        i && C[i] && (this.currentTheme = i);
+      } catch {
+      }
+      this.applyThemeToDOM();
+    }
+  }
+  setTheme(t) {
+    if (C[t]) {
+      this.currentTheme = t, this.applyThemeToDOM();
+      try {
+        localStorage.setItem(D, t);
+      } catch {
+      }
+    }
+  }
+  getTheme() {
+    return this.currentTheme;
+  }
+  getPalette() {
+    return C[this.currentTheme] || C.bioluminescent;
+  }
+  applyThemeToDOM() {
+    document.documentElement.setAttribute("data-theme", this.currentTheme);
+  }
+}
+class Q {
+  canvas;
+  ctx;
+  themeManager;
+  constructor(t, i) {
+    this.canvas = t, this.ctx = t.getContext("2d"), this.themeManager = i;
+  }
+  render(t, i, e, s, a, c, h, n, o, r) {
+    if (!this.ctx) return;
+    const l = this.themeManager.getPalette(), { width: p, height: f } = this.canvas, g = n.getShakeOffset();
+    this.ctx.save(), this.ctx.translate(g.x, g.y), this.drawFluidCosmosBackground(p, f, t.pulsePhase, l), this.drawToxicPools(e, t.pulsePhase), this.drawGravityVortices(s, t.pulsePhase), this.drawShockwaves(a), this.drawCoreFilaments(t, l), this.drawParticles(c), this.drawOrganicEnemies(i, t.pulsePhase, l), o ? this.drawPsionicTendril(t.position, o.position, l) : t && this.drawHoverTendril(t.position, r, i, l), this.drawOrganicConsciousnessCore(t, l), this.drawFloatingTexts(h), n.flashAlpha > 0 && (this.ctx.fillStyle = `rgba(255, 255, 255, ${n.flashAlpha})`, this.ctx.fillRect(0, 0, p, f)), this.ctx.restore();
+  }
+  drawToxicPools(t, i) {
+    if (this.ctx)
+      for (const e of t) {
+        const s = e.duration / e.maxDuration, a = Math.min(0.7, (1 - s) * 0.7), { x: c, y: h } = e.position;
+        this.ctx.save();
+        const n = this.ctx.createRadialGradient(c, h, 10, c, h, e.radius * 1.2);
+        n.addColorStop(0, `rgba(57, 255, 20, ${a * 0.9})`), n.addColorStop(0.4, `rgba(16, 185, 129, ${a * 0.65})`), n.addColorStop(0.8, `rgba(5, 80, 45, ${a * 0.35})`), n.addColorStop(1, "rgba(2, 35, 15, 0)"), this.ctx.fillStyle = n, this.ctx.shadowColor = "#39ff14", this.ctx.shadowBlur = 30, this.ctx.beginPath();
+        const o = 70;
+        for (let r = 0; r <= o; r++) {
+          const l = r * Math.PI * 2 / o, p = Math.sin(l * 5 + i * 3) * 14, f = Math.cos(l * 3 - i * 2) * 9, g = e.radius + p + f, b = c + Math.cos(l) * g, d = h + Math.sin(l) * g;
+          r === 0 ? this.ctx.moveTo(b, d) : this.ctx.lineTo(b, d);
+        }
+        this.ctx.closePath(), this.ctx.fill(), this.ctx.strokeStyle = `rgba(57, 255, 20, ${a * 0.8})`, this.ctx.lineWidth = 2.5, this.ctx.beginPath();
+        for (let r = 0; r <= o; r++) {
+          const l = r * Math.PI * 2 / o, p = Math.sin(l * 6 + i * 4) * 8, f = e.radius * 0.75 + p, g = c + Math.cos(l) * f, b = h + Math.sin(l) * f;
+          r === 0 ? this.ctx.moveTo(g, b) : this.ctx.lineTo(g, b);
+        }
+        this.ctx.closePath(), this.ctx.stroke();
+        for (let r = 0; r < 6; r++) {
+          const l = r * Math.PI * 0.33 + i * 1.5, p = e.radius * 0.5 * (0.3 + Math.sin(i * 2 + r) * 0.3), f = c + Math.cos(l) * p, g = h + Math.sin(l) * p, b = 3 + Math.sin(i * 3 + r) * 2;
+          this.ctx.fillStyle = `rgba(255, 255, 255, ${a * 0.8})`, this.ctx.beginPath(), this.ctx.arc(f, g, Math.max(1, b), 0, Math.PI * 2), this.ctx.fill();
+        }
+        this.ctx.restore();
+      }
+  }
+  drawShockwaves(t) {
+    if (this.ctx)
+      for (const i of t) {
+        this.ctx.save(), this.ctx.globalAlpha = i.alpha;
+        const e = this.ctx.createRadialGradient(
+          i.position.x,
+          i.position.y,
+          0,
+          i.position.x,
+          i.position.y,
+          i.radius
+        );
+        e.addColorStop(0, "rgba(255, 255, 255, 0.4)"), e.addColorStop(0.7, i.color), e.addColorStop(1, "rgba(0, 0, 0, 0)"), this.ctx.fillStyle = e, this.ctx.beginPath(), this.ctx.arc(i.position.x, i.position.y, i.radius, 0, Math.PI * 2), this.ctx.fill(), this.ctx.strokeStyle = "#ffffff", this.ctx.lineWidth = 4, this.ctx.shadowColor = i.color, this.ctx.shadowBlur = 24, this.ctx.beginPath(), this.ctx.arc(i.position.x, i.position.y, i.radius, 0, Math.PI * 2), this.ctx.stroke(), this.ctx.restore();
+      }
+  }
+  drawGravityVortices(t, i) {
+    if (this.ctx)
+      for (const e of t) {
+        const s = Math.min(0.85, (1 - e.duration / e.maxDuration) * 0.85), a = e.radius * (1 - e.duration / e.maxDuration * 0.1), { x: c, y: h } = e.position;
+        this.ctx.save();
+        const n = this.ctx.createRadialGradient(c, h, 0, c, h, 60);
+        n.addColorStop(0, `rgba(0, 0, 0, ${s})`), n.addColorStop(0.7, `rgba(20, 0, 40, ${s})`), n.addColorStop(1, `rgba(157, 78, 221, ${s * 0.5})`), this.ctx.fillStyle = n, this.ctx.beginPath(), this.ctx.arc(c, h, 60, 0, Math.PI * 2), this.ctx.fill(), this.ctx.strokeStyle = `rgba(157, 78, 221, ${s})`, this.ctx.lineWidth = 5, this.ctx.shadowColor = "#9d4edd", this.ctx.shadowBlur = 32;
+        for (let o = 1; o <= 5; o++) {
+          const r = a * o / 5, l = i * o * 2.2;
+          this.ctx.beginPath(), this.ctx.arc(c, h, r, l, l + Math.PI * 1.5), this.ctx.stroke();
+        }
+        this.ctx.restore();
+      }
+  }
+  drawFluidCosmosBackground(t, i, e, s) {
+    if (!this.ctx) return;
+    const a = this.ctx.createRadialGradient(t / 2, i / 2, 40, t / 2, i / 2, Math.max(t, i));
+    a.addColorStop(0, s.bgInner), a.addColorStop(0.5, s.bgMid), a.addColorStop(1, s.bgOuter), this.ctx.fillStyle = a, this.ctx.fillRect(0, 0, t, i);
+    const c = t * 0.35 + Math.sin(e * 0.3) * 60, h = i * 0.45 + Math.cos(e * 0.25) * 50, n = this.ctx.createRadialGradient(c, h, 20, c, h, 380);
+    n.addColorStop(0, s.nebulaCyan), n.addColorStop(1, "rgba(0, 0, 0, 0)"), this.ctx.fillStyle = n, this.ctx.beginPath(), this.ctx.arc(c, h, 380, 0, Math.PI * 2), this.ctx.fill();
+    const o = t * 0.68 + Math.cos(e * 0.35) * 50, r = i * 0.55 + Math.sin(e * 0.3) * 45, l = this.ctx.createRadialGradient(o, r, 20, o, r, 420);
+    l.addColorStop(0, s.nebulaMagenta), l.addColorStop(1, "rgba(0, 0, 0, 0)"), this.ctx.fillStyle = l, this.ctx.beginPath(), this.ctx.arc(o, r, 420, 0, Math.PI * 2), this.ctx.fill();
+  }
+  drawCoreFilaments(t, i) {
+    if (!this.ctx) return;
+    const e = 12;
+    this.ctx.lineWidth = 1.5, this.ctx.strokeStyle = i.nebulaCyan;
+    for (let s = 0; s < e; s++) {
+      const a = s * Math.PI * 2 / e + t.pulsePhase * 0.12, c = 85 + Math.sin(t.pulsePhase * 1.5 + s) * 25, h = t.position.x + Math.cos(a) * c, n = t.position.y + Math.sin(a) * c, o = t.position.x + Math.cos(a + 0.4) * 48, r = t.position.y + Math.sin(a + 0.4) * 48;
+      this.ctx.beginPath(), this.ctx.moveTo(t.position.x, t.position.y), this.ctx.quadraticCurveTo(o, r, h, n), this.ctx.stroke(), this.ctx.fillStyle = i.sporeColor, this.ctx.beginPath(), this.ctx.arc(h, n, 3.5, 0, Math.PI * 2), this.ctx.fill();
+    }
+  }
+  drawOrganicConsciousnessCore(t, i) {
+    if (!this.ctx) return;
+    const { x: e, y: s } = t.position;
+    for (let h = 0; h < t.integrity; h++) {
+      const n = t.radius + 16 + h * 12;
+      this.ctx.strokeStyle = i.corePrimary, this.ctx.lineWidth = 2.2, this.ctx.shadowColor = i.corePrimary, this.ctx.shadowBlur = 12, this.ctx.beginPath();
+      const o = 60;
+      for (let r = 0; r <= o; r++) {
+        const l = r * Math.PI * 2 / o, p = n + Math.sin(l * 4 + t.pulsePhase * 2 + h) * 3, f = e + Math.cos(l) * p, g = s + Math.sin(l) * p;
+        r === 0 ? this.ctx.moveTo(f, g) : this.ctx.lineTo(f, g);
+      }
+      this.ctx.closePath(), this.ctx.stroke();
+    }
+    const a = this.ctx.createRadialGradient(e, s, 5, e, s, t.radius * 2.2);
+    a.addColorStop(0, i.coreGlow), a.addColorStop(0.5, i.nebulaMagenta), a.addColorStop(1, "rgba(0, 0, 0, 0)"), this.ctx.fillStyle = a, this.ctx.beginPath(), this.ctx.arc(e, s, t.radius * 2.2, 0, Math.PI * 2), this.ctx.fill(), this.ctx.save(), this.ctx.translate(e, s), this.ctx.strokeStyle = i.corePrimary, this.ctx.lineWidth = 3, this.ctx.fillStyle = i.nebulaCyan, this.ctx.shadowColor = i.corePrimary, this.ctx.shadowBlur = 20, this.ctx.beginPath();
+    const c = 80;
+    for (let h = 0; h <= c; h++) {
+      const n = h * Math.PI * 2 / c, o = t.getMembraneRadius(n), r = Math.cos(n) * o, l = Math.sin(n) * o;
+      h === 0 ? this.ctx.moveTo(r, l) : this.ctx.lineTo(r, l);
+    }
+    this.ctx.closePath(), this.ctx.fill(), this.ctx.stroke(), this.ctx.fillStyle = "#ffffff", this.ctx.beginPath(), this.ctx.arc(0, 0, t.radius * 0.3, 0, Math.PI * 2), this.ctx.fill(), this.ctx.restore();
+  }
+  drawPsionicTendril(t, i, e) {
+    if (!this.ctx) return;
+    this.ctx.save();
+    const s = i.x - t.x, a = i.y - t.y;
+    this.ctx.strokeStyle = e.tendrilMagenta, this.ctx.lineWidth = 9, this.ctx.shadowColor = e.tendrilMagenta, this.ctx.shadowBlur = 20, this.ctx.beginPath(), this.ctx.moveTo(t.x, t.y);
+    const c = (t.x + i.x) / 2 + Math.sin(Date.now() * 0.02) * 16, h = (t.y + i.y) / 2 + Math.cos(Date.now() * 0.02) * 16;
+    this.ctx.quadraticCurveTo(c, h, i.x, i.y), this.ctx.stroke(), this.ctx.strokeStyle = e.tendrilCyan, this.ctx.lineWidth = 3.5, this.ctx.shadowColor = e.tendrilCyan, this.ctx.shadowBlur = 12, this.ctx.beginPath(), this.ctx.moveTo(t.x, t.y), this.ctx.lineTo(i.x, i.y), this.ctx.stroke();
+    for (let n = 0; n < 6; n++) {
+      const o = Math.random(), r = t.x + s * o + (Math.random() - 0.5) * 24, l = t.y + a * o + (Math.random() - 0.5) * 24;
+      this.ctx.fillStyle = "#ffffff", this.ctx.beginPath(), this.ctx.arc(r, l, 2.5 + Math.random() * 2.5, 0, Math.PI * 2), this.ctx.fill();
+    }
+    this.ctx.restore();
+  }
+  drawHoverTendril(t, i, e, s) {
+    if (this.ctx)
+      for (const a of e) {
+        if (!a.active || a.isGrabbed || a.isThrown || a.wasManipulated || a.isDying) continue;
+        const c = i.x - a.position.x, h = i.y - a.position.y;
+        if (Math.hypot(c, h) <= a.getHitRadius()) {
+          this.ctx.strokeStyle = s.tendrilMagenta, this.ctx.lineWidth = 2.5, this.ctx.beginPath(), this.ctx.moveTo(t.x, t.y), this.ctx.lineTo(a.position.x, a.position.y), this.ctx.stroke();
+          break;
+        }
+      }
+  }
+  drawOrganicEnemies(t, i, e) {
+    if (this.ctx)
+      for (const s of t) {
+        if (!s.active) continue;
+        let a = s.color;
+        s.type === "piercer" ? a = e.piercerColor : s.type === "spore" ? a = e.sporeColor : s.type === "cluster" ? a = e.clusterColor : s.type === "parasite" ? a = e.parasiteColor : s.type === "micro" && (a = e.microColor);
+        const { x: c, y: h } = s.position;
+        if (this.ctx.save(), this.ctx.translate(c, h), s.wasManipulated && !s.isDying) {
+          const n = s.radius * 1.5 + Math.sin(i * 6) * 4;
+          this.ctx.strokeStyle = e.tendrilMagenta, this.ctx.lineWidth = 2.5, this.ctx.shadowColor = e.tendrilMagenta, this.ctx.shadowBlur = 18, this.ctx.beginPath(), this.ctx.arc(0, 0, n, 0, Math.PI * 2), this.ctx.stroke();
+          const o = s.radius * 1.8 + Math.cos(i * 8) * 3;
+          this.ctx.strokeStyle = e.tendrilCyan, this.ctx.lineWidth = 1.5, this.ctx.beginPath(), this.ctx.arc(0, 0, o, 0, Math.PI * 2), this.ctx.stroke();
+        }
+        if (s.isDying) {
+          const n = s.deathTimer / s.maxDeathTimer, o = Math.max(0, 1 - n);
+          if (this.ctx.globalAlpha = o, s.deathType === "dissolve") {
+            const r = s.radius * (1 - n * 0.7);
+            this.ctx.fillStyle = e.sporeColor, this.ctx.shadowColor = e.sporeColor, this.ctx.shadowBlur = 20, this.ctx.beginPath(), this.ctx.arc(0, 0, r, 0, Math.PI * 2), this.ctx.fill();
+            for (let l = 0; l < 4; l++) {
+              const p = l * Math.PI * 0.5 + n * 4, f = r * 0.8 * n;
+              this.ctx.fillStyle = "#ffffff", this.ctx.beginPath(), this.ctx.arc(Math.cos(p) * f, Math.sin(p) * f, 3, 0, Math.PI * 2), this.ctx.fill();
+            }
+            this.ctx.restore();
+            continue;
+          } else if (s.deathType === "sliced") {
+            const r = n * 24, l = s.sliceAngle + Math.PI / 2, p = Math.cos(l) * r, f = Math.sin(l) * r;
+            this.ctx.shadowColor = "#ff2a5f", this.ctx.shadowBlur = 22, this.ctx.fillStyle = a, this.ctx.save(), this.ctx.translate(p, f), this.ctx.beginPath(), this.ctx.arc(0, 0, s.radius * 0.8, 0, Math.PI), this.ctx.fill(), this.ctx.restore(), this.ctx.save(), this.ctx.translate(-p, -f), this.ctx.beginPath(), this.ctx.arc(0, 0, s.radius * 0.8, Math.PI, Math.PI * 2), this.ctx.fill(), this.ctx.restore(), this.ctx.restore();
+            continue;
+          }
+        }
+        if (this.ctx.shadowColor = a, this.ctx.shadowBlur = 16, this.ctx.fillStyle = a, s.type === "piercer") {
+          this.ctx.rotate(s.rotation), this.ctx.beginPath();
+          const n = 12;
+          for (let o = 0; o <= n; o++) {
+            const r = o * Math.PI * 2 / n, l = s.radius * 1.6 + Math.sin(r * 3 + i * 4) * 3, p = s.radius * 0.6 + Math.cos(r * 2 + i * 3) * 2, f = Math.cos(r) * l, g = Math.sin(r) * p;
+            o === 0 ? this.ctx.moveTo(f, g) : this.ctx.lineTo(f, g);
+          }
+          this.ctx.closePath(), this.ctx.fill(), this.ctx.fillStyle = "#ffffff", this.ctx.beginPath(), this.ctx.arc(4, 0, 4, 0, Math.PI * 2), this.ctx.fill();
+        } else if (s.type === "spore") {
+          this.ctx.beginPath();
+          const n = 8;
+          for (let o = 0; o < n; o++) {
+            const r = o * Math.PI * 2 / n, l = s.radius + Math.sin(r * 4 + i * 3 + s.position.x) * 4, p = Math.cos(r) * l, f = Math.sin(r) * l;
+            o === 0 ? this.ctx.moveTo(p, f) : this.ctx.lineTo(p, f);
+          }
+          this.ctx.closePath(), this.ctx.fill(), this.ctx.fillStyle = "rgba(255, 255, 255, 0.7)", this.ctx.beginPath(), this.ctx.arc(-4, -4, 5, 0, Math.PI * 2), this.ctx.arc(5, 3, 4, 0, Math.PI * 2), this.ctx.fill();
+        } else if (s.type === "cluster") {
+          this.ctx.beginPath();
+          const n = Math.sin(i * 3) * 2;
+          this.ctx.arc(0, 0, s.radius * 0.55, 0, Math.PI * 2), this.ctx.arc(-9 + n, -7, s.radius * 0.42, 0, Math.PI * 2), this.ctx.arc(9 - n, -7, s.radius * 0.42, 0, Math.PI * 2), this.ctx.arc(0, 9 + n, s.radius * 0.45, 0, Math.PI * 2), this.ctx.fill();
+        } else if (s.type === "parasite") {
+          this.ctx.beginPath();
+          const n = 14;
+          for (let o = 0; o <= n; o++) {
+            const r = o * Math.PI * 2 / n, l = s.radius + Math.sin(r * 5 - i * 5) * 3, p = Math.cos(r) * l, f = Math.sin(r) * l;
+            o === 0 ? this.ctx.moveTo(p, f) : this.ctx.lineTo(p, f);
+          }
+          this.ctx.closePath(), this.ctx.fill(), this.ctx.fillStyle = e.bgOuter, this.ctx.beginPath(), this.ctx.arc(0, 0, s.radius * 0.45, 0, Math.PI * 2), this.ctx.fill();
+        } else
+          this.ctx.beginPath(), this.ctx.arc(0, 0, s.radius, 0, Math.PI * 2), this.ctx.fill();
+        this.ctx.restore();
+      }
+  }
+  drawParticles(t) {
+    if (this.ctx)
+      for (const i of t)
+        this.ctx.save(), this.ctx.globalAlpha = i.alpha, this.ctx.fillStyle = i.color, this.ctx.beginPath(), this.ctx.arc(i.position.x, i.position.y, i.radius, 0, Math.PI * 2), this.ctx.fill(), this.ctx.restore();
+  }
+  drawFloatingTexts(t) {
+    if (this.ctx)
+      for (const i of t)
+        this.ctx.save(), this.ctx.globalAlpha = i.alpha, this.ctx.fillStyle = i.color, this.ctx.font = `900 ${i.size}px Orbitron, sans-serif`, this.ctx.textAlign = "center", this.ctx.shadowColor = i.color, this.ctx.shadowBlur = 12, this.ctx.fillText(i.text, i.position.x, i.position.y), this.ctx.restore();
+  }
+}
+class j {
+  container;
+  i18n;
+  waveLabelElement;
+  progressSlot;
+  comboElement;
+  settingsButton;
+  constructor(t, i, e) {
+    this.i18n = i, this.container = document.createElement("div"), this.container.className = "axon-hud", this.waveLabelElement = document.createElement("div"), this.waveLabelElement.className = "axon-hud-wave", this.progressSlot = document.createElement("div"), this.progressSlot.className = "axon-hud-level-slot", this.waveLabelElement.appendChild(this.progressSlot), this.comboElement = document.createElement("div"), this.comboElement.className = "axon-hud-combo", this.settingsButton = document.createElement("button"), this.settingsButton.className = "axon-hud-settings-btn", this.settingsButton.setAttribute("aria-label", "Settings"), this.settingsButton.innerHTML = `
+            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
+                <circle cx="12" cy="12" r="3"></circle>
+                <path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"></path>
+            </svg>
+        `, this.settingsButton.addEventListener("click", e), this.renderLabels(), this.container.appendChild(this.waveLabelElement), this.container.appendChild(this.comboElement), this.container.appendChild(this.settingsButton), t.appendChild(this.container);
+  }
+  renderLabels() {
+    let t = this.waveLabelElement.querySelector(".axon-level-title");
+    t ? t.textContent = this.i18n.translate("waveLabel") : (t = document.createElement("div"), t.className = "axon-level-title", t.textContent = this.i18n.translate("waveLabel"), this.waveLabelElement.insertBefore(t, this.waveLabelElement.firstChild));
+    let i = this.waveLabelElement.querySelector("#axon-wave-val");
+    i || (i = document.createElement("span"), i.id = "axon-wave-val", i.textContent = "1", this.waveLabelElement.insertBefore(i, this.progressSlot)), this.comboElement.innerHTML = '<span id="axon-combo-val"></span>';
+  }
+  update(t, i) {
+    const e = this.container.querySelector("#axon-wave-val"), s = this.container.querySelector("#axon-combo-val");
+    e && (e.textContent = t.toString()), s && (i >= 2 ? (s.textContent = `x${i}`, s.style.display = "block") : s.style.display = "none");
+  }
+  show() {
+    this.renderLabels(), this.container.style.display = "flex";
+  }
+  hide() {
+    this.container.style.display = "none";
+  }
+}
+class tt {
+  container;
+  i18n;
+  onStartCallback;
+  constructor(t, i, e) {
+    this.i18n = i, this.onStartCallback = e, this.container = document.createElement("div"), this.container.className = "axon-start-menu", this.renderContent(), t.appendChild(this.container);
+  }
+  renderContent() {
+    this.container.innerHTML = `
+            <div class="axon-title-halo">
+                <h1 class="axon-title">${this.i18n.translate("title")}</h1>
+                <button id="axon-start-btn" class="axon-start-button">${this.i18n.translate("startButton")}</button>
+            </div>
+        `;
+    const t = this.container.querySelector("#axon-start-btn");
+    t && t.addEventListener("click", () => {
+      this.hide(), this.onStartCallback();
+    });
+  }
+  show() {
+    this.renderContent(), this.container.style.display = "flex";
+  }
+  hide() {
+    this.container.style.display = "none";
+  }
+}
+class it {
+  modal;
+  card;
+  i18n;
+  themeManager;
+  platform;
+  onLanguageChangedCallback;
+  onCloseCallback;
+  hapticsEnabled = !0;
+  constructor(t, i, e, s, a, c) {
+    this.i18n = i, this.themeManager = e, this.platform = s, this.onLanguageChangedCallback = a, this.onCloseCallback = c;
+    const h = localStorage.getItem("axon_surge_haptics");
+    h !== null && (this.hapticsEnabled = h === "true"), this.modal = document.createElement("dialog"), this.modal.className = "axon-settings-modal", this.card = document.createElement("div"), this.card.className = "axon-settings-card", this.modal.appendChild(this.card), t.appendChild(this.modal), this.modal.addEventListener("close", () => {
+      this.onCloseCallback && this.onCloseCallback();
+    }), this.renderContent();
+  }
+  renderContent() {
+    this.card.innerHTML = "";
+    const t = document.createElement("h2");
+    t.textContent = this.i18n.translate("settingsTitle");
+    const i = document.createElement("div");
+    i.className = "axon-setting-row";
+    const e = document.createElement("span");
+    e.textContent = this.i18n.translate("languageLabel");
+    const s = document.createElement("div");
+    s.className = "axon-select-wrapper";
+    const a = document.createElement("select");
+    a.className = "axon-select";
+    const c = {
+      es: "ESPAÑOL (ES)",
+      en: "ENGLISH (EN)",
+      fr: "FRANÇAIS (FR)",
+      de: "DEUTSCH (DE)",
+      it: "ITALIANO (IT)",
+      pt: "PORTUGUÊS (PT)",
+      nl: "NEDERLANDS (NL)",
+      sv: "SVENSKA (SV)",
+      pl: "POLSKI (PL)",
+      id: "BAHASA INDONESIA (ID)",
+      tr: "TÜRKÇE (TR)",
+      ru: "РУССКИЙ (RU)",
+      ja: "日本語 (JA)",
+      ko: "한국어 (KO)",
+      zh: "中文 (ZH)"
+    };
+    for (const u of k) {
+      const y = document.createElement("option");
+      y.value = u, y.textContent = c[u], this.i18n.getLanguage() === u && (y.selected = !0), a.appendChild(y);
+    }
+    a.addEventListener("change", () => {
+      const u = a.value;
+      this.i18n.setLanguage(u), this.onLanguageChangedCallback && this.onLanguageChangedCallback(u), this.renderContent();
+    });
+    const h = document.createElement("span");
+    h.className = "axon-select-arrow", h.textContent = "▼", s.appendChild(a), s.appendChild(h), i.appendChild(e), i.appendChild(s);
+    const n = document.createElement("div");
+    n.className = "axon-setting-row";
+    const o = document.createElement("span");
+    o.textContent = this.i18n.translate("themeLabel");
+    const r = document.createElement("div");
+    r.className = "axon-toggle-group";
+    const l = [
+      { id: "bioluminescent", label: "BIO" },
+      { id: "dark", label: "DARK" },
+      { id: "light", label: "LIGHT" }
+    ];
+    for (const u of l) {
+      const y = document.createElement("button");
+      y.type = "button", y.className = `axon-toggle-btn ${this.themeManager.getTheme() === u.id ? "active" : ""}`, y.textContent = u.label, y.addEventListener("click", () => {
+        this.themeManager.setTheme(u.id), this.renderContent();
+      }), r.appendChild(y);
+    }
+    n.appendChild(o), n.appendChild(r);
+    const p = document.createElement("div");
+    p.className = "axon-setting-row";
+    const f = document.createElement("span");
+    f.textContent = this.i18n.translate("hapticsLabel");
+    const g = document.createElement("div");
+    g.className = "axon-toggle-group";
+    const b = [
+      { enabled: !0, label: this.i18n.translate("hapticsOn") },
+      { enabled: !1, label: this.i18n.translate("hapticsOff") }
+    ];
+    for (const u of b) {
+      const y = document.createElement("button");
+      y.type = "button", y.className = `axon-toggle-btn ${this.hapticsEnabled === u.enabled ? "active" : ""}`, y.textContent = u.label, y.addEventListener("click", () => {
+        this.hapticsEnabled = u.enabled, localStorage.setItem("axon_surge_haptics", String(u.enabled)), this.hapticsEnabled && this.platform.haptics.selectionChanged(), this.renderContent();
+      }), g.appendChild(y);
+    }
+    p.appendChild(f), p.appendChild(g);
+    const d = document.createElement("div");
+    d.className = "axon-settings-credits", d.textContent = this.i18n.translate("creditsJam");
+    const m = document.createElement("button");
+    m.type = "button", m.className = "axon-start-button", m.style.padding = "12px 36px", m.style.fontSize = "14px", m.textContent = this.i18n.translate("closeButton"), m.addEventListener("click", () => {
+      this.modal.close();
+    }), this.card.appendChild(t), this.card.appendChild(i), this.card.appendChild(n), this.card.appendChild(p), this.card.appendChild(d), this.card.appendChild(m);
+  }
+  isHapticsEnabled() {
+    return this.hapticsEnabled;
+  }
+  show() {
+    this.renderContent(), this.modal.showModal();
+  }
+  hide() {
+    this.modal.close();
+  }
+}
+const O = "axon-surge-onboarding-completed";
+class et {
+  container;
+  i18n;
+  hasCompleted = !1;
+  isStep1Done = !1;
+  constructor(t, i) {
+    this.i18n = i, this.container = document.createElement("div"), this.container.className = "axon-onboarding", this.container.style.display = "none", t.appendChild(this.container);
+    try {
+      localStorage.getItem(O) === "true" && (this.hasCompleted = !0);
+    } catch {
+    }
+  }
+  isCompleted() {
+    return this.hasCompleted;
+  }
+  showStep1() {
+    this.hasCompleted || this.isStep1Done || (this.container.innerHTML = `
+            <div class="axon-onboarding-hint">
+                <div class="axon-onboarding-text">${this.i18n.translate("grabInstruction")}</div>
+            </div>
+        `, this.container.style.display = "flex");
+  }
+  showStep2() {
+    this.hasCompleted || (this.isStep1Done = !0, this.container.innerHTML = `
+            <div class="axon-onboarding-hint">
+                <div class="axon-onboarding-text">${this.i18n.translate("throwInstruction")}</div>
+            </div>
+        `, this.container.style.display = "flex");
+  }
+  complete() {
+    this.hasCompleted = !0, this.container.style.display = "none";
+    try {
+      localStorage.setItem(O, "true");
+    } catch {
+    }
+  }
+  reset() {
+    this.hasCompleted || (this.isStep1Done = !1, this.container.style.display = "none");
+  }
+}
+class st {
+  fillElement;
+  killsCount = 0;
+  currentLevel = 1;
+  onLevelUpCallback;
+  constructor(t, i) {
+    this.onLevelUpCallback = i;
+    const e = document.createElement("div");
+    e.className = "axon-hud-level-track", this.fillElement = document.createElement("div"), this.fillElement.className = "axon-hud-level-fill", e.appendChild(this.fillElement), t.appendChild(e);
+  }
+  getKillsRequiredForLevel(t) {
+    return 16 + (t - 1) * 6;
+  }
+  addKill() {
+    this.killsCount++;
+    const t = this.getKillsRequiredForLevel(this.currentLevel), i = Math.min(100, this.killsCount / t * 100);
+    this.fillElement.style.width = `${i}%`, this.killsCount >= t && (this.currentLevel++, this.killsCount = 0, this.fillElement.style.width = "0%", this.onLevelUpCallback && this.onLevelUpCallback(this.currentLevel));
+  }
+  getLevel() {
+    return this.currentLevel;
+  }
+  reset() {
+    this.killsCount = 0, this.currentLevel = 1, this.fillElement.style.width = "0%";
+  }
+  show() {
+    this.fillElement && this.fillElement.parentElement && (this.fillElement.parentElement.style.display = "block");
+  }
+  hide() {
+    this.fillElement && this.fillElement.parentElement && (this.fillElement.parentElement.style.display = "none");
+  }
+}
+class at {
+  haptics = {
+    impact: async (t) => {
+      if ("vibrate" in navigator) {
+        const i = t === "light" ? 10 : t === "medium" ? 25 : 40;
+        navigator.vibrate(i);
+      }
+    },
+    notification: async (t) => {
+      if ("vibrate" in navigator) {
+        const i = t === "error" ? [30, 40, 30] : [20, 20];
+        navigator.vibrate(i);
+      }
+    },
+    selectionChanged: async () => {
+      "vibrate" in navigator && navigator.vibrate(8);
+    }
+  };
+  share = {
+    share: async (t) => {
+      if ("share" in navigator)
+        try {
+          await navigator.share(t);
+        } catch {
+        }
+    }
+  };
+  review = {
+    requestReview: async () => {
+    }
+  };
+  analytics = {
+    event: async () => {
+    }
+  };
+  crashReporter = {
+    record: async () => {
+    }
+  };
+}
+class nt {
+  container;
+  canvas;
+  i18n;
+  themeManager;
+  platform;
+  eventBus;
+  gameLoop;
+  inputManager;
+  physicsEngine;
+  waveDirector;
+  renderer;
+  juice;
+  hud;
+  startMenu;
+  settingsModal;
+  onboarding;
+  progressBar;
+  core;
+  enemies = [];
+  ambientEnemies = [];
+  pools = [];
+  vortices = [];
+  shockwaves = [];
+  particles = [];
+  floatingTexts = [];
+  score = { value: 0 };
+  combo = { value: 0 };
+  isRunning = !1;
+  isPaused = !1;
+  firstPlay = !0;
+  constructor(t) {
+    this.container = t.root, this.container.classList.add("axon-game-root"), this.i18n = new J(t.language), this.themeManager = new q(t.theme), this.platform = t.platform || new at(), this.canvas = document.createElement("canvas"), this.canvas.className = "axon-canvas", this.container.appendChild(this.canvas), this.resizeCanvas(), window.addEventListener("resize", () => this.resizeCanvas()), this.eventBus = new G(), this.core = new U(this.canvas.width / 2, this.canvas.height / 2), this.inputManager = new H(this.canvas), this.physicsEngine = new z(this.eventBus, this.i18n), this.waveDirector = new _(), this.renderer = new Q(this.canvas, this.themeManager), this.juice = new F(), this.settingsModal = new it(
+      this.container,
+      this.i18n,
+      this.themeManager,
+      this.platform,
+      (i) => this.onLanguageChanged(i),
+      () => {
+        this.isPaused = !1;
+      }
+    ), this.onboarding = new et(this.container, this.i18n), this.hud = new j(this.container, this.i18n, () => {
+      this.isPaused = !0, this.settingsModal.show();
+    }), this.hud.show(), this.progressBar = new st(this.hud.progressSlot, (i) => {
+      this.waveDirector.wave = i;
+    }), this.startMenu = new tt(this.container, this.i18n, () => this.startGame()), this.initAmbientArena(), this.gameLoop = new B(
+      (i) => this.update(i),
+      () => this.render()
+    ), this.setupEvents(), this.gameLoop.start();
+  }
+  setLanguage(t) {
+    this.i18n.setLanguage(t), this.onLanguageChanged(t);
+  }
+  setTheme(t) {
+    this.themeManager.setTheme(t);
+  }
+  onLanguageChanged(t) {
+    this.startMenu.renderContent(), this.hud.renderLabels();
+  }
+  initAmbientArena() {
+    this.ambientEnemies = [];
+    const t = ["piercer", "spore", "cluster", "parasite"];
+    for (let i = 0; i < 16; i++) {
+      const e = t[i % t.length], s = i * Math.PI * 2 / 16, a = 180 + Math.random() * 220, c = {
+        x: this.canvas.width / 2 + Math.cos(s) * a,
+        y: this.canvas.height / 2 + Math.sin(s) * a
+      }, h = L.createEnemy(e, c, {
+        x: c.x + Math.sin(s) * 100,
+        y: c.y - Math.cos(s) * 100
+      });
+      this.ambientEnemies.push(h);
+    }
+  }
+  resizeCanvas() {
+    this.canvas.width = this.container.clientWidth || window.innerWidth, this.canvas.height = this.container.clientHeight || window.innerHeight, this.core && (this.core.position = { x: this.canvas.width / 2, y: this.canvas.height / 2 });
+  }
+  setupEvents() {
+    this.eventBus.on("onCoreDamaged", () => {
+      this.settingsModal.isHapticsEnabled() && this.platform.haptics.notification("error");
+    }), this.eventBus.on("onGameOver", () => {
+      this.isRunning = !1, this.onboarding.complete(), this.progressBar.hide(), this.initAmbientArena(), this.startMenu.show();
+    });
+    const t = () => {
+      if (!this.isRunning || this.isPaused) return;
+      this.inputManager.tryGrab(this.enemies) && (this.firstPlay && !this.onboarding.isCompleted() && this.onboarding.showStep2(), this.settingsModal.isHapticsEnabled() && this.platform.haptics.impact("light"));
+    }, i = () => {
+      if (!this.isRunning || this.isPaused) return;
+      this.inputManager.releaseAndThrow() && (this.firstPlay && (this.onboarding.complete(), this.firstPlay = !1), this.settingsModal.isHapticsEnabled() && this.platform.haptics.impact("medium"));
+    };
+    this.canvas.addEventListener("mousedown", (e) => {
+      e.button === 0 && t();
+    }), this.canvas.addEventListener("mouseup", (e) => {
+      e.button === 0 && i();
+    }), this.canvas.addEventListener("touchstart", t, { passive: !0 }), this.canvas.addEventListener("touchend", i, { passive: !0 }), this.canvas.addEventListener("touchcancel", i, { passive: !0 });
+  }
+  startGame() {
+    this.score.value = 0, this.combo.value = 0, this.enemies = [], this.ambientEnemies = [], this.pools = [], this.vortices = [], this.shockwaves = [], this.particles = [], this.floatingTexts = [], this.core.reset(this.canvas.width / 2, this.canvas.height / 2), this.waveDirector.reset(), this.inputManager.reset(), this.hud.show(), this.hud.update(1, 0), this.progressBar.reset(), this.progressBar.show(), this.isPaused = !1, this.isRunning = !0, this.firstPlay && this.onboarding.showStep1();
+  }
+  update(t) {
+    if (this.core.update(t), !this.isRunning || this.isPaused) {
+      for (const e of this.ambientEnemies)
+        e.update(t), e.position.x < -40 && (e.position.x = this.canvas.width + 40), e.position.x > this.canvas.width + 40 && (e.position.x = -40), e.position.y < -40 && (e.position.y = this.canvas.height + 40), e.position.y > this.canvas.height + 40 && (e.position.y = -40);
+      return;
+    }
+    const i = this.waveDirector.update(
+      t,
+      this.enemies,
+      this.canvas.width,
+      this.canvas.height,
+      this.core.position
+    );
+    i && this.enemies.push(i), this.juice.hitstopTime <= 0 && this.physicsEngine.update(
+      t,
+      this.core,
+      this.enemies,
+      this.pools,
+      this.vortices,
+      this.shockwaves,
+      this.particles,
+      this.floatingTexts,
+      this.juice,
+      this.combo,
+      this.score,
+      this.canvas.width,
+      this.canvas.height,
+      () => this.progressBar.addKill()
+    ), this.hud.update(this.progressBar.getLevel(), this.combo.value), this.juice.update(t, this.floatingTexts, this.particles);
+  }
+  render() {
+    const t = this.isRunning ? this.enemies : this.ambientEnemies;
+    this.renderer.render(
+      this.core,
+      t,
+      this.pools,
+      this.vortices,
+      this.shockwaves,
+      this.particles,
+      this.floatingTexts,
+      this.juice,
+      this.inputManager.grabbedEnemy,
+      this.inputManager.pointerPosition
+    );
+  }
+}
+function ot(x) {
+  return new nt(x);
+}
+export {
+  at as BrowserPlatform,
+  nt as GameEngine,
+  k as LANGUAGES,
+  q as ThemeManager,
+  ot as createAxonSurge,
+  V as isLanguage
+};