bonkjs 0.2.0

package/dist/bonkjs.js

@@ -0,0 +1,4307 @@
+import { Howler as D, Howl as X } from "howler";
+import { Application as Y, Container as A, Graphics as I, Texture as E, Sprite as S, Rectangle as H, Assets as K, Text as q, TextStyle as Z } from "pixi.js";
+import b from "matter-js";
+class R {
+  displayObject;
+  container;
+  config;
+  /**
+   * The base texture for sprite sheet operations.
+   *
+   * WHY store this separately from displayObject.texture?
+   * When we call setTextureRegion(), we create NEW Texture objects that
+   * reference different rectangular regions of this base texture. The
+   * displayObject.texture changes each frame, but baseTexture stays constant.
+   *
+   * Without storing baseTexture, we'd lose the original full-sheet texture
+   * after the first setTextureRegion() call, making subsequent region
+   * changes impossible.
+   */
+  baseTexture = null;
+  constructor(t, e, i) {
+    this.displayObject = t, this.container = e, this.config = i, e.addChild(t);
+  }
+  /** Replace the display object (used when texture loads) */
+  replaceDisplayObject(t) {
+    t.position.copyFrom(this.displayObject.position), t.rotation = this.displayObject.rotation, t.scale.copyFrom(this.displayObject.scale), t.alpha = this.displayObject.alpha, t.visible = this.displayObject.visible, t.zIndex = this.displayObject.zIndex;
+    const e = this.container.getChildIndex(this.displayObject);
+    this.container.removeChildAt(e), this.displayObject.destroy(), this.container.addChildAt(t, e), this.displayObject = t;
+  }
+  setPosition(t, e) {
+    this.displayObject.position.set(t, e);
+  }
+  setRotation(t) {
+    this.displayObject.rotation = t * Math.PI / 180;
+  }
+  setScale(t, e) {
+    this.displayObject.scale.set(t, e);
+  }
+  setAlpha(t) {
+    this.displayObject.alpha = t;
+  }
+  setVisible(t) {
+    this.displayObject.visible = t;
+  }
+  get zIndex() {
+    return this.displayObject.zIndex;
+  }
+  set zIndex(t) {
+    this.displayObject.zIndex = t;
+  }
+  destroy() {
+    this.container.removeChild(this.displayObject), this.displayObject.destroy();
+  }
+  /**
+   * Store the base texture for sprite sheet animation.
+   * Called once when the full sprite sheet texture is loaded.
+   */
+  setBaseTexture(t) {
+    this.baseTexture = t;
+  }
+  /**
+   * ═══════════════════════════════════════════════════════════════════════════
+   * TEXTURE REGION SELECTION (Sprite Sheet Animation)
+   * ═══════════════════════════════════════════════════════════════════════════
+   *
+   * This method creates a "view" into a portion of the sprite sheet texture.
+   * Each animation frame is a rectangular region of the larger texture.
+   *
+   * How PixiJS Texture Frames Work:
+   * ┌─────────────────────────────────────────────────────────────┐
+   * │  baseTexture (full sprite sheet, e.g. 128x64 pixels)       │
+   * │  ┌───────┬───────┬───────┬───────┐                         │
+   * │  │ frame │ frame │ frame │ frame │                         │
+   * │  │   0   │   1   │   2   │   3   │  ← Row 0                │
+   * │  ├───────┼───────┼───────┼───────┤                         │
+   * │  │ frame │ frame │ frame │ frame │                         │
+   * │  │   4   │   5   │   6   │   7   │  ← Row 1                │
+   * │  └───────┴───────┴───────┴───────┘                         │
+   * │          ↑                                                  │
+   * │    new Texture({ source: baseTexture.source,               │
+   * │                  frame: Rectangle(32, 0, 32, 32) })        │
+   * │    Creates a texture showing ONLY frame 1                   │
+   * └─────────────────────────────────────────────────────────────┘
+   *
+   * WHY create new Texture objects instead of modifying the existing one?
+   * PixiJS Texture objects are immutable after creation. The frame property
+   * is set at construction time. To show a different region, we must create
+   * a new Texture with a different frame Rectangle.
+   *
+   * @param x - Left edge of the frame in pixels
+   * @param y - Top edge of the frame in pixels
+   * @param width - Frame width in pixels
+   * @param height - Frame height in pixels
+   */
+  setTextureRegion(t, e, i, s) {
+    if (!this.baseTexture || !(this.displayObject instanceof S)) return;
+    const o = new H(t, e, i, s), a = new E({
+      source: this.baseTexture.source,
+      frame: o
+    });
+    this.displayObject.texture = a;
+  }
+}
+class J {
+  app = null;
+  worldContainer = null;
+  /**
+   * UI container for screen-space UI elements.
+   *
+   * ┌─────────────────────────────────────────────────────────────────┐
+   * │                    PIXI.JS APPLICATION                          │
+   * ├─────────────────────────────────────────────────────────────────┤
+   * │  app.stage                                                      │
+   * │  ├── worldContainer (camera-affected)                           │
+   * │  │   └── Game sprites, tilemaps, etc.                          │
+   * │  │                                                              │
+   * │  └── uiContainer (screen-space, fixed at 0,0)                  │
+   * │      └── UI elements (panels, text, buttons)                   │
+   * └─────────────────────────────────────────────────────────────────┘
+   *
+   * WHY separate containers?
+   * - worldContainer is transformed by camera (position, zoom)
+   * - uiContainer stays fixed at screen origin, ignores camera
+   * - UI always renders on top of game world
+   */
+  uiContainer = null;
+  textureCache = /* @__PURE__ */ new Map();
+  viewportWidth = 800;
+  viewportHeight = 600;
+  cameraX = 0;
+  cameraY = 0;
+  cameraZoom = 1;
+  async init(t) {
+    return this.app = new Y(), this.viewportWidth = t.width, this.viewportHeight = t.height, await this.app.init({
+      width: t.width,
+      height: t.height,
+      backgroundColor: t.backgroundColor ?? 1710638,
+      antialias: t.antialias ?? !0,
+      resolution: t.resolution ?? window.devicePixelRatio,
+      autoDensity: !0
+    }), this.worldContainer = new A(), this.worldContainer.sortableChildren = !0, this.app.stage.addChild(this.worldContainer), this.uiContainer = new A(), this.uiContainer.sortableChildren = !0, this.app.stage.addChild(this.uiContainer), this.app.canvas;
+  }
+  createSprite(t) {
+    if (!this.worldContainer)
+      throw new Error("Renderer not initialized. Call init() first.");
+    const e = t.width ?? 32, i = t.height ?? 32, s = t.color ?? 16711935, o = new I();
+    o.rect(-e / 2, -i / 2, e, i), o.fill(s), t.alpha !== void 0 && (o.alpha = t.alpha), t.zIndex !== void 0 && (o.zIndex = t.zIndex);
+    const a = new R(o, this.worldContainer, t);
+    return t.src && this.loadTexture(t.src).then((n) => {
+      if (n && n !== E.WHITE) {
+        const l = new S(n);
+        l.anchor.set(t.anchor?.[0] ?? 0.5, t.anchor?.[1] ?? 0.5), (t.width || t.height) && (l.width = e, l.height = i), a.replaceDisplayObject(l);
+      }
+    }), a;
+  }
+  /**
+   * ═══════════════════════════════════════════════════════════════════════════
+   * CREATE ANIMATED SPRITE
+   * ═══════════════════════════════════════════════════════════════════════════
+   *
+   * Creates a RenderObject optimized for sprite sheet animation:
+   * - Stores the base texture for later setTextureRegion() calls
+   * - Uses frame dimensions instead of scaling the texture
+   * - Notifies via callback when texture is ready for animation
+   *
+   * Flow:
+   * 1. Create placeholder Graphics immediately (so we have something to show)
+   * 2. Load texture asynchronously
+   * 3. When loaded, store as baseTexture and swap to Sprite
+   * 4. Call onTextureReady so AnimatedSpriteComponent can start animating
+   */
+  createAnimatedSprite(t) {
+    if (!this.worldContainer)
+      throw new Error("Renderer not initialized. Call init() first.");
+    const { frameWidth: e, frameHeight: i } = t, s = t.color ?? 16711935, o = new I();
+    o.rect(-e / 2, -i / 2, e, i), o.fill(s), t.alpha !== void 0 && (o.alpha = t.alpha), t.zIndex !== void 0 && (o.zIndex = t.zIndex);
+    const a = new R(o, this.worldContainer, t);
+    return t.src && this.loadTexture(t.src).then((n) => {
+      if (n && n !== E.WHITE) {
+        const l = new H(0, 0, e, i), h = new E({
+          source: n.source,
+          frame: l
+        }), u = new S(h);
+        u.anchor.set(t.anchor?.[0] ?? 0.5, t.anchor?.[1] ?? 0.5), a.setBaseTexture(n), a.replaceDisplayObject(u), t.onTextureReady?.();
+      }
+    }), a;
+  }
+  removeObject(t) {
+    t.destroy();
+  }
+  render() {
+  }
+  resize(t, e) {
+    this.app && (this.app.renderer.resize(t, e), this.viewportWidth = t, this.viewportHeight = e, this.updateWorldContainer());
+  }
+  getCanvas() {
+    return this.app?.canvas;
+  }
+  destroy() {
+    this.uiContainer && (this.uiContainer.destroy({ children: !0 }), this.uiContainer = null), this.worldContainer && (this.worldContainer.destroy({ children: !0 }), this.worldContainer = null), this.app && (this.app.destroy(!0), this.app = null), this.textureCache.clear();
+  }
+  setCameraPosition(t, e) {
+    this.cameraX = t, this.cameraY = e, this.updateWorldContainer();
+  }
+  setCameraZoom(t) {
+    this.cameraZoom = t, this.updateWorldContainer();
+  }
+  getViewportSize() {
+    return { width: this.viewportWidth, height: this.viewportHeight };
+  }
+  getCameraPosition() {
+    return { x: this.cameraX, y: this.cameraY };
+  }
+  getCameraZoom() {
+    return this.cameraZoom;
+  }
+  // ==================== PixiJS Internals ====================
+  getStage() {
+    if (!this.app) throw new Error("Renderer not initialized. Call init() first.");
+    return this.app.stage;
+  }
+  getWorldContainer() {
+    if (!this.worldContainer) throw new Error("Renderer not initialized. Call init() first.");
+    return this.worldContainer;
+  }
+  getApp() {
+    if (!this.app) throw new Error("Renderer not initialized. Call init() first.");
+    return this.app;
+  }
+  // ==================== Background ====================
+  setBackgroundColor(t) {
+    if (!this.app) throw new Error("Renderer not initialized. Call init() first.");
+    this.app.renderer.background.color = t;
+  }
+  // ==================== UI Support ====================
+  getUIContainer() {
+    if (!this.uiContainer) throw new Error("Renderer not initialized. Call init() first.");
+    return this.uiContainer;
+  }
+  addToUI(t) {
+    if (!this.uiContainer)
+      throw new Error("Renderer not initialized. Call init() first.");
+    this.uiContainer.addChild(t);
+  }
+  removeFromUI(t) {
+    this.uiContainer && this.uiContainer.removeChild(t);
+  }
+  /** Update world container transform based on camera position and zoom */
+  updateWorldContainer() {
+    this.worldContainer && (this.worldContainer.scale.set(this.cameraZoom, this.cameraZoom), this.worldContainer.position.set(
+      this.viewportWidth / 2 - this.cameraX * this.cameraZoom,
+      this.viewportHeight / 2 - this.cameraY * this.cameraZoom
+    ));
+  }
+  /** Load a texture with caching */
+  async loadTexture(t) {
+    if (this.textureCache.has(t))
+      return this.textureCache.get(t);
+    try {
+      const e = await K.load(t);
+      return this.textureCache.set(t, e), e;
+    } catch {
+      return null;
+    }
+  }
+}
+const _ = /* @__PURE__ */ new Map();
+function Q(r, t) {
+  _.set(r, t);
+}
+function tt(r, t) {
+  const e = _.get(r);
+  if (!e)
+    throw new Error(
+      `Physics backend "${r}" not found. Available: ${Array.from(_.keys()).join(", ")}`
+    );
+  return e(t);
+}
+function yt() {
+  return Array.from(_.keys());
+}
+class et {
+  nameToIndex = /* @__PURE__ */ new Map();
+  nextIndex = 0;
+  constructor() {
+    this.register("default");
+  }
+  /** Register a named layer. Returns the bit index. No-op if already registered. */
+  register(t) {
+    const e = this.nameToIndex.get(t);
+    if (e !== void 0) return e;
+    if (this.nextIndex >= 32)
+      return console.warn(
+        `[CollisionLayers] Maximum 32 layers reached. Cannot register "${t}".`
+      ), 0;
+    const i = this.nextIndex++;
+    return this.nameToIndex.set(t, i), i;
+  }
+  /** Get bitmask category for a layer name. Auto-registers if unknown. */
+  category(t) {
+    return 1 << this.register(t);
+  }
+  /** Get combined bitmask from an array of layer names. Empty = collide with all. */
+  mask(t) {
+    if (t.length === 0) return 4294967295;
+    let e = 0;
+    for (const i of t)
+      e |= this.category(i);
+    return e;
+  }
+  /** Get all registered layer names (in registration order). */
+  getLayerNames() {
+    return Array.from(this.nameToIndex.keys());
+  }
+  /** Clear the registry. Useful for testing or scene transitions. */
+  reset() {
+    this.nameToIndex.clear(), this.nextIndex = 0, this.register("default");
+  }
+}
+const j = new et();
+class it {
+  constructor(t, e) {
+    this.matterBody = t, this.type = e;
+  }
+  get id() {
+    return String(this.matterBody.id);
+  }
+  get position() {
+    return [this.matterBody.position.x, this.matterBody.position.y];
+  }
+  set position(t) {
+    b.Body.setPosition(this.matterBody, { x: t[0], y: t[1] });
+  }
+  get rotation() {
+    return this.matterBody.angle * 180 / Math.PI;
+  }
+  set rotation(t) {
+    b.Body.setAngle(this.matterBody, t * Math.PI / 180);
+  }
+  get velocity() {
+    return [this.matterBody.velocity.x, this.matterBody.velocity.y];
+  }
+  set velocity(t) {
+    b.Body.setVelocity(this.matterBody, { x: t[0], y: t[1] });
+  }
+  get angularVelocity() {
+    return this.matterBody.angularVelocity * 180 / Math.PI;
+  }
+  set angularVelocity(t) {
+    b.Body.setAngularVelocity(this.matterBody, t * Math.PI / 180);
+  }
+  applyForce(t) {
+    b.Body.applyForce(this.matterBody, this.matterBody.position, {
+      x: t[0],
+      y: t[1]
+    });
+  }
+  applyImpulse(t) {
+    const e = this.matterBody.mass;
+    b.Body.setVelocity(this.matterBody, {
+      x: this.matterBody.velocity.x + t[0] / e,
+      y: this.matterBody.velocity.y + t[1] / e
+    });
+  }
+  setVelocity(t) {
+    b.Body.setVelocity(this.matterBody, { x: t[0], y: t[1] });
+  }
+  setPosition(t) {
+    b.Body.setPosition(this.matterBody, { x: t[0], y: t[1] });
+  }
+  setRotation(t) {
+    b.Body.setAngle(this.matterBody, t * Math.PI / 180);
+  }
+}
+class st {
+  engine;
+  bodies = /* @__PURE__ */ new Map();
+  collisionStartCallbacks = [];
+  collisionEndCallbacks = [];
+  constructor(t) {
+    this.engine = b.Engine.create(), t?.gravity && this.setGravity(t.gravity), b.Events.on(this.engine, "collisionStart", (e) => {
+      for (const i of e.pairs) {
+        const s = this.bodies.get(i.bodyA.id), o = this.bodies.get(i.bodyB.id);
+        if (s && o) {
+          const a = {
+            bodyA: s,
+            bodyB: o,
+            contacts: i.collision.supports.map((n) => ({
+              point: [n.x, n.y],
+              normal: [
+                i.collision.normal.x,
+                i.collision.normal.y
+              ]
+            })),
+            isSensor: i.isSensor
+          };
+          for (const n of this.collisionStartCallbacks)
+            n(a);
+        }
+      }
+    }), b.Events.on(this.engine, "collisionEnd", (e) => {
+      for (const i of e.pairs) {
+        const s = this.bodies.get(i.bodyA.id), o = this.bodies.get(i.bodyB.id);
+        if (s && o) {
+          const a = {
+            bodyA: s,
+            bodyB: o,
+            contacts: [],
+            isSensor: i.isSensor
+          };
+          for (const n of this.collisionEndCallbacks)
+            n(a);
+        }
+      }
+    });
+  }
+  createBody(t) {
+    const e = t.type === "static", i = b.Bodies.rectangle(
+      t.position[0],
+      t.position[1],
+      1,
+      1,
+      {
+        isStatic: e,
+        angle: t.rotation * Math.PI / 180,
+        friction: t.friction ?? 0.1,
+        restitution: t.restitution ?? 0,
+        frictionAir: t.linearDamping ?? 0.01,
+        mass: t.mass,
+        inertia: t.fixedRotation ? 1 / 0 : void 0
+      }
+    );
+    t.gravityScale !== void 0 && t.gravityScale !== 1 && (i.gravityScale = t.gravityScale), b.Composite.add(this.engine.world, i);
+    const s = new it(i, t.type);
+    return this.bodies.set(i.id, s), s;
+  }
+  removeBody(t) {
+    const e = t;
+    b.Composite.remove(this.engine.world, e.matterBody), this.bodies.delete(e.matterBody.id);
+  }
+  addCollider(t, e) {
+    const i = t, s = i.matterBody, o = e.offset ?? [0, 0], a = {};
+    e.layer && (a.category = j.category(e.layer)), e.mask && e.mask.length > 0 && (a.mask = j.mask(e.mask));
+    const n = {
+      isStatic: s.isStatic,
+      isSensor: e.isTrigger,
+      friction: s.friction,
+      restitution: s.restitution,
+      frictionAir: s.frictionAir,
+      angle: s.angle,
+      inertia: s.inertia,
+      collisionFilter: Object.keys(a).length > 0 ? a : void 0
+    }, l = s;
+    l.gravityScale !== void 0 && (n.gravityScale = l.gravityScale);
+    let h = null;
+    const u = s.position.x + o[0], p = s.position.y + o[1];
+    switch (e.type) {
+      case "box":
+        h = b.Bodies.rectangle(
+          u,
+          p,
+          e.width ?? 32,
+          e.height ?? 32,
+          n
+        );
+        break;
+      case "circle":
+        h = b.Bodies.circle(u, p, e.radius ?? 16, n);
+        break;
+      case "polygon":
+        if (e.vertices && e.vertices.length >= 3) {
+          const g = e.vertices.map((k) => ({ x: k[0], y: k[1] }));
+          h = b.Bodies.fromVertices(u, p, [g], n);
+        }
+        break;
+    }
+    h && (b.Composite.remove(this.engine.world, s), this.bodies.delete(s.id), b.Composite.add(this.engine.world, h), this.bodies.set(h.id, i), i.matterBody = h);
+  }
+  step(t) {
+    const e = this.engine.gravity;
+    for (const i of this.bodies.values()) {
+      const s = i.matterBody;
+      if (s.gravityScale !== void 0 && s.gravityScale !== 1 && !s.isStatic) {
+        const o = s.gravityScale - 1;
+        b.Body.applyForce(s, s.position, {
+          x: e.x * s.mass * o * e.scale,
+          y: e.y * s.mass * o * e.scale
+        });
+      }
+    }
+    b.Engine.update(this.engine, t * 1e3);
+  }
+  setGravity(t) {
+    this.engine.gravity.x = t[0] / 1e3, this.engine.gravity.y = t[1] / 1e3, this.engine.gravity.scale = 1e-3;
+  }
+  getGravity() {
+    return [
+      this.engine.gravity.x * 1e3,
+      this.engine.gravity.y * 1e3
+    ];
+  }
+  raycast(t, e, i) {
+    const s = Math.sqrt(e[0] ** 2 + e[1] ** 2), o = e[0] / s, a = e[1] / s, n = {
+      x: t[0] + o * i,
+      y: t[1] + a * i
+    }, l = b.Query.ray(
+      b.Composite.allBodies(this.engine.world),
+      { x: t[0], y: t[1] },
+      n
+    );
+    if (l.length === 0) return null;
+    let h = l[0], u = 1 / 0, p = null;
+    for (const f of l) {
+      const x = f.supports?.[0], c = f.bodyB ?? f.bodyA, w = x ? x.x : c.position.x, O = x ? x.y : c.position.y, M = w - t[0], F = O - t[1], L = Math.sqrt(M * M + F * F);
+      L < u && (u = L, h = f, p = { x: w, y: O });
+    }
+    const g = h.bodyB ?? h.bodyA, k = this.bodies.get(g.id);
+    if (!k) return null;
+    const m = p ?? { x: g.position.x, y: g.position.y };
+    return {
+      body: k,
+      point: [m.x, m.y],
+      normal: [h.normal.x, h.normal.y],
+      distance: u
+    };
+  }
+  queryAABB(t, e) {
+    const i = {
+      min: { x: t[0], y: t[1] },
+      max: { x: e[0], y: e[1] }
+    }, s = b.Composite.allBodies(this.engine.world), o = [];
+    for (const a of s)
+      if (b.Bounds.overlaps(a.bounds, i)) {
+        const n = this.bodies.get(a.id);
+        n && o.push(n);
+      }
+    return o;
+  }
+  onCollisionStart(t) {
+    return this.collisionStartCallbacks.push(t), () => {
+      const e = this.collisionStartCallbacks.indexOf(t);
+      e !== -1 && this.collisionStartCallbacks.splice(e, 1);
+    };
+  }
+  onCollisionEnd(t) {
+    return this.collisionEndCallbacks.push(t), () => {
+      const e = this.collisionEndCallbacks.indexOf(t);
+      e !== -1 && this.collisionEndCallbacks.splice(e, 1);
+    };
+  }
+  clear() {
+    b.Composite.clear(this.engine.world, !1), this.bodies.clear();
+  }
+  destroy() {
+    this.clear(), b.Engine.clear(this.engine), this.collisionStartCallbacks = [], this.collisionEndCallbacks = [];
+  }
+}
+Q("matter", (r) => new st(r));
+class C {
+  /** Time since last frame in seconds */
+  static deltaTime = 0;
+  /** Unscaled time since last frame */
+  static unscaledDeltaTime = 0;
+  /** Total elapsed time since game start */
+  static time = 0;
+  /** Unscaled total elapsed time */
+  static unscaledTime = 0;
+  /** Fixed timestep for physics (1/60 second) */
+  static fixedDeltaTime = 1 / 60;
+  /** Time scale for slow-mo or pause effects */
+  static timeScale = 1;
+  /** Frame count since game start */
+  static frameCount = 0;
+  /** Current frames per second */
+  static fps = 60;
+  static fpsAccumulator = 0;
+  static fpsFrameCount = 0;
+  static lastFpsUpdate = 0;
+  /** Update time values (called by WorldManager) */
+  static update(t) {
+    this.unscaledDeltaTime = t, this.deltaTime = t * this.timeScale, this.unscaledTime += t, this.time += this.deltaTime, this.frameCount++, this.fpsAccumulator += t, this.fpsFrameCount++, this.fpsAccumulator >= 1 && (this.fps = Math.round(this.fpsFrameCount / this.fpsAccumulator), this.fpsAccumulator = 0, this.fpsFrameCount = 0);
+  }
+  /** Reset all time values */
+  static reset() {
+    this.deltaTime = 0, this.unscaledDeltaTime = 0, this.time = 0, this.unscaledTime = 0, this.timeScale = 1, this.frameCount = 0, this.fps = 60, this.fpsAccumulator = 0, this.fpsFrameCount = 0;
+  }
+}
+function kt(r) {
+  return { type: "frames", count: r };
+}
+function xt(r) {
+  return { type: "seconds", duration: r };
+}
+function wt(r) {
+  return { type: "until", predicate: r };
+}
+function Ct(r) {
+  return { type: "coroutine", generator: r };
+}
+let W = 0;
+class ot {
+  coroutines = [];
+  /** Start a new coroutine */
+  start(t) {
+    const e = W++, i = {
+      id: e,
+      generator: t,
+      waitingFor: null,
+      remainingFrames: 0,
+      remainingTime: 0,
+      nestedCoroutine: null,
+      cancelled: !1
+    };
+    return this.coroutines.push(i), this.advanceCoroutine(i), {
+      id: e,
+      cancel: () => this.cancel(e),
+      get isRunning() {
+        return !i.cancelled;
+      }
+    };
+  }
+  /** Cancel a running coroutine */
+  cancel(t) {
+    const e = this.coroutines.find((i) => i.id === t);
+    e && (e.cancelled = !0);
+  }
+  /** Cancel all coroutines */
+  cancelAll() {
+    for (const t of this.coroutines)
+      t.cancelled = !0;
+    this.coroutines = [];
+  }
+  /** Update all coroutines (called each frame) */
+  update() {
+    const t = C.deltaTime;
+    this.coroutines = this.coroutines.filter((e) => {
+      if (e.cancelled) return !1;
+      if (e.waitingFor)
+        switch (e.waitingFor.type) {
+          case "frames":
+            if (e.remainingFrames--, e.remainingFrames > 0) return !0;
+            break;
+          case "seconds":
+            if (e.remainingTime -= t, e.remainingTime > 0) return !0;
+            break;
+          case "until":
+            if (!e.waitingFor.predicate()) return !0;
+            break;
+          case "coroutine":
+            if (e.nestedCoroutine && !e.nestedCoroutine.cancelled)
+              return !0;
+            break;
+        }
+      return this.advanceCoroutine(e);
+    });
+  }
+  /** Advance a coroutine to its next yield point */
+  advanceCoroutine(t) {
+    try {
+      const e = t.generator.next();
+      if (e.done)
+        return !1;
+      const i = e.value;
+      switch (t.waitingFor = i, i.type) {
+        case "frames":
+          t.remainingFrames = i.count;
+          break;
+        case "seconds":
+          t.remainingTime = i.duration;
+          break;
+        case "until":
+          break;
+        case "coroutine":
+          const s = {
+            id: W++,
+            generator: i.generator,
+            waitingFor: null,
+            remainingFrames: 0,
+            remainingTime: 0,
+            nestedCoroutine: null,
+            cancelled: !1
+          };
+          t.nestedCoroutine = s, this.coroutines.push(s), this.advanceCoroutine(s);
+          break;
+      }
+      return !0;
+    } catch (e) {
+      return console.error("Coroutine error:", e), !1;
+    }
+  }
+  /** Get number of running coroutines */
+  get count() {
+    return this.coroutines.length;
+  }
+}
+const rt = new ot(), nt = {
+  axes: {
+    horizontal: {
+      negative: ["KeyA", "ArrowLeft"],
+      positive: ["KeyD", "ArrowRight"],
+      smoothing: 10
+    },
+    vertical: {
+      negative: ["KeyW", "ArrowUp"],
+      positive: ["KeyS", "ArrowDown"],
+      smoothing: 10
+    }
+  },
+  buttons: {
+    jump: { keys: ["Space"] },
+    fire: { keys: ["KeyX", "Mouse0"] }
+  }
+};
+class y {
+  // ==================== Key State ====================
+  /** Keys currently held down */
+  static keysHeld = /* @__PURE__ */ new Set();
+  /** Keys pressed this frame */
+  static keysDown = /* @__PURE__ */ new Set();
+  /** Keys released this frame */
+  static keysUp = /* @__PURE__ */ new Set();
+  // ==================== Mouse State ====================
+  /** Mouse buttons currently held (0=left, 1=middle, 2=right) */
+  static mouseButtonsHeld = /* @__PURE__ */ new Set();
+  /** Mouse buttons pressed this frame */
+  static mouseButtonsDown = /* @__PURE__ */ new Set();
+  /** Mouse buttons released this frame */
+  static mouseButtonsUp = /* @__PURE__ */ new Set();
+  /** Current mouse position relative to canvas */
+  static _mousePosition = [0, 0];
+  // ==================== Axis State ====================
+  /** Smoothed axis values */
+  static axisValues = /* @__PURE__ */ new Map();
+  // ==================== Configuration ====================
+  /** Current input configuration */
+  static config = nt;
+  /** Canvas element for mouse position calculation */
+  static canvas = null;
+  /** Whether input is initialized */
+  static initialized = !1;
+  // ==================== Event Handlers ====================
+  static onKeyDown = (t) => {
+    y.keysHeld.has(t.code) || y.keysDown.add(t.code), y.keysHeld.add(t.code);
+  };
+  static onKeyUp = (t) => {
+    y.keysHeld.delete(t.code), y.keysUp.add(t.code);
+  };
+  static onMouseDown = (t) => {
+    y.mouseButtonsHeld.has(t.button) || y.mouseButtonsDown.add(t.button), y.mouseButtonsHeld.add(t.button);
+  };
+  static onMouseUp = (t) => {
+    y.mouseButtonsHeld.delete(t.button), y.mouseButtonsUp.add(t.button);
+  };
+  static onMouseMove = (t) => {
+    if (y.canvas) {
+      const e = y.canvas.getBoundingClientRect();
+      y._mousePosition = [
+        t.clientX - e.left,
+        t.clientY - e.top
+      ];
+    } else
+      y._mousePosition = [t.clientX, t.clientY];
+  };
+  static onContextMenu = (t) => {
+    y.canvas && t.target === y.canvas && t.preventDefault();
+  };
+  // ==================== Lifecycle ====================
+  /**
+   * Initialize the input system.
+   * Call once at startup.
+   */
+  static initialize(t) {
+    if (this.initialized) {
+      console.warn("Input system already initialized");
+      return;
+    }
+    this.canvas = t ?? null, window.addEventListener("keydown", this.onKeyDown), window.addEventListener("keyup", this.onKeyUp), window.addEventListener("mousedown", this.onMouseDown), window.addEventListener("mouseup", this.onMouseUp), window.addEventListener("mousemove", this.onMouseMove), window.addEventListener("contextmenu", this.onContextMenu);
+    for (const e of Object.keys(this.config.axes))
+      this.axisValues.set(e, 0);
+    this.initialized = !0, console.log("Input system initialized");
+  }
+  /**
+   * Update input state.
+   * Call at the start of each frame, after Time.update().
+   */
+  static update() {
+    this.keysDown.clear(), this.keysUp.clear(), this.mouseButtonsDown.clear(), this.mouseButtonsUp.clear(), this.updateAxes();
+  }
+  /**
+   * Destroy the input system and remove all listeners.
+   */
+  static destroy() {
+    this.initialized && (window.removeEventListener("keydown", this.onKeyDown), window.removeEventListener("keyup", this.onKeyUp), window.removeEventListener("mousedown", this.onMouseDown), window.removeEventListener("mouseup", this.onMouseUp), window.removeEventListener("mousemove", this.onMouseMove), window.removeEventListener("contextmenu", this.onContextMenu), this.keysHeld.clear(), this.keysDown.clear(), this.keysUp.clear(), this.mouseButtonsHeld.clear(), this.mouseButtonsDown.clear(), this.mouseButtonsUp.clear(), this.axisValues.clear(), this.canvas = null, this.initialized = !1, console.log("Input system destroyed"));
+  }
+  // ==================== Axis Updates ====================
+  static updateAxes() {
+    const t = C.deltaTime || 0.016666666666666666;
+    for (const [e, i] of Object.entries(this.config.axes)) {
+      const s = this.getAxisRaw(e), o = this.axisValues.get(e) ?? 0, a = i.smoothing ?? 10;
+      if (a === 0)
+        this.axisValues.set(e, s);
+      else {
+        const n = Math.min(1, a * t), l = o + (s - o) * n;
+        this.axisValues.set(e, Math.abs(l) < 1e-3 ? 0 : l);
+      }
+    }
+  }
+  // ==================== Axis API ====================
+  /**
+   * Get a smoothed axis value between -1 and 1.
+   */
+  static getAxis(t) {
+    return this.axisValues.get(t) ?? 0;
+  }
+  /**
+   * Get raw axis value: -1, 0, or 1 (no smoothing).
+   */
+  static getAxisRaw(t) {
+    const e = this.config.axes[t];
+    if (!e) return 0;
+    let i = 0;
+    for (const s of e.negative)
+      if (this.isKeyOrMouseHeld(s)) {
+        i -= 1;
+        break;
+      }
+    for (const s of e.positive)
+      if (this.isKeyOrMouseHeld(s)) {
+        i += 1;
+        break;
+      }
+    return i;
+  }
+  // ==================== Button API ====================
+  /**
+   * Check if a button is currently held.
+   */
+  static getButton(t) {
+    const e = this.config.buttons[t];
+    if (!e) return !1;
+    for (const i of e.keys)
+      if (this.isKeyOrMouseHeld(i)) return !0;
+    return !1;
+  }
+  /**
+   * Check if a button was pressed this frame.
+   */
+  static getButtonDown(t) {
+    const e = this.config.buttons[t];
+    if (!e) return !1;
+    for (const i of e.keys)
+      if (this.isKeyOrMouseDown(i)) return !0;
+    return !1;
+  }
+  /**
+   * Check if a button was released this frame.
+   */
+  static getButtonUp(t) {
+    const e = this.config.buttons[t];
+    if (!e) return !1;
+    for (const i of e.keys)
+      if (this.isKeyOrMouseUp(i)) return !0;
+    return !1;
+  }
+  // ==================== Raw Key API ====================
+  /**
+   * Check if a key is currently held.
+   * @param code KeyboardEvent.code (e.g., 'KeyW', 'Space', 'ArrowUp')
+   */
+  static getKey(t) {
+    return this.keysHeld.has(t);
+  }
+  /**
+   * Check if a key was pressed this frame.
+   * @param code KeyboardEvent.code (e.g., 'KeyW', 'Space', 'ArrowUp')
+   */
+  static getKeyDown(t) {
+    return this.keysDown.has(t);
+  }
+  /**
+   * Check if a key was released this frame.
+   * @param code KeyboardEvent.code (e.g., 'KeyW', 'Space', 'ArrowUp')
+   */
+  static getKeyUp(t) {
+    return this.keysUp.has(t);
+  }
+  // ==================== Mouse API ====================
+  /**
+   * Current mouse position relative to canvas (or window if no canvas).
+   */
+  static get mousePosition() {
+    return [...this._mousePosition];
+  }
+  /**
+   * Check if a mouse button is currently held.
+   * @param button 0=left, 1=middle, 2=right
+   */
+  static getMouseButton(t) {
+    return this.mouseButtonsHeld.has(t);
+  }
+  /**
+   * Check if a mouse button was pressed this frame.
+   */
+  static getMouseButtonDown(t) {
+    return this.mouseButtonsDown.has(t);
+  }
+  /**
+   * Check if a mouse button was released this frame.
+   */
+  static getMouseButtonUp(t) {
+    return this.mouseButtonsUp.has(t);
+  }
+  // ==================== Configuration ====================
+  /**
+   * Configure an axis.
+   */
+  static setAxis(t, e) {
+    this.config.axes[t] = e, this.axisValues.has(t) || this.axisValues.set(t, 0);
+  }
+  /**
+   * Configure a button.
+   */
+  static setButton(t, e) {
+    this.config.buttons[t] = e;
+  }
+  /**
+   * Set the entire input configuration.
+   */
+  static setConfig(t) {
+    this.config = t, this.axisValues.clear();
+    for (const e of Object.keys(t.axes))
+      this.axisValues.set(e, 0);
+  }
+  // ==================== Helpers ====================
+  static isKeyOrMouseHeld(t) {
+    if (t.startsWith("Mouse")) {
+      const e = parseInt(t.slice(5), 10);
+      return this.mouseButtonsHeld.has(e);
+    }
+    return this.keysHeld.has(t);
+  }
+  static isKeyOrMouseDown(t) {
+    if (t.startsWith("Mouse")) {
+      const e = parseInt(t.slice(5), 10);
+      return this.mouseButtonsDown.has(e);
+    }
+    return this.keysDown.has(t);
+  }
+  static isKeyOrMouseUp(t) {
+    if (t.startsWith("Mouse")) {
+      const e = parseInt(t.slice(5), 10);
+      return this.mouseButtonsUp.has(e);
+    }
+    return this.keysUp.has(t);
+  }
+}
+class at {
+  listeners = /* @__PURE__ */ new Map();
+  /** Subscribe to an event */
+  on(t, e) {
+    this.listeners.has(t) || this.listeners.set(t, []);
+    const i = {
+      callback: e,
+      once: !1
+    };
+    return this.listeners.get(t).push(i), () => this.off(t, e);
+  }
+  /** Subscribe to an event (fires once then unsubscribes) */
+  once(t, e) {
+    this.listeners.has(t) || this.listeners.set(t, []);
+    const i = {
+      callback: e,
+      once: !0
+    };
+    return this.listeners.get(t).push(i), () => this.off(t, e);
+  }
+  /** Unsubscribe from an event */
+  off(t, e) {
+    const i = this.listeners.get(t);
+    if (!i) return;
+    const s = i.findIndex((o) => o.callback === e);
+    s !== -1 && i.splice(s, 1);
+  }
+  /** Emit an event */
+  emit(t, e) {
+    const i = this.listeners.get(t);
+    if (!i) return;
+    const s = [...i];
+    for (const o of s)
+      o.callback(e), o.once && this.off(t, o.callback);
+  }
+  /** Remove all listeners for an event (or all events) */
+  removeAllListeners(t) {
+    t ? this.listeners.delete(t) : this.listeners.clear();
+  }
+  /** Check if event has listeners */
+  hasListeners(t) {
+    const e = this.listeners.get(t);
+    return e !== void 0 && e.length > 0;
+  }
+}
+const B = new at(), T = {
+  /** Fired when the game is paused */
+  PAUSE: "engine:pause",
+  /** Fired when the game is resumed */
+  RESUME: "engine:resume",
+  /** Fired on collision enter */
+  COLLISION_ENTER: "engine:collision:enter",
+  /** Fired on collision exit */
+  COLLISION_EXIT: "engine:collision:exit",
+  /** Fired on trigger enter */
+  TRIGGER_ENTER: "engine:trigger:enter",
+  /** Fired on trigger exit */
+  TRIGGER_EXIT: "engine:trigger:exit"
+};
+class lt {
+  world;
+  transform;
+  bodyType;
+  /** The underlying physics body */
+  _body;
+  collisionEnterCallbacks = [];
+  collisionExitCallbacks = [];
+  triggerEnterCallbacks = [];
+  triggerExitCallbacks = [];
+  constructor(t, e, i) {
+    this.world = t, this.transform = e, this.bodyType = i.type;
+    const s = e.worldPosition, o = e.worldRotation;
+    this._body = t.createBody({
+      type: i.type,
+      position: s,
+      rotation: o,
+      mass: i.mass,
+      friction: i.friction,
+      restitution: i.restitution,
+      linearDamping: i.linearDamping,
+      angularDamping: i.angularDamping,
+      fixedRotation: i.fixedRotation,
+      bullet: i.bullet,
+      gravityScale: i.gravityScale
+    });
+  }
+  /** Get the underlying physics body. */
+  get body() {
+    return this._body;
+  }
+  /** Get/set velocity. */
+  get velocity() {
+    return this._body.velocity;
+  }
+  set velocity(t) {
+    this._body.setVelocity(t);
+  }
+  /** Apply a continuous force. */
+  applyForce(t) {
+    this._body.applyForce(t);
+  }
+  /** Apply an instant impulse. */
+  applyImpulse(t) {
+    this._body.applyImpulse(t);
+  }
+  /** Add a collider shape to this body. */
+  addCollider(t) {
+    this.world.addCollider(this._body, t);
+  }
+  /** Sync transform FROM physics (call for dynamic bodies after physics step). */
+  syncFromPhysics() {
+    if (this.bodyType !== "dynamic") return;
+    const t = this._body.position, e = this._body.rotation;
+    this.transform.position = [t[0], t[1]], this.transform.rotation = e;
+  }
+  /** Sync transform TO physics (call for kinematic bodies before physics step). */
+  syncToPhysics() {
+    if (this.bodyType !== "kinematic") return;
+    const t = this.transform.worldPosition, e = this.transform.worldRotation;
+    this._body.setPosition(t), this._body.setRotation(e);
+  }
+  /** Register collision enter callback. */
+  onCollisionEnter(t) {
+    return this.collisionEnterCallbacks.push(t), () => {
+      const e = this.collisionEnterCallbacks.indexOf(t);
+      e !== -1 && this.collisionEnterCallbacks.splice(e, 1);
+    };
+  }
+  /** Register collision exit callback. */
+  onCollisionExit(t) {
+    return this.collisionExitCallbacks.push(t), () => {
+      const e = this.collisionExitCallbacks.indexOf(t);
+      e !== -1 && this.collisionExitCallbacks.splice(e, 1);
+    };
+  }
+  /** Register trigger enter callback. */
+  onTriggerEnter(t) {
+    return this.triggerEnterCallbacks.push(t), () => {
+      const e = this.triggerEnterCallbacks.indexOf(t);
+      e !== -1 && this.triggerEnterCallbacks.splice(e, 1);
+    };
+  }
+  /** Register trigger exit callback. */
+  onTriggerExit(t) {
+    return this.triggerExitCallbacks.push(t), () => {
+      const e = this.triggerExitCallbacks.indexOf(t);
+      e !== -1 && this.triggerExitCallbacks.splice(e, 1);
+    };
+  }
+  /** Destroy and remove from physics world. */
+  destroy() {
+    this.world.removeBody(this._body), this.collisionEnterCallbacks = [], this.collisionExitCallbacks = [], this.triggerEnterCallbacks = [], this.triggerExitCallbacks = [];
+  }
+  // Internal methods called by Game collision routing
+  /** @internal */
+  _fireCollisionEnter(t, e) {
+    for (const i of this.collisionEnterCallbacks) i(t, e);
+  }
+  /** @internal */
+  _fireCollisionExit(t) {
+    for (const e of this.collisionExitCallbacks) e(t);
+  }
+  /** @internal */
+  _fireTriggerEnter(t) {
+    for (const e of this.triggerEnterCallbacks) e(t);
+  }
+  /** @internal */
+  _fireTriggerExit(t) {
+    for (const e of this.triggerExitCallbacks) e(t);
+  }
+}
+class vt {
+  renderer;
+  physics;
+  fixedUpdateCallbacks = [];
+  updateCallbacks = [];
+  lateUpdateCallbacks = [];
+  running = !1;
+  paused = !1;
+  animFrameId = null;
+  lastTime = 0;
+  fixedAccumulator = 0;
+  maxDeltaTime = 0.25;
+  /** Body ID → RigidBody for collision routing */
+  registeredBodies = /* @__PURE__ */ new Map();
+  physicsCleanup = [];
+  constructor(t) {
+    this.renderer = new J(), t?.physics?.enabled !== !1 ? (this.physics = tt("matter", {
+      gravity: t?.physics?.gravity ?? [0, 980]
+    }), this.setupCollisionRouting()) : this.physics = null;
+  }
+  /** Initialize the renderer and input system. Returns the canvas. */
+  async init(t) {
+    const e = await this.renderer.init({
+      width: t?.width ?? 800,
+      height: t?.height ?? 600,
+      backgroundColor: t?.backgroundColor,
+      antialias: t?.antialias ?? !0,
+      resolution: t?.resolution
+    });
+    return y.initialize(e), e;
+  }
+  /** Register a callback for fixed-timestep updates (physics). */
+  onFixedUpdate(t) {
+    return this.fixedUpdateCallbacks.push(t), () => {
+      const e = this.fixedUpdateCallbacks.indexOf(t);
+      e !== -1 && this.fixedUpdateCallbacks.splice(e, 1);
+    };
+  }
+  /** Register a callback for per-frame updates. */
+  onUpdate(t) {
+    return this.updateCallbacks.push(t), () => {
+      const e = this.updateCallbacks.indexOf(t);
+      e !== -1 && this.updateCallbacks.splice(e, 1);
+    };
+  }
+  /** Register a callback for late updates (after main update). */
+  onLateUpdate(t) {
+    return this.lateUpdateCallbacks.push(t), () => {
+      const e = this.lateUpdateCallbacks.indexOf(t);
+      e !== -1 && this.lateUpdateCallbacks.splice(e, 1);
+    };
+  }
+  /** Register a RigidBody for collision routing. */
+  registerBody(t) {
+    t.body && this.registeredBodies.set(t.body.id, t);
+  }
+  /** Unregister a RigidBody from collision routing. */
+  unregisterBody(t) {
+    t.body && this.registeredBodies.delete(t.body.id);
+  }
+  /** Convenience: create a RigidBody and auto-register it. */
+  createBody(t, e) {
+    if (!this.physics)
+      throw new Error("Physics is not enabled for this Game instance");
+    const i = new lt(this.physics, t, e);
+    return this.registerBody(i), i;
+  }
+  /** Start the game loop. */
+  start() {
+    this.running || (this.running = !0, this.paused = !1, this.lastTime = performance.now(), this.fixedAccumulator = 0, this.loop());
+  }
+  /** Stop the game loop. */
+  stop() {
+    this.running = !1, this.animFrameId !== null && (cancelAnimationFrame(this.animFrameId), this.animFrameId = null);
+  }
+  /** Pause the game (loop continues but updates are skipped). */
+  pause() {
+    this.paused || (this.paused = !0, B.emit(T.PAUSE));
+  }
+  /** Resume a paused game. */
+  resume() {
+    this.paused && (this.paused = !1, this.lastTime = performance.now(), B.emit(T.RESUME));
+  }
+  /** Clean up all resources. */
+  destroy() {
+    this.stop();
+    for (const t of this.physicsCleanup) t();
+    this.physicsCleanup = [], this.registeredBodies.clear(), this.physics?.destroy(), y.destroy(), this.renderer.destroy();
+  }
+  loop = () => {
+    if (!this.running) return;
+    const t = performance.now();
+    let e = (t - this.lastTime) / 1e3;
+    if (this.lastTime = t, e > this.maxDeltaTime && (e = this.maxDeltaTime), !this.paused) {
+      for (C.update(e), this.fixedAccumulator += e; this.fixedAccumulator >= C.fixedDeltaTime; ) {
+        this.fixedAccumulator -= C.fixedDeltaTime, this.physics && this.physics.step(C.fixedDeltaTime);
+        for (const i of this.fixedUpdateCallbacks) i();
+      }
+      for (const i of this.updateCallbacks) i();
+      for (const i of this.lateUpdateCallbacks) i();
+      rt.update(), y.update();
+    }
+    this.renderer.render(), this.animFrameId = requestAnimationFrame(this.loop);
+  };
+  setupCollisionRouting() {
+    this.physics && (this.physicsCleanup.push(
+      this.physics.onCollisionStart((t) => {
+        this.routeCollision(t, "enter");
+      })
+    ), this.physicsCleanup.push(
+      this.physics.onCollisionEnd((t) => {
+        this.routeCollision(t, "exit");
+      })
+    ));
+  }
+  routeCollision(t, e) {
+    const i = this.registeredBodies.get(t.bodyA.id), s = this.registeredBodies.get(t.bodyB.id);
+    if (!(!i || !s))
+      if (t.isSensor)
+        e === "enter" ? (i._fireTriggerEnter(s), s._fireTriggerEnter(i)) : (i._fireTriggerExit(s), s._fireTriggerExit(i));
+      else {
+        const o = t.contacts[0] ?? { point: [0, 0], normal: [0, 0] };
+        e === "enter" ? (i._fireCollisionEnter(s, o), s._fireCollisionEnter(i, {
+          point: o.point,
+          normal: [-o.normal[0], -o.normal[1]]
+        })) : (i._fireCollisionExit(s), s._fireCollisionExit(i));
+      }
+  }
+}
+class $ {
+  /** Position in world space */
+  position;
+  /** Rotation in degrees */
+  rotation;
+  /** Scale factor */
+  scale;
+  /** Z-index for render ordering (higher = on top) */
+  zIndex;
+  /** Parent transform for hierarchical positioning */
+  parent = null;
+  /** Child transforms */
+  children = [];
+  constructor(t) {
+    this.position = t?.position ? [...t.position] : [0, 0], this.rotation = t?.rotation ?? 0, this.scale = t?.scale ? [...t.scale] : [1, 1], this.zIndex = t?.zIndex ?? 0;
+  }
+  /** Get world position (accounting for parent transforms) */
+  get worldPosition() {
+    if (!this.parent) return this.position;
+    const t = this.parent.worldPosition, e = this.parent.worldScale, i = this.parent.worldRotation * Math.PI / 180, s = Math.cos(i), o = Math.sin(i), a = this.position[0] * e[0], n = this.position[1] * e[1];
+    return [
+      t[0] + s * a - o * n,
+      t[1] + o * a + s * n
+    ];
+  }
+  /** Set world position */
+  set worldPosition(t) {
+    if (!this.parent) {
+      this.position = [...t];
+      return;
+    }
+    const e = this.parent.worldPosition, i = this.parent.worldScale, s = -this.parent.worldRotation * Math.PI / 180, o = t[0] - e[0], a = t[1] - e[1], n = Math.cos(s), l = Math.sin(s);
+    this.position = [
+      (n * o - l * a) / i[0],
+      (l * o + n * a) / i[1]
+    ];
+  }
+  /** Get world rotation */
+  get worldRotation() {
+    return this.parent ? this.parent.worldRotation + this.rotation : this.rotation;
+  }
+  /** Set world rotation */
+  set worldRotation(t) {
+    if (!this.parent) {
+      this.rotation = t;
+      return;
+    }
+    this.rotation = t - this.parent.worldRotation;
+  }
+  /** Get world scale */
+  get worldScale() {
+    if (!this.parent) return this.scale;
+    const t = this.parent.worldScale;
+    return [this.scale[0] * t[0], this.scale[1] * t[1]];
+  }
+  /** Add a child transform */
+  addChild(t) {
+    t.parent && t.parent.removeChild(t), t.parent = this, this.children.push(t);
+  }
+  /** Remove a child transform */
+  removeChild(t) {
+    const e = this.children.indexOf(t);
+    e !== -1 && (this.children.splice(e, 1), t.parent = null);
+  }
+  /** Get all children */
+  getChildren() {
+    return this.children;
+  }
+  /** Get forward direction vector */
+  get forward() {
+    const t = this.worldRotation * Math.PI / 180;
+    return [Math.cos(t), Math.sin(t)];
+  }
+  /** Get right direction vector */
+  get right() {
+    const t = (this.worldRotation + 90) * Math.PI / 180;
+    return [Math.cos(t), Math.sin(t)];
+  }
+  /** Translate by offset */
+  translate(t, e) {
+    this.position[0] += t, this.position[1] += e;
+  }
+  /** Rotate by degrees */
+  rotate(t) {
+    this.rotation += t;
+  }
+  /** Look at a target position */
+  lookAt(t) {
+    const e = t[0] - this.worldPosition[0], i = t[1] - this.worldPosition[1];
+    this.worldRotation = Math.atan2(i, e) * 180 / Math.PI;
+  }
+  /** Convert to JSON */
+  toJSON() {
+    return {
+      position: [...this.position],
+      rotation: this.rotation,
+      scale: [...this.scale],
+      zIndex: this.zIndex
+    };
+  }
+  /** Create from JSON */
+  static fromJSON(t) {
+    return new $(t);
+  }
+}
+class St {
+  /** Optional transform for auto-sync via sync() */
+  transform;
+  /** Flip sprite horizontally */
+  flipX = !1;
+  /** Flip sprite vertically */
+  flipY = !1;
+  /** Alpha transparency */
+  alpha;
+  renderObject;
+  constructor(t, e = {}) {
+    this.transform = e.transform ?? null, this.alpha = e.alpha ?? 1;
+    const i = {
+      src: e.src,
+      width: e.width ?? 32,
+      height: e.height ?? 32,
+      color: e.color ?? 16711935,
+      anchor: e.anchor ?? [0.5, 0.5],
+      alpha: this.alpha,
+      zIndex: e.zIndex ?? 0
+    };
+    this.renderObject = t.createSprite(i);
+  }
+  /** Sync visual position/rotation/scale from the attached transform. */
+  sync() {
+    if (!this.transform) return;
+    const t = this.transform.worldPosition, e = this.transform.worldRotation, i = this.transform.worldScale;
+    this.renderObject.setPosition(t[0], t[1]), this.renderObject.setRotation(e);
+    const s = this.flipX ? -i[0] : i[0], o = this.flipY ? -i[1] : i[1];
+    this.renderObject.setScale(s, o), this.renderObject.setAlpha(this.alpha), this.renderObject.zIndex = this.transform.zIndex;
+  }
+  /** Manually set position. */
+  setPosition(t, e) {
+    this.renderObject.setPosition(t, e);
+  }
+  /** Manually set rotation (degrees). */
+  setRotation(t) {
+    this.renderObject.setRotation(t);
+  }
+  /** Manually set scale. */
+  setScale(t, e) {
+    this.renderObject.setScale(t, e);
+  }
+  /** Set visibility. */
+  setVisible(t) {
+    this.renderObject.setVisible(t);
+  }
+  /** Set z-index. */
+  set zIndex(t) {
+    this.renderObject.zIndex = t;
+  }
+  get zIndex() {
+    return this.renderObject.zIndex;
+  }
+  /** Destroy the sprite and remove from renderer. */
+  destroy() {
+    this.renderObject.destroy();
+  }
+}
+class Et {
+  /** Optional transform for auto-sync via sync() */
+  transform;
+  /** Flip sprite horizontally */
+  flipX = !1;
+  /** Flip sprite vertically */
+  flipY = !1;
+  /** Alpha transparency */
+  alpha;
+  /** Called when a non-looping animation reaches its last frame */
+  onAnimationComplete = null;
+  /** Called every time the displayed frame changes */
+  onFrameChange = null;
+  frameWidth;
+  frameHeight;
+  renderObject;
+  animations;
+  currentAnimation = null;
+  currentFrameIndex = 0;
+  frameAccumulator = 0;
+  isPlaying = !1;
+  sheetColumns = 1;
+  textureReady = !1;
+  constructor(t, e) {
+    if (this.transform = e.transform ?? null, this.alpha = e.alpha ?? 1, this.frameWidth = e.frameWidth, this.frameHeight = e.frameHeight, this.animations = /* @__PURE__ */ new Map(), e.animations)
+      for (const [s, o] of Object.entries(e.animations))
+        this.animations.set(s, {
+          frames: o.frames,
+          frameRate: o.frameRate ?? 12,
+          loop: o.loop ?? !0
+        });
+    const i = {
+      src: e.src,
+      frameWidth: e.frameWidth,
+      frameHeight: e.frameHeight,
+      color: e.color ?? 16711935,
+      anchor: e.anchor ?? [0.5, 0.5],
+      alpha: this.alpha,
+      zIndex: e.zIndex ?? 0,
+      onTextureReady: () => this.onTextureLoaded(e.defaultAnimation)
+    };
+    this.renderObject = t.createAnimatedSprite(i);
+  }
+  /** Must be called each frame to advance animation and sync transform. */
+  update() {
+    if (this.textureReady && this.isPlaying && this.currentAnimation) {
+      const t = this.animations.get(this.currentAnimation);
+      if (t) {
+        const e = 1 / t.frameRate;
+        for (this.frameAccumulator += C.deltaTime; this.frameAccumulator >= e; )
+          this.frameAccumulator -= e, this.advanceFrame(t);
+      }
+    }
+    this.sync();
+  }
+  /** Sync visual from attached transform. */
+  sync() {
+    if (!this.transform) return;
+    const t = this.transform.worldPosition, e = this.transform.worldRotation, i = this.transform.worldScale;
+    this.renderObject.setPosition(t[0], t[1]), this.renderObject.setRotation(e);
+    const s = this.flipX ? -i[0] : i[0], o = this.flipY ? -i[1] : i[1];
+    this.renderObject.setScale(s, o), this.renderObject.setAlpha(this.alpha), this.transform.zIndex !== void 0 && (this.renderObject.zIndex = this.transform.zIndex);
+  }
+  /** Play a named animation. */
+  playAnimation(t, e = !1) {
+    if (!this.animations.has(t)) {
+      console.warn(`Animation "${t}" not found`);
+      return;
+    }
+    this.currentAnimation === t && this.isPlaying && !e || (this.currentAnimation = t, this.currentFrameIndex = 0, this.frameAccumulator = 0, this.isPlaying = !0, this.textureReady && this.applyFrame());
+  }
+  /** Stop animation on current frame. */
+  stop() {
+    this.isPlaying = !1;
+  }
+  /** Resume playing. */
+  play() {
+    this.currentAnimation && (this.isPlaying = !0);
+  }
+  /** Jump to a specific frame. */
+  gotoFrame(t, e = !1) {
+    if (!this.currentAnimation) return;
+    const i = this.animations.get(this.currentAnimation);
+    i && (this.currentFrameIndex = Math.max(0, Math.min(t, i.frames.length - 1)), this.frameAccumulator = 0, this.isPlaying = e, this.textureReady && this.applyFrame());
+  }
+  getCurrentAnimation() {
+    return this.currentAnimation;
+  }
+  isAnimationPlaying() {
+    return this.isPlaying;
+  }
+  hasAnimation(t) {
+    return this.animations.has(t);
+  }
+  getAnimationNames() {
+    return Array.from(this.animations.keys());
+  }
+  setSheetColumns(t) {
+    this.sheetColumns = t;
+  }
+  /** Manually set position. */
+  setPosition(t, e) {
+    this.renderObject.setPosition(t, e);
+  }
+  /** Set visibility. */
+  setVisible(t) {
+    this.renderObject.setVisible(t);
+  }
+  /** Destroy and remove from renderer. */
+  destroy() {
+    this.renderObject.destroy();
+  }
+  onTextureLoaded(t) {
+    this.textureReady = !0;
+    let e = 0;
+    for (const i of this.animations.values())
+      for (const s of i.frames)
+        e = Math.max(e, s);
+    this.sheetColumns = Math.max(4, Math.ceil(Math.sqrt(e + 1))), t && this.animations.has(t) && this.playAnimation(t);
+  }
+  advanceFrame(t) {
+    const e = this.currentFrameIndex + 1;
+    if (e >= t.frames.length)
+      if (t.loop)
+        this.currentFrameIndex = 0;
+      else {
+        this.isPlaying = !1, this.onAnimationComplete?.(this.currentAnimation);
+        return;
+      }
+    else
+      this.currentFrameIndex = e;
+    this.applyFrame(), this.onFrameChange?.(this.currentFrameIndex, this.currentAnimation);
+  }
+  applyFrame() {
+    if (!this.renderObject?.setTextureRegion || !this.currentAnimation) return;
+    const t = this.animations.get(this.currentAnimation);
+    if (!t) return;
+    const e = t.frames[this.currentFrameIndex], i = e % this.sheetColumns, s = Math.floor(e / this.sheetColumns), o = i * this.frameWidth, a = s * this.frameHeight;
+    this.renderObject.setTextureRegion(o, a, this.frameWidth, this.frameHeight);
+  }
+}
+class It {
+  /** Zoom level */
+  zoom;
+  /** Follow speed */
+  followSmoothing;
+  /** Offset from target */
+  offset;
+  /** World bounds */
+  bounds;
+  /** Deadzone */
+  deadzone;
+  renderer;
+  targetFn = null;
+  currentPosition = [0, 0];
+  // Screen shake state
+  shakeIntensity = 0;
+  shakeDuration = 0;
+  shakeElapsed = 0;
+  shakeDecay = 0.9;
+  constructor(t, e) {
+    this.renderer = t, this.zoom = e?.zoom ?? 1, this.followSmoothing = e?.followSmoothing ?? 5, this.offset = e?.offset ? [...e.offset] : [0, 0], e?.bounds && (this.bounds = { ...e.bounds }), e?.deadzone && (this.deadzone = { ...e.deadzone });
+  }
+  /**
+   * Set a follow target. Takes a function that returns a position,
+   * avoiding coupling to any specific entity type.
+   */
+  follow(t) {
+    this.targetFn = t;
+    const e = t();
+    this.currentPosition = [e[0] + this.offset[0], e[1] + this.offset[1]];
+  }
+  /** Stop following. */
+  unfollow() {
+    this.targetFn = null;
+  }
+  /** Apply screen shake with intensity that decays over time. */
+  shake(t, e) {
+    this.shakeIntensity = t, this.shakeDuration = e?.duration ?? 0, this.shakeElapsed = 0, this.shakeDecay = e?.decay ?? 0.9;
+  }
+  /** Stop any active screen shake immediately. */
+  stopShake() {
+    this.shakeIntensity = 0;
+  }
+  /** Update camera (call in lateUpdate). */
+  update() {
+    let t = this.getTargetPosition();
+    this.deadzone && (t = this.applyDeadzone(t)), this.currentPosition = this.smoothFollow(t), this.bounds && (this.currentPosition = this.clampToBounds(this.currentPosition));
+    let e = this.currentPosition[0], i = this.currentPosition[1];
+    this.shakeIntensity > 0.5 && (e += (Math.random() * 2 - 1) * this.shakeIntensity, i += (Math.random() * 2 - 1) * this.shakeIntensity, this.shakeIntensity *= Math.pow(this.shakeDecay, C.deltaTime * 60), this.shakeDuration > 0 && (this.shakeElapsed += C.deltaTime, this.shakeElapsed >= this.shakeDuration && (this.shakeIntensity = 0))), this.renderer.setCameraPosition(e, i), this.renderer.setCameraZoom(this.zoom);
+  }
+  /** Instantly move camera to position (no smoothing). */
+  snapTo(t, e) {
+    this.currentPosition = [t, e], this.renderer.setCameraPosition(t, e), this.renderer.setCameraZoom(this.zoom);
+  }
+  /** Get current camera position. */
+  getPosition() {
+    return [...this.currentPosition];
+  }
+  getTargetPosition() {
+    if (this.targetFn) {
+      const t = this.targetFn();
+      return [t[0] + this.offset[0], t[1] + this.offset[1]];
+    }
+    return [...this.currentPosition];
+  }
+  smoothFollow(t) {
+    const e = Math.min(1, this.followSmoothing * C.deltaTime);
+    return [
+      this.currentPosition[0] + (t[0] - this.currentPosition[0]) * e,
+      this.currentPosition[1] + (t[1] - this.currentPosition[1]) * e
+    ];
+  }
+  applyDeadzone(t) {
+    const e = this.deadzone, i = e.width / 2, s = e.height / 2;
+    let [o, a] = t;
+    const [n, l] = this.currentPosition;
+    return o < n - i ? o = o + i : o > n + i ? o = o - i : o = n, a < l - s ? a = a + s : a > l + s ? a = a - s : a = l, [o, a];
+  }
+  clampToBounds(t) {
+    const e = this.bounds, i = this.renderer.getViewportSize(), s = i.width / 2 / this.zoom, o = i.height / 2 / this.zoom;
+    return [
+      Math.max(e.minX + s, Math.min(e.maxX - s, t[0])),
+      Math.max(e.minY + o, Math.min(e.maxY - o, t[1]))
+    ];
+  }
+}
+const Pt = {
+  // Letters
+  A: "KeyA",
+  B: "KeyB",
+  C: "KeyC",
+  D: "KeyD",
+  E: "KeyE",
+  F: "KeyF",
+  G: "KeyG",
+  H: "KeyH",
+  I: "KeyI",
+  J: "KeyJ",
+  K: "KeyK",
+  L: "KeyL",
+  M: "KeyM",
+  N: "KeyN",
+  O: "KeyO",
+  P: "KeyP",
+  Q: "KeyQ",
+  R: "KeyR",
+  S: "KeyS",
+  T: "KeyT",
+  U: "KeyU",
+  V: "KeyV",
+  W: "KeyW",
+  X: "KeyX",
+  Y: "KeyY",
+  Z: "KeyZ",
+  // Arrows
+  ArrowUp: "ArrowUp",
+  ArrowDown: "ArrowDown",
+  ArrowLeft: "ArrowLeft",
+  ArrowRight: "ArrowRight",
+  // Common
+  Space: "Space",
+  Enter: "Enter",
+  Escape: "Escape",
+  ShiftLeft: "ShiftLeft",
+  ShiftRight: "ShiftRight",
+  ControlLeft: "ControlLeft",
+  ControlRight: "ControlRight",
+  Tab: "Tab",
+  Backspace: "Backspace",
+  // Numbers
+  Digit0: "Digit0",
+  Digit1: "Digit1",
+  Digit2: "Digit2",
+  Digit3: "Digit3",
+  Digit4: "Digit4",
+  Digit5: "Digit5",
+  Digit6: "Digit6",
+  Digit7: "Digit7",
+  Digit8: "Digit8",
+  Digit9: "Digit9"
+}, N = {
+  /** Fired when audio context is unlocked by user interaction */
+  UNLOCKED: "audio:unlocked",
+  /** Fired when a volume category changes */
+  VOLUME_CHANGED: "audio:volume:changed"
+};
+class ht {
+  /** Cache of loaded sounds by path */
+  cache = /* @__PURE__ */ new Map();
+  /** Volume levels for each category */
+  volumes = {
+    master: 1,
+    music: 1,
+    sfx: 1
+  };
+  /** Whether audio context has been unlocked */
+  unlocked = !1;
+  /** Callbacks waiting for unlock */
+  unlockCallbacks = [];
+  /** Whether init has been called */
+  initialized = !1;
+  /**
+   * Initialize the audio manager.
+   * Sets up browser autoplay unlock listeners.
+   * Safe to call multiple times.
+   */
+  init() {
+    if (this.initialized) return;
+    if (this.initialized = !0, D.ctx?.state === "running") {
+      this.handleUnlock();
+      return;
+    }
+    const t = ["click", "touchstart", "keydown"], e = () => {
+      this.unlocked || (D.ctx?.state === "suspended" ? D.ctx.resume().then(() => {
+        this.handleUnlock();
+      }) : this.handleUnlock(), t.forEach((i) => {
+        document.removeEventListener(i, e, !0);
+      }));
+    };
+    t.forEach((i) => {
+      document.addEventListener(i, e, !0);
+    });
+  }
+  /** Handle successful audio unlock */
+  handleUnlock() {
+    this.unlocked = !0;
+    for (const t of this.unlockCallbacks)
+      try {
+        t();
+      } catch (e) {
+        console.error("Error in audio unlock callback:", e);
+      }
+    this.unlockCallbacks = [], B.emit(N.UNLOCKED);
+  }
+  /**
+   * Set volume for a category.
+   * @param category - The volume category
+   * @param value - Volume level (0-1)
+   */
+  setVolume(t, e) {
+    this.volumes[t] = Math.max(0, Math.min(1, e)), t === "master" && D.volume(this.volumes.master), B.emit(N.VOLUME_CHANGED, { category: t, value: this.volumes[t] });
+  }
+  /**
+   * Get volume for a category.
+   * @param category - The volume category
+   * @returns Volume level (0-1)
+   */
+  getVolume(t) {
+    return this.volumes[t];
+  }
+  /**
+   * Get effective volume for a category (master * category).
+   * @param category - The volume category
+   * @returns Effective volume level (0-1)
+   */
+  getEffectiveVolume(t) {
+    return t === "master" ? this.volumes.master : this.volumes.master * this.volumes[t];
+  }
+  /**
+   * Preload audio files.
+   * @param paths - Array of audio file paths to preload
+   * @returns Promise that resolves when all files are loaded
+   */
+  async preload(t) {
+    const e = t.map((i) => this.getSound(i));
+    await Promise.all(e);
+  }
+  /**
+   * Get or load a sound (async).
+   * @param path - Path to the audio file
+   * @returns Promise that resolves to the Howl instance
+   */
+  async getSound(t) {
+    const e = this.cache.get(t);
+    return e || new Promise((i, s) => {
+      const o = new X({
+        src: [t],
+        preload: !0,
+        onload: () => {
+          this.cache.set(t, o), i(o);
+        },
+        onloaderror: (a, n) => {
+          console.error(`Failed to load audio: ${t}`, n), s(new Error(`Failed to load audio: ${t}`));
+        }
+      });
+    });
+  }
+  /**
+   * Get cached sound (sync).
+   * Returns null if not loaded.
+   * @param path - Path to the audio file
+   * @returns Howl instance or null
+   */
+  getSoundSync(t) {
+    return this.cache.get(t) ?? null;
+  }
+  /**
+   * Check if audio context is unlocked.
+   * @returns True if audio can play without user interaction
+   */
+  isUnlocked() {
+    return this.unlocked;
+  }
+  /**
+   * Register a callback for when audio is unlocked.
+   * Calls immediately if already unlocked.
+   * @param callback - Function to call when unlocked
+   */
+  onUnlock(t) {
+    this.unlocked ? t() : this.unlockCallbacks.push(t);
+  }
+  /**
+   * Unload a specific sound from cache.
+   * @param path - Path to the audio file
+   */
+  unload(t) {
+    const e = this.cache.get(t);
+    e && (e.unload(), this.cache.delete(t));
+  }
+  /**
+   * Destroy and cleanup all sounds.
+   */
+  destroy() {
+    for (const t of this.cache.values())
+      t.unload();
+    this.cache.clear(), this.unlockCallbacks = [];
+  }
+  /**
+   * Pause all sounds.
+   */
+  pauseAll() {
+    for (const t of this.cache.values())
+      t.pause();
+  }
+  /**
+   * Resume all sounds that were playing.
+   */
+  resumeAll() {
+    for (const t of this.cache.values()) {
+      if (t.playing()) continue;
+      const e = t.seek();
+      typeof e == "number" && e > 0 && t.play();
+    }
+  }
+  /**
+   * Stop all sounds.
+   */
+  stopAll() {
+    for (const t of this.cache.values())
+      t.stop();
+  }
+}
+const G = new ht();
+function v() {
+  return G;
+}
+class Dt {
+  /** Audio file source path */
+  src;
+  /** Base volume (0-1) */
+  volume;
+  /** Whether to loop */
+  loop;
+  /** Volume category */
+  category;
+  /** Spatial audio enabled */
+  spatial;
+  /** Minimum distance for full volume */
+  minDistance;
+  /** Maximum distance before silent */
+  maxDistance;
+  sound = null;
+  soundId = null;
+  effectiveVolume = 1;
+  _transform = null;
+  constructor(t) {
+    this.src = t?.src ?? "", this.volume = t?.volume ?? 1, this.loop = t?.loop ?? !1, this.category = t?.category ?? "sfx", this.spatial = t?.spatial ?? !1, this.minDistance = t?.minDistance ?? 100, this.maxDistance = t?.maxDistance ?? 500;
+  }
+  /** Set the transform for spatial audio positioning. */
+  setTransform(t) {
+    this._transform = t;
+  }
+  /** Load the audio file. Call before play(). */
+  async load() {
+    if (G.init(), this.src)
+      try {
+        this.sound = await v().getSound(this.src);
+      } catch (t) {
+        console.error(`AudioSource: Failed to load ${this.src}`, t);
+      }
+  }
+  /** Play the sound. */
+  play() {
+    if (!this.sound) {
+      console.warn("AudioSource: No sound loaded");
+      return;
+    }
+    this.soundId !== null && this.sound.stop(this.soundId), this.effectiveVolume = this.volume * v().getEffectiveVolume(this.category), this.sound.loop(this.loop), this.soundId = this.sound.play(), this.sound.volume(this.effectiveVolume, this.soundId), this.spatial && this.updateSpatialAudio(null);
+  }
+  /** Pause playback. */
+  pause() {
+    this.sound && this.soundId !== null && this.sound.pause(this.soundId);
+  }
+  /** Stop playback and reset. */
+  stop() {
+    this.sound && this.soundId !== null && (this.sound.stop(this.soundId), this.soundId = null);
+  }
+  /** Resume paused playback. */
+  resume() {
+    this.sound && this.soundId !== null && this.sound.play(this.soundId);
+  }
+  /** Seek to a specific time in seconds. */
+  seek(t) {
+    this.sound && this.soundId !== null && this.sound.seek(t, this.soundId);
+  }
+  /** Fade volume over time. */
+  fade(t, e, i) {
+    if (this.sound && this.soundId !== null) {
+      const s = t * v().getEffectiveVolume(this.category), o = e * v().getEffectiveVolume(this.category);
+      this.sound.fade(s, o, i, this.soundId);
+    }
+  }
+  /** Check if currently playing. */
+  get playing() {
+    return !this.sound || this.soundId === null ? !1 : this.sound.playing(this.soundId);
+  }
+  /** Get current playback time in seconds. */
+  getTime() {
+    if (!this.sound || this.soundId === null) return 0;
+    const t = this.sound.seek(this.soundId);
+    return typeof t == "number" ? t : 0;
+  }
+  /** Get total duration in seconds. */
+  getDuration() {
+    return this.sound ? this.sound.duration() : 0;
+  }
+  /** Play a one-shot sound. */
+  async playOneShot(t) {
+    const e = t ?? this.src;
+    if (e)
+      try {
+        const i = await v().getSound(e), s = this.volume * v().getEffectiveVolume(this.category), o = i.play();
+        i.volume(s, o);
+      } catch (i) {
+        console.error(`AudioSource: Failed to play one-shot ${e}`, i);
+      }
+  }
+  /** Update spatial audio (call each frame if spatial is enabled). */
+  updateSpatialAudio(t) {
+    if (!this.sound || this.soundId === null || !t || !this._transform) return;
+    const e = t.getViewportSize(), i = t.getCameraPosition(), s = this._transform.worldPosition, o = s[0] - i.x, a = s[1] - i.y, n = Math.sqrt(o * o + a * a), l = e.width / 2, h = Math.max(-1, Math.min(1, o / l));
+    let u = 1;
+    if (n > this.minDistance)
+      if (n >= this.maxDistance)
+        u = 0;
+      else {
+        const p = this.maxDistance - this.minDistance;
+        u = 1 - (n - this.minDistance) / p;
+      }
+    this.sound.stereo(h, this.soundId), this.sound.volume(this.effectiveVolume * u, this.soundId);
+  }
+  /** Destroy and clean up. */
+  destroy() {
+    this.stop(), this.sound = null;
+  }
+}
+const dt = Math.PI / 180, V = 180 / Math.PI, zt = {
+  // Creation
+  zero: () => [0, 0],
+  one: () => [1, 1],
+  from: (r, t) => [r, t],
+  // Arithmetic
+  add: (r, t) => [r[0] + t[0], r[1] + t[1]],
+  sub: (r, t) => [r[0] - t[0], r[1] - t[1]],
+  scale: (r, t) => [r[0] * t, r[1] * t],
+  mul: (r, t) => [r[0] * t[0], r[1] * t[1]],
+  negate: (r) => [-r[0], -r[1]],
+  // Geometry
+  length: (r) => Math.sqrt(r[0] * r[0] + r[1] * r[1]),
+  lengthSq: (r) => r[0] * r[0] + r[1] * r[1],
+  distance: (r, t) => {
+    const e = t[0] - r[0], i = t[1] - r[1];
+    return Math.sqrt(e * e + i * i);
+  },
+  distanceSq: (r, t) => {
+    const e = t[0] - r[0], i = t[1] - r[1];
+    return e * e + i * i;
+  },
+  normalize: (r) => {
+    const t = Math.sqrt(r[0] * r[0] + r[1] * r[1]);
+    return t === 0 ? [0, 0] : [r[0] / t, r[1] / t];
+  },
+  dot: (r, t) => r[0] * t[0] + r[1] * t[1],
+  cross: (r, t) => r[0] * t[1] - r[1] * t[0],
+  // Interpolation
+  lerp: (r, t, e) => [
+    r[0] + (t[0] - r[0]) * e,
+    r[1] + (t[1] - r[1]) * e
+  ],
+  // Transformation
+  rotate: (r, t) => {
+    const e = t * dt, i = Math.cos(e), s = Math.sin(e);
+    return [r[0] * i - r[1] * s, r[0] * s + r[1] * i];
+  },
+  reflect: (r, t) => {
+    const e = 2 * (r[0] * t[0] + r[1] * t[1]);
+    return [r[0] - e * t[0], r[1] - e * t[1]];
+  },
+  perpendicular: (r) => [-r[1], r[0]],
+  // Comparison
+  equals: (r, t, e = 1e-6) => Math.abs(r[0] - t[0]) <= e && Math.abs(r[1] - t[1]) <= e,
+  // Utility
+  angle: (r) => Math.atan2(r[1], r[0]) * V,
+  angleBetween: (r, t) => {
+    const e = Math.sqrt(r[0] * r[0] + r[1] * r[1]), i = Math.sqrt(t[0] * t[0] + t[1] * t[1]);
+    if (e === 0 || i === 0) return 0;
+    const s = r[0] * t[0] + r[1] * t[1], o = Math.max(-1, Math.min(1, s / (e * i)));
+    return Math.acos(o) * V;
+  },
+  clampLength: (r, t) => {
+    const e = r[0] * r[0] + r[1] * r[1];
+    if (e <= t * t) return [r[0], r[1]];
+    const i = Math.sqrt(e);
+    return [r[0] / i * t, r[1] / i * t];
+  }
+};
+let ct = 1;
+class P {
+  // ==================== Identity ====================
+  /** Unique identifier for this element */
+  id;
+  /** Human-readable name for debugging */
+  name;
+  // ==================== Positioning ====================
+  /**
+   * Anchor point determines where the element attaches to its parent/screen.
+   *
+   * The anchor affects both:
+   * 1. Which point on the parent/screen we measure from
+   * 2. Which point on this element is placed at that location
+   *
+   * Example: anchor='bottom-right' means:
+   * - Reference the parent's bottom-right corner
+   * - Place this element's bottom-right corner there
+   * - Offset moves the element up and left (into the parent)
+   */
+  anchor = "top-left";
+  /**
+   * Pixel offset from the anchor point.
+   * Positive values move right/down from the anchor.
+   */
+  offset = [0, 0];
+  /**
+   * Requested size in pixels [width, height].
+   * 0 = auto-size to content (uses measureContent())
+   */
+  size = [0, 0];
+  // ==================== Computed Layout ====================
+  /**
+   * Computed position after layout pass (screen coordinates).
+   * Set by parent or UIManager during layout().
+   */
+  computedPosition = [0, 0];
+  /**
+   * Computed size after layout pass.
+   * Either explicit size or measureContent() result.
+   */
+  computedSize = [0, 0];
+  // ==================== Visual Properties ====================
+  /** Whether this element is visible */
+  visible = !0;
+  /** Opacity (0-1) */
+  alpha = 1;
+  /** Render order within parent (higher = on top) */
+  zIndex = 0;
+  // ==================== Hierarchy ====================
+  /** Parent element (null for root elements) */
+  parent = null;
+  /** Child elements */
+  children = [];
+  // ==================== PixiJS ====================
+  /**
+   * The PixiJS container for this element.
+   * Subclasses add their visual content (Graphics, Text, Sprite) to this.
+   */
+  displayObject;
+  // ==================== Layout State ====================
+  /**
+   * Whether layout needs to be recalculated.
+   * Set to true when properties change that affect layout.
+   */
+  layoutDirty = !0;
+  // ==================== Constructor ====================
+  constructor(t = {}) {
+    this.id = t.id ?? `ui_${ct++}`, this.name = t.name ?? this.id, t.anchor !== void 0 && (this.anchor = t.anchor), t.offset !== void 0 && (this.offset = [...t.offset]), t.size !== void 0 && (this.size = [...t.size]), t.visible !== void 0 && (this.visible = t.visible), t.alpha !== void 0 && (this.alpha = t.alpha), t.zIndex !== void 0 && (this.zIndex = t.zIndex), this.displayObject = new A(), this.displayObject.sortableChildren = !0;
+  }
+  // ==================== Lifecycle ====================
+  /**
+   * Called when the element is first added to the UI hierarchy.
+   * Override to perform one-time initialization.
+   */
+  awake() {
+  }
+  /**
+   * Called every frame.
+   * Override for per-frame logic (animations, state updates).
+   */
+  update() {
+  }
+  /**
+   * Called when the element is removed from the UI hierarchy.
+   * Override to clean up resources.
+   */
+  onDestroy() {
+  }
+  // ==================== Hierarchy Management ====================
+  /**
+   * Add a child element.
+   */
+  addChild(t) {
+    t.parent && t.parent.removeChild(t), t.parent = this, this.children.push(t), this.displayObject.addChild(t.displayObject), t.awake(), this.markLayoutDirty();
+  }
+  /**
+   * Remove a child element.
+   */
+  removeChild(t) {
+    const e = this.children.indexOf(t);
+    e !== -1 && (t.onDestroy(), t.parent = null, this.children.splice(e, 1), this.displayObject.removeChild(t.displayObject), this.markLayoutDirty());
+  }
+  /**
+   * Remove all children.
+   */
+  removeAllChildren() {
+    for (const t of [...this.children])
+      this.removeChild(t);
+  }
+  /**
+   * Get all children.
+   */
+  getChildren() {
+    return this.children;
+  }
+  /**
+   * Get the PixiJS display object.
+   * Used by UIManager to add to render tree.
+   */
+  getDisplayObject() {
+    return this.displayObject;
+  }
+  // ==================== Layout ====================
+  /**
+   * Mark this element and its ancestors as needing layout recalculation.
+   */
+  markLayoutDirty() {
+    this.layoutDirty = !0, this.parent && this.parent.markLayoutDirty();
+  }
+  /**
+   * Measure the intrinsic content size.
+   * Override in subclasses to return the natural size of the content.
+   *
+   * Examples:
+   * - UIText: Returns the text bounds
+   * - UIImage: Returns the image dimensions
+   * - UIPanel: Returns size needed to contain children + padding
+   *
+   * @returns [width, height] in pixels
+   */
+  measureContent() {
+    return [0, 0];
+  }
+  /**
+   * Compute layout for this element and its children.
+   * Called by UIManager each frame on root elements.
+   *
+   * @param viewport - The available space (screen or parent bounds)
+   */
+  layout(t) {
+    const e = this.measureContent();
+    this.computedSize = [
+      this.size[0] > 0 ? this.size[0] : e[0],
+      this.size[1] > 0 ? this.size[1] : e[1]
+    ], this.computedPosition = this.computeAnchoredPosition(t), this.displayObject.position.set(this.computedPosition[0], this.computedPosition[1]), this.displayObject.alpha = this.alpha, this.displayObject.visible = this.visible, this.displayObject.zIndex = this.zIndex, this.layoutChildren(t), this.layoutDirty = !1;
+  }
+  /**
+   * Layout child elements.
+   * Override in VBox/HBox to implement custom layout logic.
+   */
+  layoutChildren(t) {
+    for (const e of this.children)
+      e.layout({
+        width: this.computedSize[0],
+        height: this.computedSize[1]
+      });
+  }
+  /**
+   * Compute position based on anchor point and offset.
+   *
+   * The anchor system works like this:
+   * ┌─────────────────────────────────────────┐
+   * │ (0,0)           (w/2,0)           (w,0) │
+   * │ top-left      top-center      top-right │
+   * │                                         │
+   * │ (0,h/2)       (w/2,h/2)       (w,h/2)   │
+   * │ center-left    center    center-right   │
+   * │                                         │
+   * │ (0,h)         (w/2,h)         (w,h)     │
+   * │ bottom-left bottom-center bottom-right  │
+   * └─────────────────────────────────────────┘
+   */
+  computeAnchoredPosition(t) {
+    const { width: e, height: i } = t, [s, o] = this.computedSize, [a, n] = this.offset;
+    let l = 0, h = 0;
+    return this.anchor.includes("left") ? l = a : this.anchor.includes("right") ? l = e - s - a : l = (e - s) / 2 + a, this.anchor.includes("top") ? h = n : this.anchor.includes("bottom") ? h = i - o - n : h = (i - o) / 2 + n, [l, h];
+  }
+  // ==================== Hit Testing ====================
+  /**
+   * Get the world/screen position of this element.
+   *
+   * For nested elements, computedPosition is in LOCAL coordinates (relative to parent).
+   * This method walks up the parent chain to compute the absolute screen position.
+   *
+   * Example:
+   * - Panel at screen position (600, 400)
+   *   - Button at local position (10, 10)
+   *   - Button's world position = (610, 410)
+   */
+  getWorldPosition() {
+    let t = this.computedPosition[0], e = this.computedPosition[1], i = this.parent;
+    for (; i; )
+      t += i.computedPosition[0], e += i.computedPosition[1], i = i.parent;
+    return [t, e];
+  }
+  /**
+   * Check if a screen point is inside this element's bounds.
+   * Uses world position for accurate hit testing of nested elements.
+   */
+  containsPoint(t) {
+    if (!this.visible) return !1;
+    const [e, i] = t, [s, o] = this.getWorldPosition(), [a, n] = this.computedSize;
+    return e >= s && e <= s + a && i >= o && i <= o + n;
+  }
+  /**
+   * Find the topmost element at a screen point.
+   * Searches children first (in reverse z-order) then self.
+   */
+  hitTest(t) {
+    if (!this.visible) return null;
+    const e = [...this.children].sort((i, s) => s.zIndex - i.zIndex);
+    for (const i of e) {
+      const s = i.hitTest(t);
+      if (s) return s;
+    }
+    return this.containsPoint(t) ? this : null;
+  }
+  // ==================== Getters ====================
+  /** Get computed position after layout */
+  getComputedPosition() {
+    return [...this.computedPosition];
+  }
+  /**
+   * Offset the computed position after layout.
+   * Used by layout containers (UIPanel) to adjust child positions for padding.
+   * This keeps computedPosition in sync with displayObject.position.
+   */
+  offsetComputedPosition(t, e) {
+    this.computedPosition[0] += t, this.computedPosition[1] += e;
+  }
+  /**
+   * Set the computed position directly.
+   * Used by layout containers (UIVBox, UIHBox) that completely override child positioning.
+   * Also updates the displayObject position.
+   */
+  setComputedPosition(t, e) {
+    this.computedPosition[0] = t, this.computedPosition[1] = e, this.displayObject.position.set(t, e);
+  }
+  /** Get computed size after layout */
+  getComputedSize() {
+    return [...this.computedSize];
+  }
+  /** Get computed bounds as {x, y, width, height} */
+  getComputedBounds() {
+    return {
+      x: this.computedPosition[0],
+      y: this.computedPosition[1],
+      width: this.computedSize[0],
+      height: this.computedSize[1]
+    };
+  }
+  // ==================== Destruction ====================
+  /**
+   * Destroy this element and all children.
+   */
+  destroy() {
+    for (const t of [...this.children])
+      t.destroy();
+    this.children = [], this.onDestroy(), this.parent && this.parent.removeChild(this), this.displayObject.destroy({ children: !0 });
+  }
+}
+function z(r) {
+  return "onPointerEnter" in r || "onPointerExit" in r || "onPointerDown" in r || "onPointerUp" in r;
+}
+class _t {
+  /** Root UI elements (not parented to other UI elements) */
+  roots = [];
+  /** Reference to the renderer for viewport size */
+  renderer;
+  /** Currently hovered element */
+  hoveredElement = null;
+  /** Currently pressed element (mouse button held) */
+  pressedElement = null;
+  /** Whether the UI system is active */
+  active = !0;
+  constructor(t) {
+    this.renderer = t;
+  }
+  // ==================== Root Management ====================
+  /**
+   * Add a root UI element.
+   * Root elements are positioned relative to the screen.
+   */
+  addRoot(t) {
+    if (this.roots.includes(t)) {
+      console.warn(`UIElement ${t.id} is already a root`);
+      return;
+    }
+    this.roots.push(t), this.renderer.addToUI(t.getDisplayObject()), t.awake();
+  }
+  /**
+   * Remove a root UI element.
+   */
+  removeRoot(t) {
+    const e = this.roots.indexOf(t);
+    e !== -1 && (this.roots.splice(e, 1), this.renderer.removeFromUI(t.getDisplayObject()), t.onDestroy());
+  }
+  /**
+   * Get all root elements.
+   */
+  getRoots() {
+    return this.roots;
+  }
+  // ==================== Input Processing ====================
+  /**
+   * Process input events for the UI.
+   * Call this BEFORE game input processing.
+   *
+   * @returns true if UI consumed the input (game should ignore it)
+   */
+  processInput() {
+    if (!this.active) return !1;
+    const t = y.mousePosition;
+    let e = !1;
+    const i = this.hitTestAll(t);
+    if (i !== this.hoveredElement) {
+      if (this.hoveredElement && z(this.hoveredElement)) {
+        const s = this.createPointerEvent(t);
+        this.hoveredElement.onPointerExit?.(s);
+      }
+      if (i && z(i)) {
+        const s = this.createPointerEvent(t);
+        i.onPointerEnter?.(s);
+      }
+      this.hoveredElement = i;
+    }
+    if (y.getMouseButtonDown(0) && i && z(i)) {
+      this.pressedElement = i;
+      const s = this.createPointerEvent(t, 0);
+      i.onPointerDown?.(s), e = s.consumed || !0;
+    }
+    if (y.getMouseButtonUp(0)) {
+      if (this.pressedElement && z(this.pressedElement)) {
+        const s = this.createPointerEvent(t, 0);
+        this.pressedElement.onPointerUp?.(s), e = s.consumed || e;
+      }
+      this.pressedElement = null;
+    }
+    return i && (e = !0), e;
+  }
+  /**
+   * Hit test all root elements.
+   * Returns the topmost element at the given point.
+   */
+  hitTestAll(t) {
+    const e = [...this.roots].sort((i, s) => s.zIndex - i.zIndex);
+    for (const i of e) {
+      const s = i.hitTest(t);
+      if (s) return s;
+    }
+    return null;
+  }
+  /**
+   * Create a pointer event object.
+   */
+  createPointerEvent(t, e = 0) {
+    return {
+      position: [...t],
+      button: e,
+      consumed: !1
+    };
+  }
+  // ==================== Update & Layout ====================
+  /**
+   * Update all UI elements.
+   * Call once per frame.
+   */
+  update() {
+    if (this.active)
+      for (const t of this.roots)
+        this.updateElement(t);
+  }
+  /**
+   * Recursively update an element and its children.
+   */
+  updateElement(t) {
+    t.update();
+    for (const e of t.getChildren())
+      this.updateElement(e);
+  }
+  /**
+   * Run layout pass on all root elements.
+   * Call once per frame after update.
+   */
+  layout() {
+    if (!this.active) return;
+    const t = this.renderer.getViewportSize();
+    for (const e of this.roots)
+      e.layout(t);
+  }
+  // ==================== Lifecycle ====================
+  /**
+   * Enable or disable the UI system.
+   */
+  setActive(t) {
+    this.active = t;
+  }
+  /**
+   * Check if the UI system is active.
+   */
+  isActive() {
+    return this.active;
+  }
+  /**
+   * Destroy the UI manager and all root elements.
+   */
+  destroy() {
+    for (const t of [...this.roots])
+      t.destroy(), this.renderer.removeFromUI(t.getDisplayObject());
+    this.roots = [], this.hoveredElement = null, this.pressedElement = null;
+  }
+  // ==================== Utilities ====================
+  /**
+   * Find a UI element by ID.
+   */
+  findById(t) {
+    for (const e of this.roots) {
+      const i = this.findByIdInTree(e, t);
+      if (i) return i;
+    }
+    return null;
+  }
+  /**
+   * Recursively search for an element by ID.
+   */
+  findByIdInTree(t, e) {
+    if (t.id === e) return t;
+    for (const i of t.getChildren()) {
+      const s = this.findByIdInTree(i, e);
+      if (s) return s;
+    }
+    return null;
+  }
+  /**
+   * Find a UI element by name.
+   */
+  findByName(t) {
+    for (const e of this.roots) {
+      const i = this.findByNameInTree(e, t);
+      if (i) return i;
+    }
+    return null;
+  }
+  /**
+   * Recursively search for an element by name.
+   */
+  findByNameInTree(t, e) {
+    if (t.name === e) return t;
+    for (const i of t.getChildren()) {
+      const s = this.findByNameInTree(i, e);
+      if (s) return s;
+    }
+    return null;
+  }
+}
+class Bt extends P {
+  /** The PixiJS Text object */
+  textDisplay;
+  /** Current text style settings */
+  _text;
+  _fontSize;
+  _fontFamily;
+  _color;
+  _fontWeight;
+  _align;
+  _wordWrapWidth;
+  constructor(t = {}) {
+    super(t), this._text = t.text ?? "", this._fontSize = t.fontSize ?? 16, this._fontFamily = t.fontFamily ?? "Arial, sans-serif", this._color = t.color ?? "#ffffff", this._fontWeight = t.fontWeight ?? "normal", this._align = t.align ?? "left", this._wordWrapWidth = t.wordWrapWidth ?? 0;
+    const e = this.createStyle();
+    this.textDisplay = new q({ text: this._text, style: e }), this.displayObject.addChild(this.textDisplay);
+  }
+  // ==================== Text Properties ====================
+  /** Get the current text content */
+  get text() {
+    return this._text;
+  }
+  /** Set the text content */
+  set text(t) {
+    this._text !== t && (this._text = t, this.textDisplay.text = t, this.markLayoutDirty());
+  }
+  /** Get font size in pixels */
+  get fontSize() {
+    return this._fontSize;
+  }
+  /** Set font size in pixels */
+  set fontSize(t) {
+    this._fontSize !== t && (this._fontSize = t, this.updateStyle(), this.markLayoutDirty());
+  }
+  /** Get font family */
+  get fontFamily() {
+    return this._fontFamily;
+  }
+  /** Set font family */
+  set fontFamily(t) {
+    this._fontFamily !== t && (this._fontFamily = t, this.updateStyle(), this.markLayoutDirty());
+  }
+  /** Get text color */
+  get color() {
+    return this._color;
+  }
+  /** Set text color */
+  set color(t) {
+    this._color !== t && (this._color = t, this.updateStyle());
+  }
+  /** Get font weight */
+  get fontWeight() {
+    return this._fontWeight;
+  }
+  /** Set font weight */
+  set fontWeight(t) {
+    this._fontWeight !== t && (this._fontWeight = t, this.updateStyle(), this.markLayoutDirty());
+  }
+  /** Get text alignment */
+  get align() {
+    return this._align;
+  }
+  /** Set text alignment */
+  set align(t) {
+    this._align !== t && (this._align = t, this.updateStyle());
+  }
+  /** Get word wrap width (0 = no wrap) */
+  get wordWrapWidth() {
+    return this._wordWrapWidth;
+  }
+  /** Set word wrap width (0 = no wrap) */
+  set wordWrapWidth(t) {
+    this._wordWrapWidth !== t && (this._wordWrapWidth = t, this.updateStyle(), this.markLayoutDirty());
+  }
+  // ==================== Internal ====================
+  /**
+   * Create a PixiJS TextStyle from our properties.
+   */
+  createStyle() {
+    const t = typeof this._fontWeight == "number" ? this._fontWeight >= 600 ? "bold" : "normal" : this._fontWeight;
+    return new Z({
+      fontFamily: this._fontFamily,
+      fontSize: this._fontSize,
+      fontWeight: t,
+      fill: this._color,
+      align: this._align,
+      wordWrap: this._wordWrapWidth > 0,
+      wordWrapWidth: this._wordWrapWidth || void 0
+    });
+  }
+  /**
+   * Update the text style when properties change.
+   */
+  updateStyle() {
+    this.textDisplay.style = this.createStyle();
+  }
+  // ==================== Layout ====================
+  /**
+   * Measure the text bounds as the content size.
+   */
+  measureContent() {
+    const t = this.textDisplay.getBounds();
+    return [t.width, t.height];
+  }
+}
+class At extends P {
+  /** The PixiJS Sprite or placeholder Graphics */
+  imageDisplay;
+  /** Image source path */
+  _src;
+  /** Explicit width (0 = use image width) */
+  _width;
+  /** Explicit height (0 = use image height) */
+  _height;
+  /** Tint color */
+  _tint;
+  /** Whether the texture has loaded */
+  textureLoaded = !1;
+  /** Natural image dimensions */
+  naturalWidth = 0;
+  naturalHeight = 0;
+  constructor(t = {}) {
+    super(t), this._src = t.src ?? "", this._width = t.width ?? 0, this._height = t.height ?? 0, this._tint = t.tint ?? 16777215;
+    const e = this._width || 32, i = this._height || 32, s = new I();
+    s.rect(0, 0, e, i), s.fill(8947848), this.imageDisplay = s, this.displayObject.addChild(this.imageDisplay), this._src && this.loadTexture(this._src);
+  }
+  // ==================== Properties ====================
+  /** Get the image source path */
+  get src() {
+    return this._src;
+  }
+  /** Set the image source path (triggers async load) */
+  set src(t) {
+    this._src !== t && (this._src = t, this.textureLoaded = !1, t && this.loadTexture(t));
+  }
+  /** Get explicit width */
+  get width() {
+    return this._width;
+  }
+  /** Set explicit width (0 = use natural width) */
+  set width(t) {
+    this._width !== t && (this._width = t, this.updateImageSize(), this.markLayoutDirty());
+  }
+  /** Get explicit height */
+  get height() {
+    return this._height;
+  }
+  /** Set explicit height (0 = use natural height) */
+  set height(t) {
+    this._height !== t && (this._height = t, this.updateImageSize(), this.markLayoutDirty());
+  }
+  /** Get tint color */
+  get tint() {
+    return this._tint;
+  }
+  /** Set tint color */
+  set tint(t) {
+    this._tint = t, this.imageDisplay instanceof S && (this.imageDisplay.tint = t);
+  }
+  // ==================== Internal ====================
+  /**
+   * Load a texture from the given path.
+   */
+  async loadTexture(t) {
+    try {
+      const e = await K.load(t);
+      e && e !== E.WHITE && this._src === t && this.replaceWithSprite(e);
+    } catch {
+      console.warn(`UIImage: Failed to load texture: ${t}`);
+    }
+  }
+  /**
+   * Replace the placeholder with a loaded sprite.
+   */
+  replaceWithSprite(t) {
+    this.naturalWidth = t.width, this.naturalHeight = t.height;
+    const e = new S(t);
+    e.tint = this._tint, this.displayObject.removeChild(this.imageDisplay), this.imageDisplay instanceof I && this.imageDisplay.destroy(), this.imageDisplay = e, this.displayObject.addChild(e), this.textureLoaded = !0, this.updateImageSize(), this.markLayoutDirty();
+  }
+  /**
+   * Update the sprite size based on explicit dimensions.
+   */
+  updateImageSize() {
+    if (!(this.imageDisplay instanceof S)) return;
+    const t = this._width || this.naturalWidth, e = this._height || this.naturalHeight;
+    this.imageDisplay.width = t, this.imageDisplay.height = e;
+  }
+  // ==================== Layout ====================
+  /**
+   * Measure the image dimensions as content size.
+   */
+  measureContent() {
+    return this.textureLoaded ? [
+      this._width || this.naturalWidth,
+      this._height || this.naturalHeight
+    ] : [this._width || 32, this._height || 32];
+  }
+}
+class ut extends P {
+  /** The PixiJS Graphics for background rendering */
+  background;
+  /** Background color (protected for subclass access) */
+  _backgroundColor;
+  /** Border color */
+  _borderColor;
+  /** Border width in pixels */
+  _borderWidth;
+  /** Corner radius for rounded rectangles */
+  _borderRadius;
+  /** Inner padding [top, right, bottom, left] */
+  _padding;
+  constructor(t = {}) {
+    super(t), this._backgroundColor = t.backgroundColor ?? 3355443, this._borderColor = t.borderColor ?? 0, this._borderWidth = t.borderWidth ?? 0, this._borderRadius = t.borderRadius ?? 0, this._padding = t.padding ?? [0, 0, 0, 0], this.background = new I(), this.background.zIndex = -1, this.displayObject.addChild(this.background);
+  }
+  // ==================== Properties ====================
+  /** Get background color */
+  get backgroundColor() {
+    return this._backgroundColor;
+  }
+  /** Set background color */
+  set backgroundColor(t) {
+    this._backgroundColor !== t && (this._backgroundColor = t, this.redrawBackground());
+  }
+  /** Get border color */
+  get borderColor() {
+    return this._borderColor;
+  }
+  /** Set border color */
+  set borderColor(t) {
+    this._borderColor !== t && (this._borderColor = t, this.redrawBackground());
+  }
+  /** Get border width */
+  get borderWidth() {
+    return this._borderWidth;
+  }
+  /** Set border width */
+  set borderWidth(t) {
+    this._borderWidth !== t && (this._borderWidth = t, this.redrawBackground(), this.markLayoutDirty());
+  }
+  /** Get border radius */
+  get borderRadius() {
+    return this._borderRadius;
+  }
+  /** Set border radius */
+  set borderRadius(t) {
+    this._borderRadius !== t && (this._borderRadius = t, this.redrawBackground());
+  }
+  /** Get padding */
+  get padding() {
+    return [...this._padding];
+  }
+  /** Set padding [top, right, bottom, left] */
+  set padding(t) {
+    this._padding = [...t], this.markLayoutDirty();
+  }
+  // ==================== Internal ====================
+  /**
+   * Get the inner bounds (after padding).
+   */
+  getInnerBounds() {
+    const [t, e, i, s] = this._padding;
+    return {
+      x: s,
+      y: t,
+      width: Math.max(0, this.computedSize[0] - s - e),
+      height: Math.max(0, this.computedSize[1] - t - i)
+    };
+  }
+  /**
+   * Redraw the background graphics.
+   */
+  redrawBackground() {
+    const [t, e] = this.computedSize;
+    if (!(t <= 0 || e <= 0))
+      if (this.background.clear(), this._borderWidth > 0) {
+        this.background.roundRect(0, 0, t, e, this._borderRadius), this.background.fill(this._borderColor);
+        const i = this._borderWidth, s = Math.max(0, this._borderRadius - i);
+        this.background.roundRect(i, i, t - i * 2, e - i * 2, s), this.background.fill(this._backgroundColor);
+      } else
+        this.background.roundRect(0, 0, t, e, this._borderRadius), this.background.fill(this._backgroundColor);
+  }
+  // ==================== Layout ====================
+  /**
+   * Measure content size (size needed to contain children + padding).
+   */
+  measureContent() {
+    const [t, e, i, s] = this._padding;
+    let o = 0, a = 0;
+    for (const n of this.children) {
+      const l = n.getComputedSize(), h = n.getComputedPosition();
+      o = Math.max(o, h[0] + l[0]), a = Math.max(a, h[1] + l[1]);
+    }
+    return [o + s + e, a + t + i];
+  }
+  /**
+   * Override layout to position children within padding and redraw background.
+   */
+  layout(t) {
+    super.layout(t), this.redrawBackground();
+  }
+  /**
+   * Layout children within the padded content area.
+   */
+  layoutChildren(t) {
+    const e = this.getInnerBounds();
+    for (const i of this.children) {
+      i.layout({ width: e.width, height: e.height });
+      const s = i.getDisplayObject();
+      s.position.x += e.x, s.position.y += e.y, i.offsetComputedPosition(e.x, e.y);
+    }
+  }
+}
+class Ot extends ut {
+  /** Current button state */
+  _state = "normal";
+  /** Click handler */
+  _onClick;
+  /** Color when hovered */
+  _hoverColor;
+  /** Color when pressed */
+  _pressedColor;
+  /** Color when disabled */
+  _disabledColor;
+  /** Whether the button is disabled */
+  _disabled;
+  /** Store the normal background color for state changes */
+  _normalColor;
+  constructor(t = {}) {
+    super(t), this._onClick = t.onClick ?? null, this._normalColor = t.backgroundColor ?? 3355443, this._hoverColor = t.hoverColor ?? this.lightenColor(this._normalColor, 0.2), this._pressedColor = t.pressedColor ?? this.darkenColor(this._normalColor, 0.2), this._disabledColor = t.disabledColor ?? 6710886, this._disabled = t.disabled ?? !1, this.updateVisualState();
+  }
+  // ==================== Properties ====================
+  /** Get current button state */
+  get state() {
+    return this._state;
+  }
+  /** Get onClick handler */
+  get onClick() {
+    return this._onClick;
+  }
+  /** Set onClick handler */
+  set onClick(t) {
+    this._onClick = t;
+  }
+  /** Get hover color */
+  get hoverColor() {
+    return this._hoverColor;
+  }
+  /** Set hover color */
+  set hoverColor(t) {
+    this._hoverColor = t, this.updateVisualState();
+  }
+  /** Get pressed color */
+  get pressedColor() {
+    return this._pressedColor;
+  }
+  /** Set pressed color */
+  set pressedColor(t) {
+    this._pressedColor = t, this.updateVisualState();
+  }
+  /** Get disabled color */
+  get disabledColor() {
+    return this._disabledColor;
+  }
+  /** Set disabled color */
+  set disabledColor(t) {
+    this._disabledColor = t, this.updateVisualState();
+  }
+  /** Check if button is disabled */
+  get disabled() {
+    return this._disabled;
+  }
+  /** Set disabled state */
+  set disabled(t) {
+    this._disabled !== t && (this._disabled = t, this._state = t ? "disabled" : "normal", this.updateVisualState());
+  }
+  // ==================== Pointer Events (UIInteractive) ====================
+  /**
+   * Called when pointer enters button bounds.
+   */
+  onPointerEnter(t) {
+    this._disabled || (this._state = "hover", this.updateVisualState());
+  }
+  /**
+   * Called when pointer exits button bounds.
+   */
+  onPointerExit(t) {
+    this._disabled || (this._state = "normal", this.updateVisualState());
+  }
+  /**
+   * Called when pointer button is pressed on button.
+   */
+  onPointerDown(t) {
+    this._disabled || (this._state = "pressed", this.updateVisualState(), t.consumed = !0);
+  }
+  /**
+   * Called when pointer button is released on button.
+   * Fires onClick if the button was being pressed.
+   */
+  onPointerUp(t) {
+    this._disabled || (this._state === "pressed" && (this._state = "hover", this.updateVisualState(), this._onClick && this._onClick()), t.consumed = !0);
+  }
+  // ==================== Internal ====================
+  /**
+   * Update visual appearance based on current state.
+   */
+  updateVisualState() {
+    let t;
+    switch (this._state) {
+      case "hover":
+        t = this._hoverColor;
+        break;
+      case "pressed":
+        t = this._pressedColor;
+        break;
+      case "disabled":
+        t = this._disabledColor;
+        break;
+      default:
+        t = this._normalColor;
+    }
+    this._backgroundColor = t, this.redrawBackground();
+  }
+  /**
+   * Override backgroundColor setter to also update normalColor.
+   */
+  set backgroundColor(t) {
+    this._normalColor = t, this._backgroundColor = t, this._hoverColor = this.lightenColor(t, 0.2), this._pressedColor = this.darkenColor(t, 0.2), this.updateVisualState();
+  }
+  get backgroundColor() {
+    return this._normalColor;
+  }
+  // ==================== Color Utilities ====================
+  /**
+   * Lighten a color by a factor (0-1).
+   */
+  lightenColor(t, e) {
+    const i = Math.min(255, (t >> 16 & 255) + 255 * e), s = Math.min(255, (t >> 8 & 255) + 255 * e), o = Math.min(255, (t & 255) + 255 * e);
+    return Math.floor(i) << 16 | Math.floor(s) << 8 | Math.floor(o);
+  }
+  /**
+   * Darken a color by a factor (0-1).
+   */
+  darkenColor(t, e) {
+    const i = (t >> 16 & 255) * (1 - e), s = (t >> 8 & 255) * (1 - e), o = (t & 255) * (1 - e);
+    return Math.floor(i) << 16 | Math.floor(s) << 8 | Math.floor(o);
+  }
+}
+class Mt extends P {
+  /** Space between children in pixels */
+  _gap;
+  /** Inner padding [top, right, bottom, left] */
+  _padding;
+  /** Cross-axis (horizontal) alignment of children */
+  _align;
+  constructor(t = {}) {
+    super(t), this._gap = t.gap ?? 0, this._padding = t.padding ?? [0, 0, 0, 0], this._align = t.align ?? "start";
+  }
+  // ==================== Properties ====================
+  /** Get gap between children */
+  get gap() {
+    return this._gap;
+  }
+  /** Set gap between children */
+  set gap(t) {
+    this._gap !== t && (this._gap = t, this.markLayoutDirty());
+  }
+  /** Get padding */
+  get padding() {
+    return [...this._padding];
+  }
+  /** Set padding [top, right, bottom, left] */
+  set padding(t) {
+    this._padding = [...t], this.markLayoutDirty();
+  }
+  /** Get alignment */
+  get align() {
+    return this._align;
+  }
+  /** Set alignment */
+  set align(t) {
+    this._align !== t && (this._align = t, this.markLayoutDirty());
+  }
+  // ==================== Layout ====================
+  /**
+   * Measure content size (sum of child heights + gaps + padding).
+   *
+   * ┌─────────────────────────────────────────┐
+   * │  padding-top                            │
+   * │  ┌─────────────────────────────────┐    │
+   * │  │ Child 1 (measured height)       │    │
+   * │  └─────────────────────────────────┘    │
+   * │              gap                         │
+   * │  ┌─────────────────────────────────┐    │
+   * │  │ Child 2 (measured height)       │    │
+   * │  └─────────────────────────────────┘    │
+   * │              gap                         │
+   * │  ┌─────────────────────────────────┐    │
+   * │  │ Child 3 (measured height)       │    │
+   * │  └─────────────────────────────────┘    │
+   * │  padding-bottom                         │
+   * └─────────────────────────────────────────┘
+   */
+  measureContent() {
+    const [t, e, i, s] = this._padding;
+    let o = t + i, a = 0;
+    for (let n = 0; n < this.children.length; n++) {
+      const l = this.children[n];
+      l.layout({ width: 0, height: 0 });
+      const h = l.getComputedSize();
+      o += h[1], a = Math.max(a, h[0]), n < this.children.length - 1 && (o += this._gap);
+    }
+    return [a + s + e, o];
+  }
+  /**
+   * Layout children vertically with gaps.
+   */
+  layoutChildren(t) {
+    const [e, i, s, o] = this._padding, a = this.computedSize[0] - o - i;
+    let n = e;
+    for (let l = 0; l < this.children.length; l++) {
+      const h = this.children[l];
+      h.layout({ width: a, height: 0 });
+      const u = h.getComputedSize();
+      let p = o;
+      switch (this._align) {
+        case "center":
+          p = o + (a - u[0]) / 2;
+          break;
+        case "end":
+          p = o + a - u[0];
+          break;
+      }
+      h.setComputedPosition(p, n), n += u[1], l < this.children.length - 1 && (n += this._gap);
+    }
+  }
+}
+class Ft extends P {
+  /** Space between children in pixels */
+  _gap;
+  /** Inner padding [top, right, bottom, left] */
+  _padding;
+  /** Cross-axis (vertical) alignment of children */
+  _align;
+  constructor(t = {}) {
+    super(t), this._gap = t.gap ?? 0, this._padding = t.padding ?? [0, 0, 0, 0], this._align = t.align ?? "start";
+  }
+  // ==================== Properties ====================
+  /** Get gap between children */
+  get gap() {
+    return this._gap;
+  }
+  /** Set gap between children */
+  set gap(t) {
+    this._gap !== t && (this._gap = t, this.markLayoutDirty());
+  }
+  /** Get padding */
+  get padding() {
+    return [...this._padding];
+  }
+  /** Set padding [top, right, bottom, left] */
+  set padding(t) {
+    this._padding = [...t], this.markLayoutDirty();
+  }
+  /** Get alignment */
+  get align() {
+    return this._align;
+  }
+  /** Set alignment */
+  set align(t) {
+    this._align !== t && (this._align = t, this.markLayoutDirty());
+  }
+  // ==================== Layout ====================
+  /**
+   * Measure content size (sum of child widths + gaps + padding).
+   *
+   * ┌───────────────────────────────────────────────────────────┐
+   * │ pl │ Child1 │ gap │ Child2 │ gap │ Child3 │ pr           │
+   * └───────────────────────────────────────────────────────────┘
+   *        └─────────────────────────────────────┘
+   *                    content area
+   */
+  measureContent() {
+    const [t, e, i, s] = this._padding;
+    let o = s + e, a = 0;
+    for (let n = 0; n < this.children.length; n++) {
+      const l = this.children[n];
+      l.layout({ width: 0, height: 0 });
+      const h = l.getComputedSize();
+      o += h[0], a = Math.max(a, h[1]), n < this.children.length - 1 && (o += this._gap);
+    }
+    return [o, a + t + i];
+  }
+  /**
+   * Layout children horizontally with gaps.
+   */
+  layoutChildren(t) {
+    const [e, i, s, o] = this._padding, a = this.computedSize[1] - e - s;
+    let n = o;
+    for (let l = 0; l < this.children.length; l++) {
+      const h = this.children[l];
+      h.layout({ width: 0, height: a });
+      const u = h.getComputedSize();
+      let p = e;
+      switch (this._align) {
+        case "center":
+          p = e + (a - u[1]) / 2;
+          break;
+        case "end":
+          p = e + a - u[1];
+          break;
+      }
+      h.setComputedPosition(n, p), n += u[0], l < this.children.length - 1 && (n += this._gap);
+    }
+  }
+}
+const pt = `
+@import url('https://fonts.googleapis.com/css2?family=Recursive:slnt,wght,CASL,MONO@0,400..900,0..1,1&family=Space+Grotesk:wght@400;700&display=swap');
+
+/* Keyframes */
+@keyframes bonk-letter-in {
+  0%   { transform: scale(0, 0) translateY(20px); opacity: 0; }
+  40%  { transform: scale(1.4, 0.7) translateY(-8px); opacity: 1; }
+  60%  { transform: scale(0.85, 1.15) translateY(3px); }
+  80%  { transform: scale(1.05, 0.95) translateY(-1px); }
+  100% { transform: scale(1, 1) translateY(0); opacity: 1; }
+}
+
+@keyframes bonk-float {
+  0%, 100% { transform: translateY(0); }
+  50%      { transform: translateY(-3px); }
+}
+
+@keyframes bonk-star {
+  0%   { transform: scale(0) rotate(0deg); opacity: 0.9; }
+  50%  { transform: scale(1.2) rotate(20deg); opacity: 0.5; }
+  100% { transform: scale(1.5) rotate(30deg); opacity: 0; }
+}
+
+.bonk-tweaker {
+  --bonk-accent: #f59e0b;
+  --bonk-accent-rgb: 245, 158, 11;
+  --bonk-accent-glow: #fbbf24;
+  --bonk-font-mono: 'Recursive', 'Consolas', monospace;
+  --bonk-font-ui: 'Space Grotesk', sans-serif;
+  --bonk-ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1);
+  --bonk-ease-out: cubic-bezier(0.16, 1, 0.3, 1);
+  --bonk-transition-fast: 0.15s var(--bonk-ease-out);
+  --bonk-transition-bounce: 0.25s var(--bonk-ease-spring);
+
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  width: 360px;
+  background: rgba(9, 9, 11, 0.97);
+  color: #a1a1aa;
+  font-family: var(--bonk-font-mono);
+  font-size: 12px;
+  display: flex;
+  flex-direction: column;
+  z-index: 99999;
+  border-left: 1px solid #27272a;
+  box-shadow: -4px 0 20px rgba(0, 0, 0, 0.6);
+  border-radius: 6px 0 0 6px;
+  overflow: hidden;
+  user-select: none;
+  transition: transform 400ms var(--bonk-ease-out), opacity 300ms var(--bonk-ease-out);
+}
+
+/* State classes */
+.bonk-tweaker.state-hidden {
+  display: none;
+}
+.bonk-tweaker.state-active {
+  transform: translateX(0);
+  opacity: 1;
+}
+.bonk-tweaker.state-dormant {
+  opacity: 0.12;
+  transform: translateX(calc(100% - 20px));
+}
+.bonk-tweaker.left.state-dormant {
+  transform: translateX(calc(-100% + 20px));
+}
+.bonk-tweaker.state-dormant.waking {
+  transition: transform 600ms var(--bonk-ease-spring), opacity 300ms var(--bonk-ease-out);
+}
+.bonk-tweaker.state-dormant > * {
+  pointer-events: none;
+}
+/* Accent bar on the visible dormant edge */
+.bonk-tweaker.right.state-dormant::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 3px;
+  height: 100%;
+  background: linear-gradient(to bottom, var(--bonk-accent), rgba(var(--bonk-accent-rgb), 0.2));
+  z-index: 1;
+}
+.bonk-tweaker.left.state-dormant::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: 3px;
+  height: 100%;
+  background: linear-gradient(to bottom, var(--bonk-accent), rgba(var(--bonk-accent-rgb), 0.2));
+  z-index: 1;
+}
+
+/* Theme blocks */
+.bonk-tweaker.theme-amber {
+  --bonk-accent: #f59e0b;
+  --bonk-accent-rgb: 245, 158, 11;
+  --bonk-accent-glow: #fbbf24;
+}
+.bonk-tweaker.theme-lime {
+  --bonk-accent: #84cc16;
+  --bonk-accent-rgb: 132, 204, 22;
+  --bonk-accent-glow: #a3e635;
+}
+.bonk-tweaker.theme-spring {
+  --bonk-accent: #00e5a0;
+  --bonk-accent-rgb: 0, 229, 160;
+  --bonk-accent-glow: #34ffc6;
+}
+
+.bonk-tweaker.right { right: 0; border-radius: 6px 0 0 6px; }
+.bonk-tweaker.left { left: 0; border-left: none; border-right: 1px solid #27272a; box-shadow: 4px 0 20px rgba(0, 0, 0, 0.6); border-radius: 0 6px 6px 0; }
+
+/* Header */
+.bonk-tweaker-header {
+  display: flex;
+  align-items: center;
+  padding: 8px 10px;
+  gap: 8px;
+  border-bottom: 1px solid #27272a;
+  flex-shrink: 0;
+}
+.bonk-tweaker-search {
+  flex: 1;
+  background: #09090b;
+  border: 1px solid #3f3f46;
+  color: #e4e4e7;
+  padding: 5px 8px;
+  border-radius: 4px;
+  font-family: inherit;
+  font-size: 12px;
+  outline: none;
+  transition: border-color var(--bonk-transition-bounce);
+}
+.bonk-tweaker-search:focus {
+  border-color: var(--bonk-accent);
+  box-shadow: 0 0 0 1px var(--bonk-accent);
+}
+.bonk-tweaker-search::placeholder {
+  color: #71717a;
+}
+.bonk-tweaker-close {
+  background: none;
+  border: none;
+  color: #71717a;
+  cursor: pointer;
+  font-size: 18px;
+  padding: 0 4px;
+  line-height: 1;
+  transition: color var(--bonk-transition-fast);
+}
+.bonk-tweaker-close:hover { color: #f87171; }
+
+/* Logo */
+.bonk-tweaker-logo {
+  text-align: center;
+  padding: 12px 0 8px;
+  border-bottom: 1px solid #27272a;
+  flex-shrink: 0;
+  position: relative;
+  overflow: hidden;
+}
+.bonk-tweaker-logo-star {
+  position: absolute;
+  width: 60px;
+  height: 60px;
+  left: 50%;
+  top: 50%;
+  margin-left: -30px;
+  margin-top: -34px;
+  background: radial-gradient(circle, rgba(var(--bonk-accent-rgb), 0.3) 0%, rgba(var(--bonk-accent-rgb), 0.1) 30%, transparent 70%);
+  border-radius: 50%;
+  pointer-events: none;
+  opacity: 0;
+}
+.bonk-tweaker-logo.entering .bonk-tweaker-logo-star {
+  animation: bonk-star 0.6s 0.1s ease-out both;
+}
+.bonk-tweaker-logo-text {
+  display: inline-flex;
+  gap: 2px;
+  position: relative;
+}
+.bonk-tweaker-logo-letter {
+  display: inline-block;
+  font-size: 28px;
+  font-weight: 900;
+  color: var(--bonk-accent);
+  letter-spacing: 0.15em;
+  text-shadow: 0 0 20px rgba(var(--bonk-accent-rgb), 0.3);
+  opacity: 0;
+}
+.bonk-tweaker-logo.entering .bonk-tweaker-logo-letter {
+  animation: bonk-letter-in 0.5s calc(var(--i) * 0.08s) ease-out both;
+}
+.bonk-tweaker-logo.idle .bonk-tweaker-logo-letter {
+  opacity: 1;
+  animation: bonk-float 3s calc(var(--i) * 0.15s) ease-in-out infinite;
+}
+.bonk-tweaker-logo-sub {
+  font-family: var(--bonk-font-ui);
+  font-size: 10px;
+  color: #71717a;
+  letter-spacing: 0.2em;
+  text-transform: uppercase;
+  margin-top: 2px;
+}
+
+/* Scrollable body */
+.bonk-tweaker-body {
+  flex: 1;
+  overflow-y: auto;
+  overflow-x: hidden;
+  scrollbar-width: thin;
+  scrollbar-color: #3f3f46 #18181b;
+}
+.bonk-tweaker-body::-webkit-scrollbar { width: 6px; }
+.bonk-tweaker-body::-webkit-scrollbar-track { background: #18181b; }
+.bonk-tweaker-body::-webkit-scrollbar-thumb { background: #3f3f46; border-radius: 4px; }
+.bonk-tweaker-body::-webkit-scrollbar-thumb:hover { background: var(--bonk-accent); }
+
+/* Group */
+.bonk-tweaker-group {
+  border-bottom: 1px solid #27272a;
+}
+.bonk-tweaker-group-header {
+  display: flex;
+  align-items: center;
+  padding: 6px 10px;
+  cursor: pointer;
+  background: rgba(var(--bonk-accent-rgb), 0.03);
+  transition: background var(--bonk-transition-fast);
+}
+.bonk-tweaker-group-header:hover {
+  background: rgba(var(--bonk-accent-rgb), 0.06);
+}
+.bonk-tweaker-group-header:active {
+  transform: scale(0.995) translateX(1px);
+}
+.bonk-tweaker-group-arrow {
+  width: 16px;
+  font-size: 10px;
+  color: #71717a;
+  flex-shrink: 0;
+}
+.bonk-tweaker-group-name {
+  flex: 1;
+  font-weight: 700;
+  color: var(--bonk-accent);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+}
+.bonk-tweaker-group-reset {
+  background: none;
+  border: none;
+  color: #71717a;
+  cursor: pointer;
+  font-size: 14px;
+  padding: 0 4px;
+  transition: color var(--bonk-transition-fast);
+}
+.bonk-tweaker-group-reset:hover { color: #facc15; }
+.bonk-tweaker-group-body {
+  padding: 2px 0;
+}
+.bonk-tweaker-group-body.collapsed {
+  display: none;
+}
+
+/* Sub-group (nested object) */
+.bonk-tweaker-subgroup {
+  margin-left: 12px;
+  border-left: 1px solid #27272a;
+}
+.bonk-tweaker-subgroup-header {
+  display: flex;
+  align-items: center;
+  padding: 4px 10px;
+  cursor: pointer;
+  font-size: 11px;
+  color: #a1a1aa;
+  transition: background var(--bonk-transition-fast);
+}
+.bonk-tweaker-subgroup-header:hover {
+  background: rgba(var(--bonk-accent-rgb), 0.04);
+}
+
+.bonk-tweaker-subgroup-body.collapsed {
+  display: none;
+}
+
+/* Field row */
+.bonk-tweaker-field {
+  display: flex;
+  align-items: center;
+  padding: 3px 10px 3px 26px;
+  gap: 6px;
+  min-height: 24px;
+  transition: background var(--bonk-transition-fast);
+}
+.bonk-tweaker-field:hover {
+  background: rgba(var(--bonk-accent-rgb), 0.03);
+}
+.bonk-tweaker-field.modified .bonk-tweaker-field-name {
+  color: #facc15;
+}
+.bonk-tweaker-field.search-hidden {
+  display: none;
+}
+.bonk-tweaker-field-name {
+  flex: 0 0 auto;
+  max-width: 140px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 11px;
+  color: #a1a1aa;
+}
+.bonk-tweaker-field-controls {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  justify-content: flex-end;
+}
+
+/* Number slider */
+.bonk-tweaker-slider {
+  flex: 1;
+  max-width: 100px;
+  height: 4px;
+  -webkit-appearance: none;
+  appearance: none;
+  background: #3f3f46;
+  border-radius: 2px;
+  outline: none;
+}
+.bonk-tweaker-slider::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  width: 10px;
+  height: 14px;
+  background: var(--bonk-accent);
+  border-radius: 2px;
+  cursor: pointer;
+}
+.bonk-tweaker-slider::-moz-range-thumb {
+  width: 10px;
+  height: 14px;
+  background: var(--bonk-accent);
+  border-radius: 2px;
+  cursor: pointer;
+  border: none;
+}
+
+/* Number input */
+.bonk-tweaker-number {
+  width: 60px;
+  background: #09090b;
+  border: 1px solid #3f3f46;
+  color: #e4e4e7;
+  padding: 2px 4px;
+  border-radius: 4px;
+  font-family: inherit;
+  font-size: 11px;
+  text-align: right;
+  outline: none;
+  transition: border-color var(--bonk-transition-bounce);
+}
+.bonk-tweaker-number:focus {
+  border-color: var(--bonk-accent);
+  box-shadow: 0 0 0 1px var(--bonk-accent);
+}
+
+/* Color picker */
+.bonk-tweaker-color {
+  width: 24px;
+  height: 18px;
+  border: 1px solid #3f3f46;
+  border-radius: 4px;
+  padding: 0;
+  cursor: pointer;
+  background: none;
+}
+.bonk-tweaker-color-hex {
+  width: 70px;
+  background: #09090b;
+  border: 1px solid #3f3f46;
+  color: #e4e4e7;
+  padding: 2px 4px;
+  border-radius: 4px;
+  font-family: inherit;
+  font-size: 11px;
+  outline: none;
+  transition: border-color var(--bonk-transition-bounce);
+}
+.bonk-tweaker-color-hex:focus {
+  border-color: var(--bonk-accent);
+  box-shadow: 0 0 0 1px var(--bonk-accent);
+}
+
+/* Checkbox */
+.bonk-tweaker-checkbox {
+  accent-color: var(--bonk-accent);
+  cursor: pointer;
+}
+
+/* Readonly display */
+.bonk-tweaker-readonly {
+  color: #71717a;
+  font-size: 11px;
+  font-style: italic;
+}
+
+/* Footer */
+.bonk-tweaker-footer {
+  display: flex;
+  padding: 8px 10px;
+  gap: 6px;
+  border-top: 1px solid #27272a;
+  flex-shrink: 0;
+  align-items: center;
+}
+.bonk-tweaker-btn {
+  flex: 1;
+  background: #27272a;
+  border: 1px solid rgba(var(--bonk-accent-rgb), 0.3);
+  color: var(--bonk-accent);
+  padding: 5px 8px;
+  border-radius: 4px;
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 11px;
+  text-align: center;
+  transition: background var(--bonk-transition-fast), color var(--bonk-transition-fast), transform var(--bonk-transition-bounce);
+}
+.bonk-tweaker-btn:hover {
+  background: rgba(var(--bonk-accent-rgb), 0.1);
+  color: var(--bonk-accent);
+}
+.bonk-tweaker-btn:active {
+  transform: scale(0.96);
+}
+
+/* Theme picker */
+.bonk-tweaker-theme-picker {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 0 4px;
+}
+.bonk-tweaker-theme-swatch {
+  width: 16px;
+  height: 16px;
+  border-radius: 50%;
+  border: 2px solid transparent;
+  cursor: pointer;
+  transition: transform var(--bonk-transition-bounce), border-color var(--bonk-transition-fast);
+}
+.bonk-tweaker-theme-swatch:hover {
+  transform: scale(1.2);
+}
+.bonk-tweaker-theme-swatch.active {
+  border-color: #e4e4e7;
+}
+
+/* Group hidden by search */
+.bonk-tweaker-group.search-hidden {
+  display: none;
+}
+
+/* Floating toggle button */
+.bonk-tweaker-fab {
+  --bonk-fab-accent: #f59e0b;
+  position: fixed;
+  bottom: 16px;
+  width: 36px;
+  height: 36px;
+  border-radius: 50%;
+  background: rgba(9, 9, 11, 0.9);
+  border: 1px solid #27272a;
+  color: var(--bonk-fab-accent);
+  cursor: pointer;
+  z-index: 99998;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 18px;
+  font-weight: 900;
+  font-family: 'Space Grotesk', sans-serif;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
+  transition: transform 0.25s cubic-bezier(0.34, 1.56, 0.64, 1), opacity 0.15s ease-out, border-color 0.15s ease-out;
+  opacity: 0.5;
+  padding: 0;
+  line-height: 1;
+}
+.bonk-tweaker-fab:hover {
+  opacity: 1;
+  transform: scale(1.15);
+  border-color: var(--bonk-fab-accent);
+  box-shadow: 0 2px 14px rgba(0, 0, 0, 0.5), 0 0 8px rgba(var(--bonk-fab-accent-rgb, 245, 158, 11), 0.2);
+}
+.bonk-tweaker-fab:active {
+  transform: scale(0.92);
+}
+.bonk-tweaker-fab.right { right: 16px; }
+.bonk-tweaker-fab.left { left: 16px; }
+.bonk-tweaker-fab.theme-amber { --bonk-fab-accent: #f59e0b; --bonk-fab-accent-rgb: 245, 158, 11; }
+.bonk-tweaker-fab.theme-lime { --bonk-fab-accent: #84cc16; --bonk-fab-accent-rgb: 132, 204, 22; }
+.bonk-tweaker-fab.theme-spring { --bonk-fab-accent: #00e5a0; --bonk-fab-accent-rgb: 0, 229, 160; }
+.bonk-tweaker-fab.fab-hidden { display: none; }
+`;
+class mt {
+  root = null;
+  body = null;
+  logo = null;
+  searchInput = null;
+  styleEl = null;
+  fields = [];
+  groupBodies = /* @__PURE__ */ new Map();
+  onChange = () => {
+  };
+  onReset = () => {
+  };
+  onExport = () => "{}";
+  onImport = () => {
+  };
+  getterInterval = null;
+  logoIdleTimer = null;
+  position = "right";
+  width = 360;
+  currentTheme = "amber";
+  swatches = /* @__PURE__ */ new Map();
+  fab = null;
+  currentState = "hidden";
+  outsideClickListener = null;
+  wakingTimer = null;
+  storagePrefix = "bonk-tweaker";
+  setCallbacks(t, e, i, s) {
+    this.onChange = t, this.onReset = e, this.onExport = i, this.onImport = s;
+  }
+  create(t, e, i) {
+    this.position = t, this.width = e, this.storagePrefix = i, this.styleEl = document.createElement("style"), this.styleEl.textContent = pt, document.head.appendChild(this.styleEl), this.root = document.createElement("div"), this.root.className = `bonk-tweaker ${t} state-hidden`, this.root.style.width = `${e}px`, this.root.addEventListener("keydown", (c) => c.stopPropagation()), this.root.addEventListener("keyup", (c) => c.stopPropagation()), this.root.addEventListener("keypress", (c) => c.stopPropagation()), this.root.addEventListener("mouseenter", () => {
+      this.currentState === "dormant" && this.wake();
+    });
+    const s = document.createElement("div");
+    s.className = "bonk-tweaker-header", this.searchInput = document.createElement("input"), this.searchInput.className = "bonk-tweaker-search", this.searchInput.type = "text", this.searchInput.placeholder = "Search constants...", this.searchInput.addEventListener("input", () => this.applySearch());
+    const o = document.createElement("button");
+    o.className = "bonk-tweaker-close", o.textContent = "×", o.addEventListener("click", () => this.hide()), s.appendChild(this.searchInput), s.appendChild(o), this.body = document.createElement("div"), this.body.className = "bonk-tweaker-body";
+    const a = document.createElement("div");
+    a.className = "bonk-tweaker-footer";
+    const n = this.createButton("Reset All", () => {
+      this.onReset(), this.refreshAllFields();
+    }), l = this.createButton("Export", () => {
+      const c = this.onExport();
+      navigator.clipboard.writeText(c).catch(() => {
+        prompt("Copy preset JSON:", c);
+      });
+    }), h = this.createButton("Import", () => {
+      const c = prompt("Paste preset JSON:");
+      c && (this.onImport(c), this.refreshAllFields());
+    });
+    a.appendChild(n), a.appendChild(l), a.appendChild(h);
+    const u = document.createElement("div");
+    u.className = "bonk-tweaker-theme-picker";
+    const p = [
+      { name: "amber", color: "#f59e0b" },
+      { name: "lime", color: "#84cc16" },
+      { name: "spring", color: "#00e5a0" }
+    ];
+    for (const c of p) {
+      const w = document.createElement("div");
+      w.className = "bonk-tweaker-theme-swatch", w.style.backgroundColor = c.color, w.title = c.name, w.addEventListener("click", () => this.setTheme(c.name)), this.swatches.set(c.name, w), u.appendChild(w);
+    }
+    a.appendChild(u), this.logo = document.createElement("div"), this.logo.className = "bonk-tweaker-logo";
+    const g = document.createElement("div");
+    g.className = "bonk-tweaker-logo-star";
+    const k = document.createElement("span");
+    k.className = "bonk-tweaker-logo-text";
+    const m = "BONK";
+    for (let c = 0; c < m.length; c++) {
+      const w = document.createElement("span");
+      w.className = "bonk-tweaker-logo-letter", w.style.setProperty("--i", String(c)), w.textContent = m[c], k.appendChild(w);
+    }
+    const f = document.createElement("div");
+    f.className = "bonk-tweaker-logo-sub", f.textContent = "tweaker", this.logo.appendChild(g), this.logo.appendChild(k), this.logo.appendChild(f), this.root.appendChild(s), this.root.appendChild(this.logo), this.root.appendChild(this.body), this.root.appendChild(a), document.body.appendChild(this.root);
+    const x = localStorage.getItem(`${this.storagePrefix}-ui:theme`) ?? localStorage.getItem("bonk-tweaker-theme");
+    x && this.swatches.has(x) ? this.setTheme(x) : this.setTheme(this.currentTheme), this.fab = document.createElement("button"), this.fab.className = `bonk-tweaker-fab ${t} theme-${this.currentTheme}`, this.fab.textContent = "B", this.fab.title = "Toggle Tweaker", this.fab.addEventListener("click", () => {
+      this.currentState === "hidden" ? this.show() : this.hide();
+    }), document.body.appendChild(this.fab);
+  }
+  addGroup(t) {
+    if (!this.body) return;
+    const e = document.createElement("div");
+    e.className = "bonk-tweaker-group", e.dataset.groupName = t.name;
+    const i = document.createElement("div");
+    i.className = "bonk-tweaker-group-header";
+    let s = t.options.collapsed ?? !1;
+    try {
+      const h = localStorage.getItem(`${this.storagePrefix}-ui:group:${t.name}`);
+      h !== null && (s = h === "1");
+    } catch {
+    }
+    const o = document.createElement("span");
+    o.className = "bonk-tweaker-group-arrow", o.textContent = s ? "▶" : "▼";
+    const a = document.createElement("span");
+    a.className = "bonk-tweaker-group-name", a.textContent = t.name;
+    const n = document.createElement("button");
+    n.className = "bonk-tweaker-group-reset", n.textContent = "↺", n.title = `Reset ${t.name}`, n.addEventListener("click", (h) => {
+      h.stopPropagation(), this.onReset(t.name), this.refreshGroupFields(t.name);
+    }), i.appendChild(o), i.appendChild(a), i.appendChild(n);
+    const l = document.createElement("div");
+    l.className = `bonk-tweaker-group-body${s ? " collapsed" : ""}`, i.addEventListener("click", () => {
+      const h = l.classList.toggle("collapsed");
+      o.textContent = h ? "▶" : "▼";
+      try {
+        localStorage.setItem(`${this.storagePrefix}-ui:group:${t.name}`, h ? "1" : "0");
+      } catch {
+      }
+    }), this.addFields(t, l, t.target, t.defaults, "", t.options.hints || {}), this.groupBodies.set(t.name, l), e.appendChild(i), e.appendChild(l), this.body.appendChild(e);
+  }
+  removeGroup(t) {
+    if (!this.body) return;
+    const e = this.body.querySelector(`[data-group-name="${t}"]`);
+    e && e.remove(), this.fields = this.fields.filter((i) => i.groupName !== t), this.groupBodies.delete(t);
+  }
+  show() {
+    if (this.root) {
+      this.currentState = "active", this.applyStateClasses(), this.refreshAllFields(), this.playLogoEntrance(), this.setupDormantListeners(), this.getterInterval || (this.getterInterval = setInterval(() => this.refreshGetters(), 500)), this.fab?.classList.add("fab-hidden");
+      try {
+        localStorage.setItem(`${this.storagePrefix}-ui:visible`, "1");
+      } catch {
+      }
+    }
+  }
+  hide() {
+    if (this.root) {
+      this.currentState = "hidden", this.applyStateClasses(), this.removeDormantListeners(), this.wakingTimer && (clearTimeout(this.wakingTimer), this.wakingTimer = null), this.getterInterval && (clearInterval(this.getterInterval), this.getterInterval = null), this.fab?.classList.remove("fab-hidden");
+      try {
+        localStorage.setItem(`${this.storagePrefix}-ui:visible`, "0");
+      } catch {
+      }
+    }
+  }
+  isVisible() {
+    return this.currentState !== "hidden";
+  }
+  restoreVisibility() {
+    try {
+      localStorage.getItem(`${this.storagePrefix}-ui:visible`) === "1" && this.show();
+    } catch {
+    }
+  }
+  getState() {
+    return this.currentState;
+  }
+  goDormant() {
+    !this.root || this.currentState !== "active" || (this.currentState = "dormant", this.applyStateClasses());
+  }
+  wake() {
+    !this.root || this.currentState !== "dormant" || (this.currentState = "active", this.root.classList.add("waking"), this.applyStateClasses(), this.playLogoEntrance(), this.wakingTimer && clearTimeout(this.wakingTimer), this.wakingTimer = setTimeout(() => {
+      this.root?.classList.remove("waking"), this.wakingTimer = null;
+    }, 600));
+  }
+  applyStateClasses() {
+    this.root && (this.root.classList.remove("state-hidden", "state-active", "state-dormant"), this.root.classList.add(`state-${this.currentState}`));
+  }
+  playLogoEntrance() {
+    this.logo && (this.logoIdleTimer && (clearTimeout(this.logoIdleTimer), this.logoIdleTimer = null), this.logo.classList.remove("idle"), this.logo.classList.add("entering"), this.logoIdleTimer = setTimeout(() => {
+      this.logo && (this.logo.classList.remove("entering"), this.logo.classList.add("idle"));
+    }, 800));
+  }
+  setupDormantListeners() {
+    this.outsideClickListener || (this.outsideClickListener = (t) => {
+      this.currentState === "active" && this.root && !this.root.contains(t.target) && this.goDormant();
+    }, document.addEventListener("pointerdown", this.outsideClickListener));
+  }
+  removeDormantListeners() {
+    this.outsideClickListener && (document.removeEventListener("pointerdown", this.outsideClickListener), this.outsideClickListener = null);
+  }
+  setTheme(t) {
+    if (this.root) {
+      this.root.classList.remove("theme-amber", "theme-lime", "theme-spring"), this.root.classList.add(`theme-${t}`), this.currentTheme = t;
+      try {
+        localStorage.setItem(`${this.storagePrefix}-ui:theme`, t);
+      } catch {
+      }
+      this.swatches.forEach((e, i) => {
+        e.classList.toggle("active", i === t);
+      }), this.fab && (this.fab.classList.remove("theme-amber", "theme-lime", "theme-spring"), this.fab.classList.add(`theme-${t}`));
+    }
+  }
+  destroy() {
+    this.getterInterval && clearInterval(this.getterInterval), this.logoIdleTimer && clearTimeout(this.logoIdleTimer), this.wakingTimer && clearTimeout(this.wakingTimer), this.removeDormantListeners(), this.root?.remove(), this.styleEl?.remove(), this.fab?.remove(), this.fields = [], this.groupBodies.clear(), this.root = null, this.body = null, this.logo = null, this.fab = null;
+  }
+  // === Field creation ===
+  addFields(t, e, i, s, o, a) {
+    for (const n of Object.keys(i)) {
+      const l = o ? `${o}.${n}` : n, h = Object.getOwnPropertyDescriptor(i, n);
+      if (h && h.get) {
+        this.addReadonlyField(t.name, e, n, l, i);
+        continue;
+      }
+      const u = i[n];
+      switch (this.detectFieldType(n, u, a[l] || a[n])) {
+        case "number":
+          this.addNumberField(t.name, e, n, l, i, s);
+          break;
+        case "color":
+          this.addColorField(t.name, e, n, l, i, s);
+          break;
+        case "boolean":
+          this.addBooleanField(t.name, e, n, l, i, s);
+          break;
+        case "object":
+          this.addSubgroup(t, e, n, l, i, s, a);
+          break;
+        case "readonly":
+          this.addReadonlyField(t.name, e, n, l, i);
+          break;
+      }
+    }
+  }
+  detectFieldType(t, e, i) {
+    if (i === "color") return "color";
+    if (i === "readonly") return "readonly";
+    if (typeof e == "boolean") return "boolean";
+    if (typeof e == "number") {
+      const s = t.toUpperCase();
+      return (s.includes("COLOR") || s.includes("TINT")) && e > 255 && Number.isInteger(e) ? "color" : "number";
+    }
+    return typeof e == "object" && e !== null && !Array.isArray(e) ? "object" : "readonly";
+  }
+  addNumberField(t, e, i, s, o, a) {
+    const n = this.createFieldRow(i), l = n.querySelector(".bonk-tweaker-field-controls"), h = this.getNestedDefault(a, s), u = o[i], { min: p, max: g, step: k } = this.inferRange(u), m = document.createElement("input");
+    m.type = "range", m.className = "bonk-tweaker-slider", m.min = String(p), m.max = String(g), m.step = String(k), m.value = String(u);
+    const f = document.createElement("input");
+    f.type = "number", f.className = "bonk-tweaker-number", f.value = this.formatNumber(u), f.step = String(k);
+    const x = () => {
+      const c = o[i] !== h;
+      n.classList.toggle("modified", c);
+    };
+    m.addEventListener("input", () => {
+      const c = parseFloat(m.value);
+      f.value = this.formatNumber(c), o[i] = c, this.onChange(t, s, c), x();
+    }), f.addEventListener("change", () => {
+      const c = parseFloat(f.value);
+      isNaN(c) || (o[i] = c, c < parseFloat(m.min) && (m.min = String(c * (c < 0 ? 2 : 0.5))), c > parseFloat(m.max) && (m.max = String(c * 1.5)), m.value = String(c), this.onChange(t, s, c), x());
+    }), l.appendChild(m), l.appendChild(f), e.appendChild(n), x(), this.fields.push({
+      groupName: t,
+      path: s,
+      defaultValue: h,
+      row: n,
+      update: (c) => {
+        m.value = String(c), f.value = this.formatNumber(c), x();
+      }
+    });
+  }
+  addColorField(t, e, i, s, o, a) {
+    const n = this.createFieldRow(i), l = n.querySelector(".bonk-tweaker-field-controls"), h = this.getNestedDefault(a, s), u = o[i], p = document.createElement("input");
+    p.type = "color", p.className = "bonk-tweaker-color", p.value = "#" + u.toString(16).padStart(6, "0");
+    const g = document.createElement("input");
+    g.type = "text", g.className = "bonk-tweaker-color-hex", g.value = "0x" + u.toString(16).padStart(6, "0");
+    const k = () => {
+      const m = o[i] !== h;
+      n.classList.toggle("modified", m);
+    };
+    p.addEventListener("input", () => {
+      const m = p.value, f = parseInt(m.slice(1), 16);
+      g.value = "0x" + f.toString(16).padStart(6, "0"), o[i] = f, this.onChange(t, s, f), k();
+    }), g.addEventListener("change", () => {
+      let m = g.value.trim();
+      (m.startsWith("0x") || m.startsWith("0X")) && (m = m.slice(2)), m.startsWith("#") && (m = m.slice(1));
+      const f = parseInt(m, 16);
+      isNaN(f) || (p.value = "#" + f.toString(16).padStart(6, "0"), g.value = "0x" + f.toString(16).padStart(6, "0"), o[i] = f, this.onChange(t, s, f), k());
+    }), l.appendChild(p), l.appendChild(g), e.appendChild(n), k(), this.fields.push({
+      groupName: t,
+      path: s,
+      defaultValue: h,
+      row: n,
+      update: (m) => {
+        const f = m;
+        p.value = "#" + f.toString(16).padStart(6, "0"), g.value = "0x" + f.toString(16).padStart(6, "0"), k();
+      }
+    });
+  }
+  addBooleanField(t, e, i, s, o, a) {
+    const n = this.createFieldRow(i), l = n.querySelector(".bonk-tweaker-field-controls"), h = this.getNestedDefault(a, s), u = document.createElement("input");
+    u.type = "checkbox", u.className = "bonk-tweaker-checkbox", u.checked = o[i];
+    const p = () => {
+      const g = o[i] !== h;
+      n.classList.toggle("modified", g);
+    };
+    u.addEventListener("change", () => {
+      o[i] = u.checked, this.onChange(t, s, u.checked), p();
+    }), l.appendChild(u), e.appendChild(n), p(), this.fields.push({
+      groupName: t,
+      path: s,
+      defaultValue: h,
+      row: n,
+      update: (g) => {
+        u.checked = g, p();
+      }
+    });
+  }
+  addReadonlyField(t, e, i, s, o) {
+    const a = this.createFieldRow(i), n = a.querySelector(".bonk-tweaker-field-controls"), l = document.createElement("span");
+    l.className = "bonk-tweaker-readonly";
+    const h = o[i];
+    l.textContent = this.formatReadonly(h), n.appendChild(l), e.appendChild(a), this.fields.push({
+      groupName: t,
+      path: s,
+      defaultValue: void 0,
+      row: a,
+      update: (u) => {
+        l.textContent = this.formatReadonly(u);
+      }
+    });
+  }
+  addSubgroup(t, e, i, s, o, a, n) {
+    const l = o[i], h = this.getNestedDefault(a, s) || {};
+    let u = !1;
+    try {
+      const c = localStorage.getItem(`${this.storagePrefix}-ui:subgroup:${t.name}:${s}`);
+      c !== null && (u = c === "1");
+    } catch {
+    }
+    const p = document.createElement("div");
+    p.className = "bonk-tweaker-subgroup";
+    const g = document.createElement("div");
+    g.className = "bonk-tweaker-subgroup-header";
+    const k = document.createElement("span");
+    k.className = "bonk-tweaker-group-arrow", k.textContent = u ? "▶" : "▼";
+    const m = document.createElement("span");
+    m.textContent = i, g.appendChild(k), g.appendChild(m);
+    const f = document.createElement("div");
+    f.className = `bonk-tweaker-subgroup-body${u ? " collapsed" : ""}`, g.addEventListener("click", () => {
+      const c = f.classList.toggle("collapsed");
+      k.textContent = c ? "▶" : "▼";
+      try {
+        localStorage.setItem(`${this.storagePrefix}-ui:subgroup:${t.name}:${s}`, c ? "1" : "0");
+      } catch {
+      }
+    });
+    const x = {};
+    for (const [c, w] of Object.entries(n))
+      c.startsWith(s + ".") && (x[c] = w, x[c.slice(s.length + 1)] = w);
+    this.addFields(t, f, l, h, s, x), p.appendChild(g), p.appendChild(f), e.appendChild(p);
+  }
+  // === Search ===
+  applySearch() {
+    if (!this.body || !this.searchInput) return;
+    const t = this.searchInput.value.toLowerCase().trim();
+    for (const i of this.fields) {
+      const s = i.path.toLowerCase().includes(t), o = i.groupName.toLowerCase().includes(t);
+      i.row.classList.toggle("search-hidden", !!(t && !s && !o));
+    }
+    const e = this.body.querySelectorAll(".bonk-tweaker-group");
+    for (const i of e) {
+      const o = (i.dataset.groupName || "").toLowerCase().includes(t), a = i.querySelector(".bonk-tweaker-field:not(.search-hidden)");
+      if (i.classList.toggle("search-hidden", !!(t && !o && !a)), t && (o || a)) {
+        const n = i.querySelector(".bonk-tweaker-group-body"), l = i.querySelector(".bonk-tweaker-group-arrow");
+        n && n.classList.remove("collapsed"), l && (l.textContent = "▼");
+      }
+    }
+  }
+  // === Refresh ===
+  refreshAllFields() {
+    for (const t of this.fields) {
+      const e = this.resolveFieldValue(t);
+      e !== void 0 && t.update(e);
+    }
+  }
+  refreshGroupFields(t) {
+    for (const e of this.fields)
+      if (e.groupName === t) {
+        const i = this.resolveFieldValue(e);
+        i !== void 0 && e.update(i);
+      }
+  }
+  refreshGetters() {
+    for (const t of this.fields)
+      if (t.defaultValue === void 0) {
+        const e = this.resolveFieldValue(t);
+        e !== void 0 && t.update(e);
+      }
+  }
+  resolveFieldValue(t) {
+  }
+  // === Utilities ===
+  createFieldRow(t) {
+    const e = document.createElement("div");
+    e.className = "bonk-tweaker-field", e.dataset.fieldKey = t;
+    const i = document.createElement("span");
+    i.className = "bonk-tweaker-field-name", i.textContent = t, i.title = t;
+    const s = document.createElement("div");
+    return s.className = "bonk-tweaker-field-controls", e.appendChild(i), e.appendChild(s), e;
+  }
+  createButton(t, e) {
+    const i = document.createElement("button");
+    return i.className = "bonk-tweaker-btn", i.textContent = t, i.addEventListener("click", e), i;
+  }
+  inferRange(t) {
+    if (t === 0) return { min: -1, max: 1, step: 0.01 };
+    const e = Math.abs(t);
+    let i, s, o;
+    return e <= 1 ? (i = t < 0 ? t * 3 : 0, s = t < 0 ? -t : t * 3, o = 1e-3) : e <= 10 ? (i = t < 0 ? t * 3 : 0, s = t < 0 ? 0 : t * 3, o = 0.1) : (i = t < 0 ? t * 3 : 0, s = t < 0 ? 0 : t * 3, o = e < 100 ? 1 : Math.round(e / 100)), { min: i, max: s, step: o };
+  }
+  formatNumber(t) {
+    return Number.isInteger(t) ? String(t) : parseFloat(t.toFixed(4)).toString();
+  }
+  formatReadonly(t) {
+    return typeof t == "number" ? this.formatNumber(t) : typeof t == "string" ? `"${t}"` : Array.isArray(t) ? `[${t.join(", ")}]` : t == null ? String(t) : JSON.stringify(t);
+  }
+  getNestedDefault(t, e) {
+    const i = e.split(".");
+    let s = t;
+    for (const o of i) {
+      if (s == null || typeof s != "object") return;
+      s = s[o];
+    }
+    return s;
+  }
+}
+const U = {
+  hotkey: "Backquote",
+  position: "right",
+  width: 360,
+  storagePrefix: "bonk-tweaker",
+  theme: "amber"
+};
+class d {
+  static overlay = null;
+  static groups = /* @__PURE__ */ new Map();
+  static config = { ...U };
+  static initialized = !1;
+  static hotkeyHandler = null;
+  /**
+   * Initialize the tweaker. Call once at startup.
+   * Creates the DOM overlay and binds the toggle hotkey.
+   */
+  static init(t) {
+    d.initialized || (d.initialized = !0, d.config = { ...U, ...t }, d.overlay = new mt(), d.overlay.setCallbacks(
+      (e, i, s) => d.onFieldChange(e, i, s),
+      (e) => d.reset(e),
+      () => d.exportPreset(),
+      (e) => d.importPreset(e)
+    ), d.overlay.create(d.config.position, d.config.width, d.config.storagePrefix), d.overlay.setTheme(d.config.theme), d.overlay.restoreVisibility(), d.hotkeyHandler = (e) => {
+      e.code === d.config.hotkey && (e.preventDefault(), d.toggle());
+    }, window.addEventListener("keydown", d.hotkeyHandler));
+  }
+  /**
+   * Register a constants object for live editing.
+   * Saved overrides from localStorage are applied immediately.
+   */
+  static register(t, e, i) {
+    if (!d.initialized) return;
+    const s = d.deepClone(e), o = {
+      name: t,
+      target: e,
+      defaults: s,
+      options: i || {}
+    };
+    d.groups.set(t, o), d.overlay?.addGroup(o), d.loadOverrides(o);
+  }
+  /**
+   * Unregister a constants group.
+   */
+  static unregister(t) {
+    d.groups.delete(t), d.overlay?.removeGroup(t);
+  }
+  /** Show the tweaker overlay */
+  static show() {
+    d.overlay?.show();
+  }
+  /** Hide the tweaker overlay */
+  static hide() {
+    d.overlay?.hide();
+  }
+  /** Toggle the tweaker overlay visibility */
+  static toggle() {
+    d.overlay?.isVisible() ? d.overlay.hide() : d.overlay?.show();
+  }
+  /** Send the tweaker to dormant mode (faded, slid aside) */
+  static goDormant() {
+    d.overlay?.goDormant();
+  }
+  /** Wake the tweaker from dormant mode */
+  static wake() {
+    d.overlay?.wake();
+  }
+  /** Get the current tweaker state */
+  static getState() {
+    return d.overlay?.getState() ?? "hidden";
+  }
+  /**
+   * Reset a group (or all groups) to default values.
+   * Clears localStorage overrides.
+   */
+  static reset(t) {
+    if (t) {
+      const e = d.groups.get(t);
+      e && (d.applyDefaults(e), d.clearStorage(t));
+    } else {
+      for (const e of d.groups.values())
+        d.applyDefaults(e);
+      d.clearStorage();
+    }
+    d.overlay?.refreshAllFields();
+  }
+  /**
+   * Export all current overrides as a JSON string.
+   */
+  static exportPreset() {
+    const t = {};
+    for (const [e, i] of d.groups) {
+      const s = d.getOverrides(i);
+      Object.keys(s).length > 0 && (t[e] = s);
+    }
+    return JSON.stringify(t, null, 2);
+  }
+  /**
+   * Import a preset JSON string and apply overrides.
+   */
+  static importPreset(t) {
+    try {
+      const e = JSON.parse(t);
+      for (const [i, s] of Object.entries(e)) {
+        const o = d.groups.get(i);
+        if (o)
+          for (const [a, n] of Object.entries(s))
+            d.setNestedValue(o.target, a, n), d.saveOverride(i, a, n);
+      }
+      d.overlay?.refreshAllFields();
+    } catch {
+      console.warn("[Tweaker] Invalid preset JSON");
+    }
+  }
+  /** Clean up everything */
+  static destroy() {
+    d.hotkeyHandler && (window.removeEventListener("keydown", d.hotkeyHandler), d.hotkeyHandler = null), d.overlay?.destroy(), d.overlay = null, d.groups.clear(), d.initialized = !1;
+  }
+  // === Internal ===
+  static onFieldChange(t, e, i) {
+    d.saveOverride(t, e, i);
+  }
+  static storageKey(t, e) {
+    return `${d.config.storagePrefix}:${t}:${e}`;
+  }
+  static saveOverride(t, e, i) {
+    try {
+      localStorage.setItem(d.storageKey(t, e), JSON.stringify(i));
+    } catch {
+    }
+  }
+  static loadOverrides(t) {
+    const e = `${d.config.storagePrefix}:${t.name}:`;
+    for (let i = 0; i < localStorage.length; i++) {
+      const s = localStorage.key(i);
+      if (!s || !s.startsWith(e)) continue;
+      const o = s.slice(e.length);
+      try {
+        const a = JSON.parse(localStorage.getItem(s));
+        d.setNestedValue(t.target, o, a);
+      } catch {
+      }
+    }
+  }
+  static clearStorage(t) {
+    const e = t ? `${d.config.storagePrefix}:${t}:` : `${d.config.storagePrefix}:`, i = [];
+    for (let s = 0; s < localStorage.length; s++) {
+      const o = localStorage.key(s);
+      o && o.startsWith(e) && i.push(o);
+    }
+    for (const s of i) localStorage.removeItem(s);
+  }
+  static applyDefaults(t) {
+    d.deepApply(t.target, t.defaults);
+  }
+  static getOverrides(t) {
+    const e = {};
+    return d.diffValues(t.target, t.defaults, "", e), e;
+  }
+  static diffValues(t, e, i, s) {
+    for (const o of Object.keys(e)) {
+      const a = Object.getOwnPropertyDescriptor(t, o);
+      if (a && a.get) continue;
+      const n = i ? `${i}.${o}` : o, l = t[o], h = e[o];
+      typeof l == "object" && l !== null && !Array.isArray(l) && typeof h == "object" && h !== null && !Array.isArray(h) ? d.diffValues(
+        l,
+        h,
+        n,
+        s
+      ) : l !== h && (s[n] = l);
+    }
+  }
+  static setNestedValue(t, e, i) {
+    const s = e.split(".");
+    let o = t;
+    for (let a = 0; a < s.length - 1; a++) {
+      const n = o[s[a]];
+      if (typeof n != "object" || n === null) return;
+      o = n;
+    }
+    o[s[s.length - 1]] = i;
+  }
+  static deepClone(t) {
+    const e = {};
+    for (const i of Object.keys(t)) {
+      const s = Object.getOwnPropertyDescriptor(t, i);
+      if (s && s.get) {
+        Object.defineProperty(e, i, {
+          get: s.get,
+          enumerable: !0,
+          configurable: !0
+        });
+        continue;
+      }
+      const o = t[i];
+      typeof o == "object" && o !== null && !Array.isArray(o) ? e[i] = d.deepClone(o) : Array.isArray(o) ? e[i] = [...o] : e[i] = o;
+    }
+    return e;
+  }
+  static deepApply(t, e) {
+    for (const i of Object.keys(e)) {
+      const s = Object.getOwnPropertyDescriptor(t, i);
+      if (s && s.get) continue;
+      const o = e[i];
+      if (typeof o == "object" && o !== null && !Array.isArray(o)) {
+        const a = t[i];
+        typeof a == "object" && a !== null && !Array.isArray(a) && d.deepApply(a, o);
+      } else
+        t[i] = o;
+    }
+  }
+}
+export {
+  Et as AnimatedSprite,
+  N as AudioEvents,
+  G as AudioManager,
+  Dt as AudioSource,
+  It as Camera,
+  j as CollisionLayers,
+  T as EngineEvents,
+  at as EventEmitter,
+  vt as Game,
+  B as GlobalEvents,
+  rt as GlobalScheduler,
+  y as Input,
+  Pt as Keys,
+  st as MatterPhysicsWorld,
+  J as PixiRenderer,
+  lt as RigidBody,
+  ot as Scheduler,
+  St as Sprite,
+  C as Time,
+  $ as Transform,
+  d as Tweaker,
+  Ot as UIButton,
+  P as UIElement,
+  Ft as UIHBox,
+  At as UIImage,
+  _t as UIManager,
+  ut as UIPanel,
+  Bt as UIText,
+  Mt as UIVBox,
+  tt as createPhysicsWorld,
+  v as getAudioManager,
+  yt as getPhysicsBackends,
+  Q as registerPhysicsBackend,
+  zt as vec2,
+  xt as wait,
+  Ct as waitForCoroutine,
+  kt as waitFrames,
+  wt as waitUntil
+};
+//# sourceMappingURL=bonkjs.js.map