@cosmoledo/gleam 1.0.0

package/dist/gleam.js

@@ -0,0 +1,3824 @@
+"use strict";
+var Gleam = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    Animator: () => Animator,
+    AudioBase: () => AudioBase,
+    CANVAS_TYPES: () => CANVAS_TYPES,
+    CONTROLLER_KEYS: () => CONTROLLER_KEYS,
+    CanvasManager: () => CanvasManager,
+    Color: () => Color,
+    Controller: () => Controller,
+    ControllerCursor: () => ControllerCursor,
+    EASINGS: () => EASINGS,
+    EventSystem: () => EventSystem,
+    Game: () => Game,
+    Gameloop: () => Gameloop,
+    KEYBOARD_KEYS: () => KEYBOARD_KEYS,
+    Keyboard: () => Keyboard,
+    Music: () => Music,
+    POINTER_KEYS: () => POINTER_KEYS,
+    Particle: () => Particle,
+    Pointer: () => Pointer,
+    Polygon: () => Polygon,
+    Projectile: () => Projectile,
+    Rect: () => Rect,
+    SHAKE_TYPES: () => SHAKE_TYPES,
+    Screenshake: () => Screenshake,
+    Settings: () => Settings,
+    Sound: () => Sound,
+    Vec2: () => Vec2,
+    applyFilterOnCanvas: () => applyFilterOnCanvas,
+    approxEqual: () => approxEqual,
+    changeColor: () => changeColor,
+    chunk: () => chunk,
+    clamp: () => clamp,
+    cloneGrid: () => cloneGrid,
+    colorShifter: () => colorShifter,
+    compact: () => compact,
+    convert1DTo2D: () => convert1DTo2D,
+    convert2DTo1D: () => convert2DTo1D,
+    createNewCanvas: () => createNewCanvas,
+    debounce: () => debounce,
+    deepClone: () => deepClone,
+    defineMethod: () => defineMethod,
+    delay: () => delay,
+    doWhilePressed: () => doWhilePressed,
+    easeIn: () => easeIn,
+    easeInOut: () => easeInOut,
+    easeOut: () => easeOut,
+    generateGrid: () => generateGrid,
+    getCanvasConstruct: () => getCanvasConstruct,
+    getElement: () => getElement,
+    getFactorial: () => getFactorial,
+    getUsedColors: () => getUsedColors,
+    hex2rgb: () => hex2rgb,
+    hue2rgb: () => hue2rgb,
+    initCSSVariables: () => initCSSVariables,
+    isNumeric: () => isNumeric,
+    isTouchPrimary: () => isTouchPrimary,
+    linear: () => linear,
+    loadBunch: () => loadBunch,
+    loadCanvas: () => loadCanvas,
+    loadImage: () => loadImage,
+    loadImageFromJson: () => loadImageFromJson,
+    loadJson: () => loadJson,
+    loadJsonCommented: () => loadJsonCommented,
+    loadText: () => loadText,
+    map: () => map,
+    mapUnclamped: () => mapUnclamped,
+    prepareLanguage: () => prepareLanguage,
+    rafLoop: () => rafLoop,
+    random2Pi: () => random2Pi,
+    randomBetweenFloat: () => randomBetweenFloat,
+    randomBetweenInt: () => randomBetweenInt,
+    randomBoolean: () => randomBoolean,
+    randomHex: () => randomHex,
+    randomItem: () => randomItem,
+    randomRgb: () => randomRgb,
+    randomSign: () => randomSign,
+    remove: () => remove,
+    replaceCharAt: () => replaceCharAt,
+    rgb2Int: () => rgb2Int,
+    rgb2hex: () => rgb2hex,
+    rotateHue: () => rotateHue,
+    roundTo: () => roundTo,
+    safeLoad: () => safeLoad,
+    setDisplay: () => setDisplay,
+    setVisibility: () => setVisibility,
+    shuffle: () => shuffle,
+    splitSpriteSheet: () => splitSpriteSheet,
+    styleElement: () => styleElement,
+    threshold: () => threshold,
+    throttle: () => throttle,
+    throttleByKey: () => throttleByKey,
+    toDegrees: () => toDegrees,
+    toDotted: () => toDotted,
+    toHHMMSS: () => toHHMMSS,
+    toRadians: () => toRadians,
+    urlBasename: () => urlBasename,
+    validateUrl: () => validateUrl,
+    waitForEvent: () => waitForEvent,
+    wrapDegrees: () => wrapDegrees,
+    wrapRadians: () => wrapRadians,
+    wrapValue: () => wrapValue
+  });
+
+  // src/utilities/Functions.ts
+  function debounce(callback, delay2) {
+    let timer;
+    return (...args) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => callback(...args), delay2);
+    };
+  }
+  function delay(time) {
+    return new Promise((res) => setTimeout(res, time));
+  }
+  function isTouchPrimary() {
+    return matchMedia("(pointer: coarse)").matches;
+  }
+  function rafLoop(tick) {
+    let lastTime = 0;
+    let running = true;
+    let handle = 0;
+    const wrapped = (now) => {
+      const dt = lastTime === 0 ? 0 : (now - lastTime) / 1e3;
+      lastTime = now;
+      tick(dt);
+      if (running) {
+        handle = requestAnimationFrame(wrapped);
+      }
+    };
+    handle = requestAnimationFrame(wrapped);
+    return () => {
+      running = false;
+      cancelAnimationFrame(handle);
+    };
+  }
+  function throttle(callback, delay2 = 1e3) {
+    let lastCalled = -Infinity;
+    let callCount = 0;
+    return () => {
+      callCount++;
+      const now = performance.now();
+      if (now - lastCalled > delay2) {
+        lastCalled = now;
+        const count = callCount;
+        callCount = 0;
+        callback(count);
+      }
+    };
+  }
+  function throttleByKey(callback, delay2 = 1e3) {
+    const wrappers = /* @__PURE__ */ new Map();
+    return (key, ...args) => {
+      let wrapper = wrappers.get(key);
+      if (!wrapper) {
+        let latest;
+        const throttled = throttle(
+          (count) => callback(count, ...latest),
+          delay2
+        );
+        wrapper = (...a) => {
+          latest = a;
+          throttled();
+        };
+        wrappers.set(key, wrapper);
+      }
+      wrapper(...args);
+    };
+  }
+  function urlBasename(path) {
+    const url = new URL(path, "http://_/");
+    const base = url.pathname.split("/").pop();
+    const dot = base.lastIndexOf(".");
+    const stem = dot > 0 ? base.slice(0, dot) : base;
+    if (!stem) {
+      return null;
+    }
+    try {
+      return decodeURIComponent(stem);
+    } catch {
+      return null;
+    }
+  }
+
+  // src/core/EventSystem.ts
+  var _EventSystem = class _EventSystem {
+    static addEventListener(eventName, callback, options = {}) {
+      if (options.signal?.aborted) {
+        return function dispose2() {
+        };
+      }
+      const id = ++this.nextId;
+      function dispose() {
+        const bucket2 = _EventSystem.eventListener[eventName];
+        if (!bucket2?.delete(id)) {
+          return;
+        }
+        if (bucket2.size === 0) {
+          delete _EventSystem.eventListener[eventName];
+        }
+        if (listener.options.signal) {
+          listener.options.signal.removeEventListener("abort", dispose);
+        }
+      }
+      const listener = {
+        callback,
+        dispose,
+        options: { once: options.once ?? false, signal: options.signal }
+      };
+      let bucket = this.eventListener[eventName];
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Map();
+        this.eventListener[eventName] = bucket;
+      }
+      bucket.set(id, listener);
+      if (options.signal) {
+        options.signal.addEventListener("abort", dispose, { once: true });
+      }
+      return dispose;
+    }
+    static dispatchEvent(eventName, ...params) {
+      const bucket = this.eventListener[eventName];
+      if (!bucket) {
+        return;
+      }
+      const maxId = this.nextId;
+      bucket.forEach((entry, id) => {
+        if (id > maxId) {
+          return;
+        }
+        if (entry.options.once) {
+          entry.dispose();
+        }
+        try {
+          entry.callback(...params);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.logListenerError(`${eventName}:${msg}`, eventName, err);
+        }
+      });
+    }
+  };
+  __publicField(_EventSystem, "eventListener", {});
+  __publicField(_EventSystem, "logListenerError", throttleByKey(
+    (count, eventName, err) => {
+      const suffix = count > 1 ? ` (x${count} since last log)` : "";
+      console.error(
+        `EventSystem listener for "${eventName}" threw${suffix}:`,
+        err
+      );
+    }
+  ));
+  // Monotonic counter — each listener gets an id assigned at registration.
+  // `dispatchEvent` captures the value at start as a boundary so listeners
+  // registered mid-dispatch (id > maxId) are deferred to the next dispatch.
+  __publicField(_EventSystem, "nextId", 0);
+  var EventSystem = _EventSystem;
+
+  // src/audio/AudioBase.ts
+  var MEDIA_ERROR_CODES = {
+    1: "ABORTED",
+    2: "NETWORK",
+    3: "DECODE",
+    4: "SRC_NOT_SUPPORTED"
+  };
+  var AudioBase = class {
+    constructor(enabled = true) {
+      __publicField(this, "songs", /* @__PURE__ */ new Map());
+      __publicField(this, "_enabled");
+      __publicField(this, "registered", false);
+      this._enabled = enabled;
+      EventSystem.addEventListener("gameloopStopped", () => this.stop());
+    }
+    get enabled() {
+      return this._enabled;
+    }
+    set enabled(value) {
+      this._enabled = value;
+      if (!value) {
+        this.stop();
+      }
+    }
+    register(defaultVolume = 1, ...songs) {
+      this.throwOnBadVolume(defaultVolume, "defaultVolume");
+      if (this.registered) {
+        throw new Error("register() can only be called once per instance");
+      }
+      this.registered = true;
+      songs.forEach((song) => {
+        if (typeof song === "string") {
+          song = { name: urlBasename(song) ?? song, path: song };
+        } else if (song.volume !== void 0) {
+          this.throwOnBadVolume(song.volume, `Volume of "${song.name}"`);
+        }
+        const audio = new window.Audio();
+        audio.addEventListener("error", () => {
+          const err = audio.error;
+          const reason = err ? `${MEDIA_ERROR_CODES[err.code] ?? err.code}${err.message ? `: ${err.message}` : ""}` : "unknown";
+          console.error(
+            `Failed to load audio "${song.name}" from "${audio.src}": ${reason}`
+          );
+        });
+        audio.preload = "auto";
+        audio.src = song.path;
+        audio.id = song.name;
+        audio.volume = song.volume ?? defaultVolume;
+        audio.defaultVolume = audio.volume;
+        this.songs.set(song.name, audio);
+      });
+    }
+    stop() {
+    }
+    throwOnBadVolume(volume, name) {
+      if (!Number.isFinite(volume)) {
+        throw new Error(
+          name + " is invalid, it has to be in range of 0 to 1"
+        );
+      }
+      if (volume < 0) {
+        throw new Error(
+          name + " has to be above 0. What's a negative volume anyway?"
+        );
+      }
+      if (volume > 1) {
+        throw new Error(
+          name + " has to be lower or equal to 1! If you need a louder volume, you need to update the audio file itself."
+        );
+      }
+    }
+  };
+
+  // src/utilities/Number.ts
+  function approxEqual(a, b, epsilon = 1e-9) {
+    return Math.abs(a - b) <= epsilon;
+  }
+  function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+  }
+  function mapUnclamped(value, low1, high1, low2, high2) {
+    if (low1 === high1) {
+      return low2;
+    }
+    return low2 + (high2 - low2) * (value - low1) / (high1 - low1);
+  }
+  function map(value, low1, high1, low2, high2) {
+    return clamp(
+      mapUnclamped(value, low1, high1, low2, high2),
+      Math.min(low2, high2),
+      Math.max(low2, high2)
+    );
+  }
+  function threshold(value, cutoff) {
+    if (Math.abs(value) < cutoff) {
+      return 0;
+    }
+    return value;
+  }
+  function toDotted(value) {
+    return Math.round(value).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+  }
+  function wrapValue(value, min, max) {
+    if (approxEqual(min, max)) {
+      throw new RangeError(`wrapValue: min and max must differ (got ${min})`);
+    }
+    if (min > max) {
+      [min, max] = [max, min];
+    }
+    const range = max - min;
+    return ((value - min) % range + range) % range + min;
+  }
+
+  // src/utilities/Easing.ts
+  function easeIn(t) {
+    return t * t;
+  }
+  function easeInOut(t) {
+    return t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t);
+  }
+  function easeOut(t) {
+    return t * (2 - t);
+  }
+  function linear(t) {
+    return t;
+  }
+  var EASINGS = {
+    "ease-in": easeIn,
+    "ease-in-out": easeInOut,
+    "ease-out": easeOut,
+    "linear": linear
+  };
+
+  // src/utilities/Array.ts
+  function chunk(array, maxLength) {
+    if (!Number.isFinite(maxLength) || maxLength < 1) {
+      throw new RangeError(
+        `chunk: maxLength must be a finite number >= 1 (got ${maxLength})`
+      );
+    }
+    const result = [];
+    let part = [];
+    array.forEach((item, i) => {
+      part.push(item);
+      if (part.length === maxLength || i === array.length - 1) {
+        result.push(part);
+        part = [];
+      }
+    });
+    return result;
+  }
+  function randomItem(array) {
+    if (array.length === 0) {
+      throw new Error("randomItem called on empty array");
+    }
+    return array[Math.random() * array.length | 0];
+  }
+  function remove(arr, item) {
+    const index = arr.indexOf(item);
+    if (index >= 0) {
+      arr.splice(index, 1);
+    }
+  }
+  function shuffle(arr) {
+    const result = arr.slice();
+    for (let i = result.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+  }
+
+  // src/audio/Music.ts
+  var Music = class extends AudioBase {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "last", null);
+      __publicField(this, "current", null);
+      __publicField(this, "next", null);
+      __publicField(this, "fadeCancel", null);
+    }
+    get isPlaying() {
+      return !!this.fadeCancel || this.current instanceof window.Audio && !this.current.paused;
+    }
+    get enabled() {
+      return super.enabled;
+    }
+    set enabled(value) {
+      super.enabled = value;
+      if (value && !this.isPlaying) {
+        this.fade();
+      }
+    }
+    fade(name = null, fadeTime = 1e3, easing = {
+      cur: "ease-in",
+      next: "ease-out"
+    }) {
+      if (fadeTime <= 0) {
+        throw new Error(`fadeTime must be > 0, got ${fadeTime}`);
+      }
+      if (this.songs.size === 0) {
+        throw new Error("No music registered!");
+      }
+      if (name && !this.songs.has(name)) {
+        throw new Error(`Music "${name}" not registered!`);
+      }
+      if (!this.enabled) {
+        return;
+      }
+      if (this.fadeCancel) {
+        console.warn("Stopping current music fading.");
+        this.fadeCancel();
+        this.fadeCancel = null;
+        this.current?.stop();
+        this.current = this.next;
+        this.next = null;
+      }
+      if (this.songs.size === 1) {
+        console.info("Only one music registered, playing that looped.");
+        this.current = this.songs.values().next().value;
+        this.current.loop = true;
+        this.current.play();
+        return;
+      }
+      if (name) {
+        this.next = this.songs.get(name);
+      } else {
+        this.next = this.getRandom();
+        if (!this.next) {
+          console.warn(
+            "Not enough songs to pick a fresh one, replaying the previous one."
+          );
+          this.next = this.last;
+        }
+      }
+      this.next.onended = () => {
+        this.fade();
+      };
+      this.next.volume = 0;
+      this.next.play();
+      console.log(`Start fading to music: "${this.next.id}"`);
+      if (this.current) {
+        this.current.onended = () => void 0;
+      }
+      const curEase = EASINGS[easing.cur];
+      const nextEase = EASINGS[easing.next];
+      const fadeTimeSeconds = fadeTime / 1e3;
+      let time = 0;
+      const curStartVolume = this.current?.volume ?? 0;
+      this.fadeCancel = rafLoop((dt) => {
+        time += dt / fadeTimeSeconds;
+        if (this.current) {
+          this.current.volume = curStartVolume * (1 - clamp(curEase(time), 0, 1));
+        }
+        this.next.volume = this.next.defaultVolume * clamp(nextEase(time), 0, 1);
+        if (time >= 1) {
+          this.fadeCancel?.();
+          this.fadeCancel = null;
+          if (this.current) {
+            this.current.stop();
+            this.current.volume = this.current.defaultVolume;
+          }
+          this.next.volume = this.next.defaultVolume;
+          this.last = this.current;
+          this.current = this.next;
+          this.next = null;
+        }
+      });
+    }
+    stop() {
+      super.stop();
+      this.fadeCancel?.();
+      this.fadeCancel = null;
+      this.current?.stop();
+      this.next?.stop();
+      this.last = this.current;
+      this.current = this.next;
+      this.next = null;
+    }
+    getRandom() {
+      const allSongs = Array.from(this.songs.values());
+      if (this.last) {
+        remove(allSongs, this.last);
+      }
+      if (this.current) {
+        remove(allSongs, this.current);
+      }
+      if (allSongs.length === 0) {
+        return null;
+      }
+      return randomItem(allSongs);
+    }
+  };
+
+  // src/audio/Sound.ts
+  var Sound = class extends AudioBase {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "currentSounds", []);
+    }
+    play(name) {
+      if (this.songs.size === 0) {
+        throw new Error("No sounds registered!");
+      }
+      if (!this.songs.has(name)) {
+        throw new Error(`Sound "${name}" not registered!`);
+      }
+      if (!this.enabled) {
+        return Promise.resolve();
+      }
+      const newSound = this.songs.get(name).clone();
+      this.currentSounds.push(newSound);
+      const cleanup = () => remove(this.currentSounds, newSound);
+      newSound.onended = cleanup;
+      newSound.onerror = () => {
+        cleanup();
+        console.error(
+          `Playback failed for Sound "${name}", reason: ${newSound.error?.message ?? "unknown"}`
+        );
+      };
+      return newSound.play().catch((err) => {
+        cleanup();
+        throw err;
+      });
+    }
+    stop() {
+      super.stop();
+      this.currentSounds.forEach((audio) => audio.stop());
+      this.currentSounds.length = 0;
+    }
+  };
+
+  // src/utilities/Math.ts
+  var NUMERIC_PATTERN = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+  function isNumeric(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value);
+    }
+    if (typeof value === "string") {
+      return NUMERIC_PATTERN.test(value.trim());
+    }
+    return false;
+  }
+  function random2Pi() {
+    return Math.random() * Math.PI * 2;
+  }
+  function randomBetweenFloat(min, max) {
+    if (min > max) {
+      [min, max] = [max, min];
+    }
+    return min + Math.random() * (max - min);
+  }
+  function randomBetweenInt(min, max) {
+    if (min > max) {
+      [min, max] = [max, min];
+    }
+    return Math.floor(min + Math.random() * (max - min + 1));
+  }
+  function randomBoolean() {
+    return Math.random() >= 0.5;
+  }
+  function randomSign() {
+    return randomBoolean() ? 1 : -1;
+  }
+  var warnInvalidTime = throttle((count) => {
+    console.warn(
+      `toHHMMSS() received invalid input (NaN, Infinity, or negative) x${count} since last warning; returning "00:00".`
+    );
+  });
+  function toHHMMSS(time) {
+    if (!Number.isFinite(time) || time < 0) {
+      warnInvalidTime();
+      return "00:00";
+    }
+    time = Math.floor(time);
+    const h = Math.floor(time / 3600);
+    const m = Math.floor((time - h * 3600) / 60);
+    const s = time - h * 3600 - m * 60;
+    const hours = h < 10 ? "0" + h : "" + h;
+    const minutes = m < 10 ? "0" + m : "" + m;
+    const seconds = s < 10 ? "0" + s : "" + s;
+    if (h === 0) {
+      return `${minutes}:${seconds}`;
+    }
+    return `${hours}:${minutes}:${seconds}`;
+  }
+  function toDegrees(radians) {
+    return radians * 180 / Math.PI;
+  }
+  function toRadians(degrees) {
+    return degrees * Math.PI / 180;
+  }
+  function wrapRadians(angle) {
+    return wrapValue(angle, -Math.PI, Math.PI);
+  }
+  function wrapDegrees(angle) {
+    return wrapValue(angle, -180, 180);
+  }
+  function roundTo(number, digitsAfterPoint) {
+    const power = Math.pow(10, digitsAfterPoint);
+    return Math.round(number * power) / power;
+  }
+  var factorialsCache = { 0: 1 };
+  var largestCachedFactorial = 0;
+  var factorialOverflowAt = Infinity;
+  function getFactorial(n) {
+    const intN = Math.floor(n);
+    if (intN < 0 || !Number.isFinite(intN)) {
+      throw new Error("getFactorial requires non-negative integer");
+    }
+    if (intN >= factorialOverflowAt) {
+      return Infinity;
+    }
+    if (factorialsCache[intN] !== void 0) {
+      return factorialsCache[intN];
+    }
+    let result = factorialsCache[largestCachedFactorial];
+    for (let i = largestCachedFactorial + 1; i <= intN; i++) {
+      result *= i;
+      if (!Number.isFinite(result)) {
+        factorialOverflowAt = i;
+        return Infinity;
+      }
+      factorialsCache[i] = result;
+      largestCachedFactorial = i;
+    }
+    return result;
+  }
+
+  // src/utilities/Color.ts
+  function rgb2hex(red, green, blue) {
+    return "#" + (16777216 + rgb2Int(red, green, blue)).toString(16).slice(1);
+  }
+  function rgb2Int(red, green, blue, alpha) {
+    if (alpha === void 0) {
+      return red << 16 | green << 8 | blue;
+    }
+    const a = Math.round(alpha * 255);
+    return (red << 24 | green << 16 | blue << 8 | a) >>> 0;
+  }
+  function hex2rgb(hex) {
+    return hex.replace(
+      /^#?([a-f\d])([a-f\d])([a-f\d])$/i,
+      (_, r, g, b) => "#" + r + r + g + g + b + b
+    ).substring(1).match(/.{2}/g).map((x) => parseInt(x, 16));
+  }
+  function hue2rgb(p, q, t) {
+    if (t < 0) {
+      t += 1;
+    }
+    if (t > 1) {
+      t -= 1;
+    }
+    if (t < 1 / 6) {
+      return p + (q - p) * 6 * t;
+    }
+    if (t < 1 / 2) {
+      return q;
+    }
+    if (t < 2 / 3) {
+      return p + (q - p) * (2 / 3 - t) * 6;
+    }
+    return p;
+  }
+  function randomHex() {
+    return "#" + Math.random().toString(16).slice(2, 6);
+  }
+  function randomRgb(min = 0, max = 255) {
+    return [
+      randomBetweenInt(min, max),
+      randomBetweenInt(min, max),
+      randomBetweenInt(min, max)
+    ];
+  }
+
+  // src/color/Color.ts
+  var Color = class _Color {
+    constructor(r, g, b, a) {
+      __publicField(this, "_r");
+      __publicField(this, "_g");
+      __publicField(this, "_b");
+      __publicField(this, "_alpha", 1);
+      this.set(r, g, b, a);
+    }
+    static fromHex(hex) {
+      let cleanHex = hex.replace("#", "").toUpperCase();
+      if (!/^[0-9A-F]+$/.test(cleanHex)) {
+        throw new Error(`Invalid hex color: ${hex}`);
+      }
+      if (cleanHex.length === 3 || cleanHex.length === 4) {
+        cleanHex = cleanHex.split("").map((c) => c + c).join("");
+      }
+      if (cleanHex.length !== 6 && cleanHex.length !== 8) {
+        throw new Error(`Invalid hex color: ${hex}`);
+      }
+      const r = parseInt(cleanHex.slice(0, 2), 16);
+      const g = parseInt(cleanHex.slice(2, 4), 16);
+      const b = parseInt(cleanHex.slice(4, 6), 16);
+      if (cleanHex.length === 8) {
+        const a = parseInt(cleanHex.slice(6, 8), 16);
+        return new _Color(r, g, b, a / 255);
+      }
+      return new _Color(r, g, b);
+    }
+    static fromHSL(h, s, l, a = 1) {
+      const hNorm = wrapValue(h, 0, 360) / 360;
+      const sNorm = s / 100;
+      const lNorm = l / 100;
+      let r, g, b;
+      if (sNorm === 0) {
+        r = g = b = lNorm;
+      } else {
+        const q = lNorm < 0.5 ? lNorm * (1 + sNorm) : lNorm + sNorm - lNorm * sNorm;
+        const p = 2 * lNorm - q;
+        r = hue2rgb(p, q, hNorm + 1 / 3);
+        g = hue2rgb(p, q, hNorm);
+        b = hue2rgb(p, q, hNorm - 1 / 3);
+      }
+      return new _Color(r * 255, g * 255, b * 255, a);
+    }
+    get r() {
+      return this._r;
+    }
+    get g() {
+      return this._g;
+    }
+    get b() {
+      return this._b;
+    }
+    get alpha() {
+      return this._alpha;
+    }
+    set(r, g, b, a) {
+      this._r = clamp(r, 0, 255);
+      this._g = clamp(g, 0, 255);
+      this._b = clamp(b, 0, 255);
+      if (a !== void 0) {
+        const clamped = clamp(a, 0, 1);
+        this._alpha = approxEqual(clamped, 0) ? 0 : approxEqual(clamped, 1) ? 1 : clamped;
+      }
+      return this;
+    }
+    applyMatrix(m1, m2, m3, m4, m5, m6, m7, m8, m9) {
+      return this.set(
+        this.r * m1 + this.g * m2 + this.b * m3,
+        this.r * m4 + this.g * m5 + this.b * m6,
+        this.r * m7 + this.g * m8 + this.b * m9
+      );
+    }
+    brightness(factor) {
+      return this.set(this.r * factor, this.g * factor, this.b * factor);
+    }
+    contrast(factor) {
+      const midtone = 127.5;
+      return this.set(
+        midtone + (this.r - midtone) * factor,
+        midtone + (this.g - midtone) * factor,
+        midtone + (this.b - midtone) * factor
+      );
+    }
+    grayscale(value = 1) {
+      const m1 = 0.2126 + 0.7874 * (1 - value);
+      const m2 = 0.7152 - 0.7152 * (1 - value);
+      const m3 = 0.0722 - 0.0722 * (1 - value);
+      const m4 = 0.2126 - 0.2126 * (1 - value);
+      const m5 = 0.7152 + 0.2848 * (1 - value);
+      const m6 = 0.0722 - 0.0722 * (1 - value);
+      const m7 = 0.2126 - 0.2126 * (1 - value);
+      const m8 = 0.7152 - 0.7152 * (1 - value);
+      const m9 = 0.0722 + 0.9278 * (1 - value);
+      return this.applyMatrix(m1, m2, m3, m4, m5, m6, m7, m8, m9);
+    }
+    hueRotate(radians) {
+      const cos = Math.cos(radians);
+      const sin = Math.sin(radians);
+      const m1 = 0.213 + cos * 0.787 - sin * 0.213;
+      const m2 = 0.715 - cos * 0.715 - sin * 0.715;
+      const m3 = 0.072 - cos * 0.072 + sin * 0.928;
+      const m4 = 0.213 - cos * 0.213 + sin * 0.143;
+      const m5 = 0.715 + cos * 0.285 + sin * 0.14;
+      const m6 = 0.072 - cos * 0.072 - sin * 0.283;
+      const m7 = 0.213 - cos * 0.213 - sin * 0.787;
+      const m8 = 0.715 - cos * 0.715 + sin * 0.715;
+      const m9 = 0.072 + cos * 0.928 + sin * 0.072;
+      return this.applyMatrix(m1, m2, m3, m4, m5, m6, m7, m8, m9);
+    }
+    invert(factor = 1) {
+      return this.set(
+        this.r * (1 - factor) + (255 - this.r) * factor,
+        this.g * (1 - factor) + (255 - this.g) * factor,
+        this.b * (1 - factor) + (255 - this.b) * factor
+      );
+    }
+    mix(other, amount) {
+      const inv = 1 - amount;
+      return this.set(
+        this.r * inv + other.r * amount,
+        this.g * inv + other.g * amount,
+        this.b * inv + other.b * amount,
+        this.alpha * inv + other.alpha * amount
+      );
+    }
+    round() {
+      return this.set(
+        Math.round(this.r),
+        Math.round(this.g),
+        Math.round(this.b)
+      );
+    }
+    saturate(value = 1) {
+      const m1 = 0.213 + 0.787 * value;
+      const m2 = 0.715 - 0.715 * value;
+      const m3 = 0.072 - 0.072 * value;
+      const m4 = 0.213 - 0.213 * value;
+      const m5 = 0.715 + 0.285 * value;
+      const m6 = 0.072 - 0.072 * value;
+      const m7 = 0.213 - 0.213 * value;
+      const m8 = 0.715 - 0.715 * value;
+      const m9 = 0.072 + 0.928 * value;
+      return this.applyMatrix(m1, m2, m3, m4, m5, m6, m7, m8, m9);
+    }
+    sepia(value = 1) {
+      const m1 = 0.393 + 0.607 * (1 - value);
+      const m2 = 0.769 - 0.769 * (1 - value);
+      const m3 = 0.189 - 0.189 * (1 - value);
+      const m4 = 0.349 - 0.349 * (1 - value);
+      const m5 = 0.686 + 0.314 * (1 - value);
+      const m6 = 0.168 - 0.168 * (1 - value);
+      const m7 = 0.272 - 0.272 * (1 - value);
+      const m8 = 0.534 - 0.534 * (1 - value);
+      const m9 = 0.131 + 0.869 * (1 - value);
+      return this.applyMatrix(m1, m2, m3, m4, m5, m6, m7, m8, m9);
+    }
+    shade(percent) {
+      const target = percent < 0 ? 0 : 255;
+      const p = Math.abs(percent);
+      return this.set(
+        this.r + (target - this.r) * p,
+        this.g + (target - this.g) * p,
+        this.b + (target - this.b) * p
+      );
+    }
+    toHex() {
+      const r = Math.round(this.r).toString(16).padStart(2, "0");
+      const g = Math.round(this.g).toString(16).padStart(2, "0");
+      const b = Math.round(this.b).toString(16).padStart(2, "0");
+      const rgb = `#${r}${g}${b}`;
+      if (this.alpha === 1) {
+        return rgb;
+      }
+      const a = Math.round(this.alpha * 255);
+      return `${rgb}${a.toString(16).padStart(2, "0")}`;
+    }
+    toHSL() {
+      const { h, s, l } = this.toHSLObject();
+      const cssH = Math.round(h);
+      const cssS = Math.round(s);
+      const cssL = Math.round(l);
+      return this.alpha === 1 ? `hsl(${cssH}, ${cssS}%, ${cssL}%)` : `hsla(${cssH}, ${cssS}%, ${cssL}%, ${this.alpha.toFixed(2)})`;
+    }
+    toHSLObject() {
+      const r = this.r / 255;
+      const g = this.g / 255;
+      const b = this.b / 255;
+      const max = Math.max(r, g, b);
+      const min = Math.min(r, g, b);
+      const l = (max + min) / 2;
+      let h = 0;
+      let s = 0;
+      if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+          case r:
+            h = (g - b) / d + (g < b ? 6 : 0);
+            break;
+          case g:
+            h = (b - r) / d + 2;
+            break;
+          case b:
+            h = (r - g) / d + 4;
+            break;
+        }
+        h /= 6;
+      }
+      return { h: h * 360, s: s * 100, l: l * 100, a: this.alpha };
+    }
+    toRGB() {
+      const r = Math.round(this.r);
+      const g = Math.round(this.g);
+      const b = Math.round(this.b);
+      return this.alpha === 1 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${this.alpha.toFixed(2)})`;
+    }
+    clone() {
+      return new _Color(this.r, this.g, this.b, this.alpha);
+    }
+    equals(other, compareAlpha = true) {
+      return approxEqual(this.r, other.r) && approxEqual(this.g, other.g) && approxEqual(this.b, other.b) && (!compareAlpha || approxEqual(this.alpha, other.alpha));
+    }
+  };
+
+  // src/color/ColorShifter.ts
+  var SATURATE = 2;
+  var HUE_ROTATE = 3;
+  var BRIGHTNESS = 4;
+  var CONTRAST = 5;
+  function colorShifter(rgb) {
+    const color = new Color(rgb[0], rgb[1], rgb[2]);
+    const solver = new Solver(color);
+    const result = solver.solve();
+    return result.filter.replace("filter: ", "").replace(";", "");
+  }
+  var Solver = class {
+    constructor(target) {
+      __publicField(this, "reusedColor");
+      __publicField(this, "target");
+      __publicField(this, "targetHSL");
+      this.target = target;
+      this.targetHSL = target.toHSLObject();
+      this.reusedColor = new Color(0, 0, 0);
+    }
+    css(filters) {
+      const [invert, sepia, saturate, hueRotate, brightness, contrast] = filters;
+      return `filter: invert(${Math.round(invert)}%) sepia(${Math.round(sepia)}%) saturate(${Math.round(saturate)}%) hue-rotate(${Math.round(hueRotate * 3.6)}deg) brightness(${Math.round(brightness)}%) contrast(${Math.round(contrast)}%);`;
+    }
+    loss(filters) {
+      const [invert, sepia, saturate, hueRotate, brightness, contrast] = filters;
+      const color = this.reusedColor;
+      color.set(0, 0, 0);
+      color.invert(invert / 100);
+      color.sepia(sepia / 100);
+      color.saturate(saturate / 100);
+      color.hueRotate(hueRotate / 100 * Math.PI * 2);
+      color.brightness(brightness / 100);
+      color.contrast(contrast / 100);
+      const colorHSL = color.toHSLObject();
+      return Math.abs(color.r - this.target.r) + Math.abs(color.g - this.target.g) + Math.abs(color.b - this.target.b) + // h is cyclic 0-360; wrap diff into ±180 then scale to 0-100 to keep loss balance with the other terms
+      Math.abs(wrapDegrees(colorHSL.h - this.targetHSL.h)) / 1.8 + Math.abs(colorHSL.s - this.targetHSL.s) + Math.abs(colorHSL.l - this.targetHSL.l);
+    }
+    solve() {
+      const result = this.solveNarrow(this.solveWide());
+      return {
+        values: result.values,
+        loss: result.loss,
+        filter: this.css(result.values)
+      };
+    }
+    solveNarrow(wide) {
+      const A = wide.loss;
+      const c = 2;
+      const A1 = A + 1;
+      const a = [
+        0.25 * A1,
+        0.25 * A1,
+        A1,
+        0.25 * A1,
+        0.2 * A1,
+        0.2 * A1
+      ];
+      return this.spsa(A, a, c, wide.values, 500);
+    }
+    solveWide() {
+      const A = 5;
+      const c = 15;
+      const a = [60, 180, 18e3, 600, 1.2, 1.2];
+      let best = {
+        loss: Infinity,
+        values: [50, 20, 3750, 50, 100, 100]
+      };
+      for (let i = 0; best.loss > 25 && i < 3; i++) {
+        const initial = [50, 20, 3750, 50, 100, 100];
+        const result = this.spsa(A, a, c, initial, 1e3);
+        if (result.loss < best.loss) {
+          best = result;
+        }
+      }
+      return best;
+    }
+    spsa(A, a, c, values, iters) {
+      values = values.slice();
+      const alpha = 1;
+      const gamma = 0.16666666666666666;
+      let best = values.slice();
+      let bestLoss = Infinity;
+      const deltas = [0, 0, 0, 0, 0, 0];
+      const highArgs = [0, 0, 0, 0, 0, 0];
+      const lowArgs = [0, 0, 0, 0, 0, 0];
+      for (let k = 0; k < iters; k++) {
+        const ck = c / Math.pow(k + 1, gamma);
+        for (let i = 0; i < 6; i++) {
+          deltas[i] = Math.random() > 0.5 ? 1 : -1;
+          highArgs[i] = values[i] + ck * deltas[i];
+          lowArgs[i] = values[i] - ck * deltas[i];
+        }
+        const lossDiff = this.loss(highArgs) - this.loss(lowArgs);
+        for (let i = 0; i < 6; i++) {
+          const g = lossDiff / (2 * ck) * deltas[i];
+          const ak = a[i] / Math.pow(A + k + 1, alpha);
+          values[i] = fix(values[i] - ak * g, i);
+        }
+        const loss = this.loss(values);
+        if (loss < bestLoss) {
+          best = values.slice();
+          bestLoss = loss;
+        }
+      }
+      return { values: best, loss: bestLoss };
+      function fix(value, idx) {
+        let max = 100;
+        if (idx === SATURATE) {
+          max = 7500;
+        } else if (idx === BRIGHTNESS || idx === CONTRAST) {
+          max = 200;
+        }
+        if (idx === HUE_ROTATE) {
+          value = wrapValue(value, 0, max);
+        } else if (value < 0) {
+          value = 0;
+        } else if (value > max) {
+          value = max;
+        }
+        return value;
+      }
+    }
+  };
+
+  // src/math/Rect.ts
+  var Rect = class _Rect {
+    constructor(x = 0, y = 0, w = 0, h = 0) {
+      __publicField(this, "_h", 0);
+      __publicField(this, "_w", 0);
+      __publicField(this, "_x", 0);
+      __publicField(this, "_y", 0);
+      __publicField(this, "_sides");
+      __publicField(this, "sideIsDirty", true);
+      this.set(x, y, w, h);
+    }
+    static fromBoundingClientRect(rect) {
+      if (rect instanceof HTMLElement) {
+        rect = rect.getBoundingClientRect();
+      }
+      return new _Rect(rect.left, rect.top, rect.width, rect.height);
+    }
+    static fromPolygon(polygon) {
+      if (polygon.points.length === 0) {
+        throw new Error("Supplied polygon has no points!");
+      }
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      polygon.points.forEach((point) => {
+        if (point.x < minX) {
+          minX = point.x;
+        }
+        if (point.x > maxX) {
+          maxX = point.x;
+        }
+        if (point.y < minY) {
+          minY = point.y;
+        }
+        if (point.y > maxY) {
+          maxY = point.y;
+        }
+      });
+      return new _Rect(minX, minY, maxX - minX, maxY - minY);
+    }
+    get h() {
+      return this._h;
+    }
+    set h(value) {
+      this._h = value;
+      this.sideIsDirty = true;
+    }
+    get w() {
+      return this._w;
+    }
+    set w(value) {
+      this._w = value;
+      this.sideIsDirty = true;
+    }
+    get x() {
+      return this._x;
+    }
+    set x(value) {
+      this._x = value;
+      this.sideIsDirty = true;
+    }
+    get y() {
+      return this._y;
+    }
+    set y(value) {
+      this._y = value;
+      this.sideIsDirty = true;
+    }
+    get sides() {
+      if (this.sideIsDirty) {
+        this._sides = {
+          bottom: this.y + this.h,
+          centerPos: new Vec2(
+            this.x + this.w * 0.5,
+            this.y + this.h * 0.5
+          ),
+          halfSize: new Vec2(this.w * 0.5, this.h * 0.5),
+          right: this.x + this.w
+        };
+        this.sideIsDirty = false;
+      }
+      return this._sides;
+    }
+    inflate(delta) {
+      this.x -= delta;
+      this.y -= delta;
+      this.w += 2 * delta;
+      this.h += 2 * delta;
+      this.sideIsDirty = true;
+      return this;
+    }
+    round() {
+      this.x = Math.round(this.x);
+      this.y = Math.round(this.y);
+      this.sideIsDirty = true;
+      return this;
+    }
+    set(x = 0, y = 0, w, h) {
+      if (typeof x === "number") {
+        this.x = x;
+        this.y = y;
+      } else {
+        if ("w" in x) {
+          this.w = x.w;
+          this.h = x.h;
+        }
+        this.x = x.x;
+        this.y = x.y;
+      }
+      if (w !== void 0) {
+        this.w = w;
+      }
+      if (h !== void 0) {
+        this.h = h;
+      }
+      this.sideIsDirty = true;
+      return this;
+    }
+    collide(rect) {
+      return this.x <= rect.x + rect.w && this.x + this.w >= rect.x && this.y <= rect.y + rect.h && this.y + this.h >= rect.y;
+    }
+    collideFull(rect) {
+      return rect.x + rect.w <= this.x + this.w && rect.x >= this.x && rect.y >= this.y && rect.y + rect.h <= this.y + this.h;
+    }
+    collidePoint(vec) {
+      return this.x <= vec.x && vec.x <= this.x + this.w && this.y <= vec.y && vec.y <= this.y + this.h;
+    }
+    collideSide(rect) {
+      const dx = this.x + this.w * 0.5 - (rect.x + rect.w * 0.5);
+      const dy = this.y + this.h * 0.5 - (rect.y + rect.h * 0.5);
+      const width = (this.w + rect.w) * 0.5;
+      const height = (this.h + rect.h) * 0.5;
+      const crossWidth = width * dy;
+      const crossHeight = height * dx;
+      let collision = "none";
+      if (Math.abs(dx) <= width && Math.abs(dy) <= height) {
+        if (crossWidth > crossHeight) {
+          collision = crossWidth > -crossHeight ? "bottom" : "left";
+        } else {
+          collision = crossWidth > -crossHeight ? "right" : "top";
+        }
+      }
+      return collision;
+    }
+    pos() {
+      return new Vec2(this.x, this.y);
+    }
+    size() {
+      return new Vec2(this.w, this.h);
+    }
+    toString() {
+      return `Rect [x: ${this.x}, y: ${this.y}, w: ${this.w}, h: ${this.h}]`;
+    }
+    clone() {
+      return new _Rect(this.x, this.y, this.w, this.h);
+    }
+    equals(other, withSize = true) {
+      let output = approxEqual(this.x, other.x) && approxEqual(this.y, other.y);
+      if (output && withSize) {
+        output = approxEqual(this.w, other.w) && approxEqual(this.h, other.h);
+      }
+      return output;
+    }
+  };
+
+  // src/math/Vec2.ts
+  var Operation = {
+    Add: 1,
+    Sub: 2,
+    Mult: 3,
+    Div: 4,
+    Rem: 5,
+    Equal: 6,
+    Mod: 7
+  };
+  var warnZeroNormalize = throttle(
+    (count) => console.warn(
+      `Vec2.normalize() called on zero vector x${count} since last warning; returning zero.`
+    )
+  );
+  var warnNonFinite = throttle(
+    (count) => console.warn(
+      `Vec2 operation produced non-finite value x${count} since last warning; check for zero divisor.`
+    )
+  );
+  var Vec2 = class _Vec2 {
+    constructor(x = 0, y) {
+      __publicField(this, "x", 0);
+      __publicField(this, "y", 0);
+      this.calculate(Operation.Equal, x, y);
+    }
+    static fromAngle(rad, scaleX = 1, scaleY = scaleX) {
+      return new _Vec2(Math.cos(rad) * scaleX, Math.sin(rad) * scaleY);
+    }
+    set(x, y) {
+      return this.calculate(Operation.Equal, x, y);
+    }
+    abs() {
+      return this.map(Math.abs);
+    }
+    add(x, y) {
+      return this.calculate(Operation.Add, x, y);
+    }
+    ceil() {
+      return this.map(Math.ceil);
+    }
+    clamp(x, y = x) {
+      this.x = clamp(this.x, x[0], x[1]);
+      this.y = clamp(this.y, y[0], y[1]);
+      return this;
+    }
+    div(x, y) {
+      return this.calculate(Operation.Div, x, y);
+    }
+    floor() {
+      return this.map(Math.floor);
+    }
+    map(callback) {
+      this.x = callback(this.x, 0);
+      this.y = callback(this.y, 1);
+      return this;
+    }
+    mod(x, y) {
+      return this.calculate(Operation.Mod, x, y);
+    }
+    mult(x, y) {
+      return this.calculate(Operation.Mult, x, y);
+    }
+    negate() {
+      return this.mult(-1);
+    }
+    normalize() {
+      const length = this.length();
+      if (approxEqual(length, 0)) {
+        warnZeroNormalize();
+        return this;
+      }
+      return this.map((value) => value / length);
+    }
+    normalizeManhattan() {
+      const length = this.lengthManhattan();
+      if (approxEqual(length, 0)) {
+        return this;
+      }
+      return this.map((value) => value / length);
+    }
+    rem(x, y) {
+      return this.calculate(Operation.Rem, x, y);
+    }
+    round() {
+      this.x = Math.round(this.x);
+      this.y = Math.round(this.y);
+      return this;
+    }
+    sub(x, y) {
+      return this.calculate(Operation.Sub, x, y);
+    }
+    angle(other) {
+      if (!other) {
+        return Math.atan2(this.y, this.x);
+      }
+      return Math.atan2(other.y - this.y, other.x - this.x);
+    }
+    distance(other) {
+      return Math.sqrt(
+        Math.pow(other.x - this.x, 2) + Math.pow(other.y - this.y, 2)
+      );
+    }
+    distanceManhattan(other) {
+      return Math.abs(other.x - this.x) + Math.abs(other.y - this.y);
+    }
+    dotProduct(other) {
+      return this.x * other.x + this.y * other.y;
+    }
+    isValid() {
+      return Number.isFinite(this.x) && Number.isFinite(this.y);
+    }
+    length() {
+      return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    lengthManhattan() {
+      return Math.abs(this.x) + Math.abs(this.y);
+    }
+    max() {
+      return Math.max(this.x, this.y);
+    }
+    min() {
+      return Math.min(this.x, this.y);
+    }
+    toArray() {
+      return [this.x, this.y];
+    }
+    toRectAddPos(x, y) {
+      return this.concat(true, x, y);
+    }
+    toRectAddSize(width, height) {
+      return this.concat(false, width, height);
+    }
+    toString() {
+      return `Vec2 [x: ${this.x}, y: ${this.y}]`;
+    }
+    clone() {
+      return new _Vec2(this.x, this.y);
+    }
+    equals(x, y) {
+      const [x2, y2] = this.getValues(x, y);
+      return approxEqual(this.x, x2) && approxEqual(this.y, y2);
+    }
+    calculate(operation, x, y) {
+      const [x2, y2] = this.getValues(x, y);
+      switch (operation) {
+        case Operation.Add:
+          this.x += x2;
+          this.y += y2;
+          break;
+        case Operation.Sub:
+          this.x -= x2;
+          this.y -= y2;
+          break;
+        case Operation.Mult:
+          this.x *= x2;
+          this.y *= y2;
+          break;
+        case Operation.Div:
+          this.x /= x2;
+          this.y /= y2;
+          break;
+        case Operation.Rem:
+          this.x %= x2;
+          this.y %= y2;
+          break;
+        case Operation.Equal:
+          this.x = x2;
+          this.y = y2;
+          break;
+        case Operation.Mod:
+          this.x = (this.x % x2 + x2) % x2;
+          this.y = (this.y % y2 + y2) % y2;
+          break;
+        default:
+          operation;
+          break;
+      }
+      if (!this.isValid()) {
+        warnNonFinite();
+      }
+      return this;
+    }
+    concat(first, x, y) {
+      const [x2, y2] = this.getValues(x, y);
+      if (first) {
+        return new Rect(x2, y2, this.x, this.y);
+      }
+      return new Rect(this.x, this.y, x2, y2);
+    }
+    getValues(x, y) {
+      let inputX = 0;
+      let inputY = 0;
+      if (typeof x === "number") {
+        inputX = x;
+        if (y === void 0) {
+          inputY = x;
+        } else {
+          inputY = y;
+        }
+      } else {
+        if (y === void 0) {
+          inputX = x.x;
+          inputY = x.y;
+        } else {
+          throw new Error("When x is a Vector2, y must be omitted!");
+        }
+      }
+      return [inputX, inputY];
+    }
+  };
+
+  // src/core/Settings.ts
+  var LOCAL_STORAGE_KEY = "gleam";
+  var Settings = class {
+    static get localStorage() {
+      return this._localStorage;
+    }
+    static init(overrides, game) {
+      if (this.initialized) {
+        throw new Error("Settings.init called twice");
+      }
+      Object.assign(this, overrides);
+      if (!(Number.isFinite(this.fps) && this.fps > 0)) {
+        throw new Error(`Settings.fps must be > 0, got ${this.fps}`);
+      }
+      if (this.debug) {
+        window.game = game;
+      }
+      if (this.warnBeforeClose) {
+        window.addEventListener(
+          "beforeunload",
+          (event) => {
+            this.triedToClose?.();
+            event.preventDefault();
+            event.returnValue = true;
+            return "Are you sure?";
+          },
+          false
+        );
+      }
+      this._localStorage.language = navigator.language.split("-")[0] || "en";
+      const storage = localStorage.getItem(LOCAL_STORAGE_KEY);
+      if (storage) {
+        try {
+          const parsed = JSON.parse(storage);
+          Object.assign(this._localStorage, parsed);
+        } catch (_e) {
+          console.error(
+            "Couldn't parse local storage! Will be cleaned now.",
+            storage
+          );
+          localStorage.removeItem(LOCAL_STORAGE_KEY);
+        }
+      }
+      this.initialized = true;
+    }
+    static setLocalStorage(key, value) {
+      this._localStorage[key] = value;
+      localStorage.setItem(
+        LOCAL_STORAGE_KEY,
+        JSON.stringify(this._localStorage)
+      );
+    }
+  };
+  __publicField(Settings, "antialias", false);
+  __publicField(Settings, "autoloop", true);
+  __publicField(Settings, "backgroundColor", "#444");
+  __publicField(Settings, "debug", false);
+  __publicField(Settings, "doNotClear", false);
+  __publicField(Settings, "enableResize", true);
+  __publicField(Settings, "font", "Arial");
+  __publicField(Settings, "fps", 1 / 60);
+  __publicField(Settings, "triedToClose");
+  __publicField(Settings, "useClearRect", true);
+  __publicField(Settings, "warnBeforeClose", false);
+  __publicField(Settings, "initialized", false);
+  // Only mutated via `setLocalStorage` (typed) and via the localStorage
+  // round-trip in `init()` — since `setLocalStorage` is the sole writer of
+  // the persisted blob, the parsed payload is trusted to match the schema.
+  __publicField(Settings, "_localStorage", {
+    language: ""
+  });
+
+  // src/utilities/DOM.ts
+  function getElement(query, parent = document) {
+    const el = parent.querySelector(query);
+    if (!el) {
+      throw new Error(`Element not found: ${query}`);
+    }
+    return el;
+  }
+  function styleElement(element, styles) {
+    Object.assign(element.style, styles);
+  }
+  function setDisplay(element, active) {
+    element.style.display = active ? "" : "none";
+  }
+  function setVisibility(element, active) {
+    element.style.visibility = active ? "" : "hidden";
+  }
+  function initCSSVariables() {
+    const root = getElement(":root");
+    return {
+      root,
+      get(name) {
+        return getComputedStyle(root).getPropertyValue("--" + name);
+      },
+      set(name, value) {
+        root.style.setProperty("--" + name, value);
+      }
+    };
+  }
+  function doWhilePressed(querySelector, callback, delay2 = 200) {
+    const element = getElement(querySelector);
+    let intervalId;
+    let activePointerId = null;
+    function start(event) {
+      if (activePointerId !== null) {
+        return;
+      }
+      activePointerId = event.pointerId;
+      element.setPointerCapture(activePointerId);
+      clearInterval(intervalId);
+      callback();
+      intervalId = setInterval(() => callback(), delay2);
+    }
+    function stop(event) {
+      if (event.pointerId !== activePointerId) {
+        return;
+      }
+      clearInterval(intervalId);
+      element.releasePointerCapture(event.pointerId);
+      activePointerId = null;
+    }
+    element.addEventListener("pointerdown", start);
+    element.addEventListener("pointerup", stop);
+    element.addEventListener("pointercancel", stop);
+    function dispose() {
+      element.removeEventListener("pointerdown", start);
+      element.removeEventListener("pointerup", stop);
+      element.removeEventListener("pointercancel", stop);
+      clearInterval(intervalId);
+      if (activePointerId !== null) {
+        element.releasePointerCapture(activePointerId);
+        activePointerId = null;
+      }
+    }
+    return dispose;
+  }
+  async function waitForEvent(element, type, signal) {
+    if (signal?.aborted) {
+      throw signal.reason;
+    }
+    return new Promise((resolve, reject) => {
+      element.addEventListener(type, () => resolve(), {
+        once: true,
+        signal
+      });
+      signal?.addEventListener("abort", () => reject(signal.reason), {
+        once: true
+      });
+    });
+  }
+
+  // src/utilities/Grid.ts
+  function cloneGrid(grid) {
+    return grid.map((row) => row.slice());
+  }
+  function convert1DTo2D(index, width) {
+    return {
+      x: index % width,
+      y: index / width | 0
+    };
+  }
+  function convert2DTo1D(indexX, indexY, width) {
+    return indexX + width * indexY;
+  }
+  function generateGrid(height, width, valueOrFactory) {
+    const isFactory = typeof valueOrFactory === "function";
+    return Array.from(
+      { length: height },
+      (_, y) => Array.from(
+        { length: width },
+        (_2, x) => isFactory ? valueOrFactory(x, y) : valueOrFactory
+      )
+    );
+  }
+
+  // src/utilities/Prototype.ts
+  function defineMethod(proto, name, value) {
+    Object.defineProperty(proto, name, {
+      value,
+      configurable: true,
+      writable: true
+    });
+  }
+
+  // src/loader/UrlLoaders.ts
+  var DEFAULT_TIMEOUT_MS = 1e4;
+  function validateUrl(url) {
+    const schemeMatch = url.trim().match(/^([a-z][a-z0-9+.-]*):/i);
+    if (!schemeMatch) {
+      return;
+    }
+    const scheme = schemeMatch[1].toLowerCase();
+    if (["blob", "data", "http", "https"].includes(scheme)) {
+      return;
+    }
+    throw new Error(`Invalid URL protocol: ${url}`);
+  }
+  function safeLoad(promise, url, operationName) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(
+          new Error(
+            `Timeout (${DEFAULT_TIMEOUT_MS}ms) when loading ${operationName}: ${url}`
+          )
+        );
+      }, DEFAULT_TIMEOUT_MS);
+    });
+    return Promise.race([promise, timeoutPromise]).catch((error) => {
+      clearTimeout(timeoutId);
+      const errorMessage = error?.message || String(error);
+      console.error(
+        `${operationName} failed on ${url}
+  ${errorMessage}`
+      );
+      throw error;
+    }).finally(() => clearTimeout(timeoutId));
+  }
+  async function loadImage(url) {
+    validateUrl(url);
+    return safeLoad(
+      new Promise((resolve, reject) => {
+        const image = new Image();
+        image.onload = () => resolve(image);
+        image.onerror = () => reject(new Error(`Image failed to load: ${url}`));
+        image.crossOrigin = "anonymous";
+        image.src = url;
+      }),
+      url,
+      "image"
+    );
+  }
+  async function loadCanvas(url) {
+    validateUrl(url);
+    return safeLoad(
+      (async () => {
+        const image = await loadImage(url);
+        const cc = createNewCanvas(image.width, image.height);
+        cc.canvas.id = url;
+        cc.context.drawImage(image, 0, 0);
+        return cc.canvas;
+      })(),
+      url,
+      "canvas"
+    );
+  }
+  async function loadText(url) {
+    validateUrl(url);
+    return safeLoad(
+      (async () => {
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(
+            `HTTP ${response.status}: Failed to load text from ${url}
+  Status: ${response.status} ${response.statusText}`
+          );
+        }
+        return response.text();
+      })(),
+      url,
+      "text"
+    );
+  }
+  async function loadJson(url) {
+    validateUrl(url);
+    return safeLoad(
+      loadText(url).then((text) => JSON.parse(text)),
+      url,
+      "JSON"
+    );
+  }
+  async function loadJsonCommented(url) {
+    validateUrl(url);
+    return safeLoad(
+      loadText(url).then((text) => {
+        const lines = text.split("\n").filter((line) => {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("//")) {
+            return false;
+          }
+          return true;
+        }).join("\n");
+        return JSON.parse(lines);
+      }),
+      url,
+      "JSON (commented)"
+    );
+  }
+  async function loadImageFromJson(baseUrl, filenameOrJson, jsonInput = false) {
+    if (!baseUrl.endsWith("/")) {
+      baseUrl += "/";
+    }
+    let json;
+    if (jsonInput) {
+      try {
+        json = JSON.parse(filenameOrJson);
+      } catch (parseError) {
+        throw new Error(
+          `Failed to parse inline JSON: ${parseError.message}`
+        );
+      }
+    } else {
+      const url = baseUrl + filenameOrJson + ".json";
+      json = await loadJson(url);
+    }
+    if (!json || !json.options?.file) {
+      const source = jsonInput ? "inline JSON" : `${baseUrl}${filenameOrJson}.json`;
+      throw new Error(
+        `JSON missing 'options.file' property
+  Source: ${source}`
+      );
+    }
+    const canvas = await loadCanvas(baseUrl + json.options.file);
+    const sprites = {};
+    if (!json.sprites || !Array.isArray(json.sprites)) {
+      throw new Error(
+        `JSON missing 'sprites' array
+  Source: ${baseUrl}${filenameOrJson}.json`
+      );
+    }
+    json.sprites.forEach((sprite, i) => {
+      if (sprite.x === void 0 || sprite.y === void 0 || !sprite.w || !sprite.h || !sprite.name) {
+        throw new Error(
+          `Invalid sprite data at index ${i}: ${JSON.stringify(sprite, null, 2)}`
+        );
+      }
+      const newSprite = canvas.subImage(
+        sprite.x,
+        sprite.y,
+        sprite.w,
+        sprite.h
+      );
+      for (const key in sprite) {
+        newSprite.dataset[key] = String(sprite[key]);
+      }
+      sprites[sprite.name] = newSprite;
+    });
+    return sprites;
+  }
+  async function loadBunch(bunch) {
+    const output = {};
+    const keys = Object.keys(bunch);
+    return Promise.all(keys.map((k) => bunch[k])).then((datas) => {
+      keys.forEach((key, i) => {
+        output[key] = datas[i];
+      });
+      return output;
+    });
+  }
+
+  // src/prototypes/HTMLCanvasElement.ts
+  defineMethod(HTMLCanvasElement.prototype, "hasAnyColor", function() {
+    const pixels = this.getContext("2d").getImageData(
+      0,
+      0,
+      this.width,
+      this.height
+    ).data;
+    return pixels.some((pixel) => pixel !== 0);
+  });
+  defineMethod(HTMLCanvasElement.prototype, "getPixelAt", function(x, y, output = "integer") {
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 0;
+    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
+      const data = this.getContext("2d").getImageData(x, y, 1, 1).data;
+      r = data[0];
+      g = data[1];
+      b = data[2];
+      a = data[3];
+    }
+    switch (output) {
+      case "array":
+        return [r, g, b, a];
+      case "json":
+        return { r, g, b, a };
+      case "string":
+        return `rgba(${r}, ${g}, ${b}, ${a})`;
+      case "integer":
+      default:
+        return rgb2Int(r, g, b, a / 255);
+    }
+  });
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "replaceColors",
+    function(replacements) {
+      const lookup = /* @__PURE__ */ new Map();
+      for (const from in replacements) {
+        const [fr, fg, fb] = hex2rgb(from);
+        const [tr, tg, tb] = hex2rgb(replacements[from]);
+        lookup.set(rgb2Int(fr, fg, fb), [tr, tg, tb]);
+      }
+      const context = this.getContext("2d");
+      const image = context.getImageData(0, 0, this.width, this.height);
+      const { data } = image;
+      for (let i = 0; i < data.length; i += 4) {
+        if (data[i + 3] === 0) {
+          continue;
+        }
+        const replacement = lookup.get(
+          rgb2Int(data[i], data[i + 1], data[i + 2])
+        );
+        if (replacement !== void 0) {
+          data[i] = replacement[0];
+          data[i + 1] = replacement[1];
+          data[i + 2] = replacement[2];
+        }
+      }
+      context.putImageData(image, 0, 0);
+      return this;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "rotateBy",
+    function(radians) {
+      const diam = Math.ceil(
+        Math.sqrt(this.width * this.width + this.height * this.height)
+      );
+      const cc = createNewCanvas(diam, diam);
+      cc.context.translate(diam * 0.5, diam * 0.5);
+      cc.context.rotate(radians);
+      cc.context.drawImage(this, -this.width * 0.5, -this.height * 0.5);
+      cc.context.translate(-diam * 0.5, -diam * 0.5);
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "rotateByAligned",
+    function(radians) {
+      const cc = createNewCanvas(this.width, this.height);
+      cc.context.translate(this.width * 0.5, this.height * 0.5);
+      cc.context.rotate(radians);
+      cc.context.translate(-this.width * 0.5, -this.height * 0.5);
+      cc.context.drawImage(this, 0, 0);
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "autoCrop",
+    function() {
+      const topLeft = {
+        x: this.width,
+        y: this.height,
+        update(x, y) {
+          this.x = Math.min(this.x, x);
+          this.y = Math.min(this.y, y);
+        }
+      };
+      const bottomRight = {
+        x: 0,
+        y: 0,
+        update(x, y) {
+          this.x = Math.max(this.x, x);
+          this.y = Math.max(this.y, y);
+        }
+      };
+      const context = this.getContext("2d");
+      const imageData = context.getImageData(0, 0, this.width, this.height);
+      for (let y = 0; y < this.height; y++) {
+        for (let x = 0; x < this.width; x++) {
+          const alpha = imageData.data[convert2DTo1D(x * 4, y * 4, this.width) + 3];
+          if (alpha !== 0) {
+            topLeft.update(x, y);
+            bottomRight.update(x, y);
+          }
+        }
+      }
+      if (topLeft.x > bottomRight.x) {
+        return this.clone();
+      }
+      const width = bottomRight.x - topLeft.x + 1;
+      const height = bottomRight.y - topLeft.y + 1;
+      return this.subImage(topLeft.x, topLeft.y, width, height);
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "scaleBy",
+    function(scaleX = 1, scaleY = scaleX) {
+      if (scaleX <= 0 || scaleY <= 0) {
+        throw new Error(
+          `scaleBy requires positive scale factors, got: ${scaleX} x ${scaleY}`
+        );
+      }
+      const cc = createNewCanvas(this.width * scaleX, this.height * scaleY);
+      cc.context.scale(scaleX, scaleY);
+      cc.context.drawImage(this, 0, 0);
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "resize",
+    function(size, isWidth = true) {
+      if (isWidth) {
+        return this.scaleBy(size / this.width);
+      }
+      return this.scaleBy(size / this.height);
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "flipX",
+    function(offsetX = 0) {
+      const cc = createNewCanvas(this.width, this.height);
+      cc.context.translate(this.width + offsetX, 0);
+      cc.context.scale(-1, 1);
+      cc.context.drawImage(this, 0, 0);
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "flipY",
+    function(offsetY = 0) {
+      const cc = createNewCanvas(this.width, this.height);
+      cc.context.translate(0, this.height + offsetY);
+      cc.context.scale(1, -1);
+      cc.context.drawImage(this, 0, 0);
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "subImage",
+    function(x, y, w, h) {
+      if (w === void 0) {
+        w = this.width;
+      }
+      if (h === void 0) {
+        h = this.height;
+      }
+      const cc = createNewCanvas(w, h);
+      cc.context.drawImage(this, x, y, w, h, 0, 0, w, h);
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "clone",
+    function() {
+      const cc = createNewCanvas(this.width, this.height);
+      cc.canvas.id = this.id;
+      cc.context.drawImage(this, 0, 0);
+      for (const key in this.dataset) {
+        cc.canvas.dataset[key] = this.dataset[key];
+      }
+      return cc.canvas;
+    }
+  );
+  defineMethod(
+    HTMLCanvasElement.prototype,
+    "toImage",
+    function() {
+      return loadImage(this.toDataURL());
+    }
+  );
+
+  // src/utilities/Canvas.ts
+  function createNewCanvas(width, height, antialias = Settings.antialias) {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const context = canvas.getContext("2d");
+    context.imageSmoothingEnabled = antialias;
+    return {
+      canvas,
+      context
+    };
+  }
+  function getCanvasConstruct(selector) {
+    const canvas = getElement(selector);
+    const context = canvas.getContext("2d");
+    return {
+      canvas,
+      context
+    };
+  }
+  function applyFilterOnCanvas(image, filter, width = image.width, height = image.height) {
+    const cc = createNewCanvas(width, height);
+    cc.context.filter = filter;
+    cc.context.drawImage(image, 0, 0);
+    cc.context.filter = "none";
+    return cc.canvas;
+  }
+  function rotateHue(image, hue, width, height) {
+    return applyFilterOnCanvas(
+      image,
+      "hue-rotate(" + hue + "deg)",
+      width,
+      height
+    );
+  }
+  function changeColor(context, oriImg, newColor) {
+    context.save();
+    context.clearRect(0, 0, oriImg.width, oriImg.height);
+    context.globalCompositeOperation = "source-over";
+    context.drawImage(oriImg, 0, 0, oriImg.width, oriImg.height);
+    context.globalCompositeOperation = "color";
+    context.fillStyle = newColor;
+    context.fillRect(0, 0, oriImg.width, oriImg.height);
+    context.globalCompositeOperation = "destination-in";
+    context.drawImage(oriImg, 0, 0, oriImg.width, oriImg.height);
+    context.restore();
+  }
+  function splitSpriteSheet(img, elementsX, elementsY) {
+    if (img.width % elementsX !== 0 || img.height % elementsY !== 0) {
+      throw new Error(
+        `SpriteSheet doesn't divide evenly: ${img.width}x${img.height} / ${elementsX}x${elementsY}`
+      );
+    }
+    const sizeX = img.width / elementsX;
+    const sizeY = img.height / elementsY;
+    const sprites = [];
+    Array.from({ length: elementsY }).forEach((_, row) => {
+      Array.from({ length: elementsX }).forEach((_2, col) => {
+        sprites.push(img.subImage(col * sizeX, row * sizeY, sizeX, sizeY));
+      });
+    });
+    return sprites;
+  }
+  function getUsedColors(image, pixelAmount = 1, removeLowerThan = 0, removeHigherThan = 0) {
+    const data = image.getContext("2d").getImageData(0, 0, image.width, image.height).data;
+    const counts = /* @__PURE__ */ new Map();
+    for (let i = 0; i < data.length; i += 4) {
+      const key = rgb2Int(data[i], data[i + 1], data[i + 2]);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    if (pixelAmount < 1 || removeLowerThan > 0 || removeHigherThan > 0) {
+      counts.forEach((value, key) => {
+        const newAmount = value * pixelAmount | 0;
+        if (newAmount === 0 || removeLowerThan > 0 && newAmount < removeLowerThan || removeHigherThan > 0 && newAmount > removeHigherThan) {
+          counts.delete(key);
+        } else {
+          counts.set(key, newAmount);
+        }
+      });
+    }
+    const result = /* @__PURE__ */ new Map();
+    counts.forEach((count, rgbInt) => {
+      result.set("#" + (16777216 + rgbInt).toString(16).slice(1), count);
+    });
+    return result;
+  }
+
+  // src/content/Animator.ts
+  var _Animator = class _Animator {
+    /**
+     * We store rendered images in a cache.
+     * So if you have the same entity multiple times, the images get computed once and then shared.
+     * This reduces overhead and frees time up for other important computations.
+     *
+     * `namespace` is the cache key prefix for these rendered images.
+     * So pass a different key for different Animators; otherwise, you will see wrong images.
+     */
+    constructor(entity, namespace) {
+      __publicField(this, "active", true);
+      __publicField(this, "image");
+      __publicField(this, "imageId", 0);
+      __publicField(this, "lookLeft", false);
+      __publicField(this, "onEnd");
+      __publicField(this, "size", new Vec2());
+      __publicField(this, "animations", []);
+      __publicField(this, "currentAnimation", 0);
+      __publicField(this, "entity");
+      __publicField(this, "lastPlayed");
+      __publicField(this, "namespace");
+      __publicField(this, "onFrame");
+      __publicField(this, "playVersion", 0);
+      __publicField(this, "timer", 0);
+      this.entity = entity;
+      this.namespace = namespace;
+    }
+    /**
+     * Drop cached rendered sprites. Pass a namespace to evict only that prefix; omit to clear all.
+     */
+    static clearSpriteCache(namespace) {
+      if (namespace === void 0) {
+        _Animator.spriteCache.clear();
+        return;
+      }
+      const prefix = `${namespace}.`;
+      _Animator.spriteCache.forEach((_, key) => {
+        if (key.startsWith(prefix)) {
+          _Animator.spriteCache.delete(key);
+        }
+      });
+    }
+    get current() {
+      return this.animations[this.currentAnimation];
+    }
+    draw(context, offset = new Vec2()) {
+      context.drawImage(
+        this.image,
+        this.entity.pos.x + offset.x - this.size.x,
+        this.entity.pos.y + offset.y
+      );
+    }
+    update(dt) {
+      if (!this.active) {
+        return;
+      }
+      this.timer += dt;
+      if (this.timer <= this.current.timing) {
+        return;
+      }
+      this.timer -= this.current.timing;
+      this.imageId++;
+      if (this.imageId >= this.current.sprites.length) {
+        const onEnd = this.onEnd;
+        this.onEnd = void 0;
+        this.onFrame = void 0;
+        this.imageId = 0;
+        const versionBefore = this.playVersion;
+        onEnd?.();
+        if (this.playVersion !== versionBefore) {
+          return;
+        }
+        if (this.lastPlayed) {
+          this.play(this.lastPlayed);
+          this.lastPlayed = void 0;
+          return;
+        }
+        if (this.current.sprites.length === 1) {
+          this.active = false;
+          return;
+        }
+      }
+      if (this.onFrame?.[this.imageId]) {
+        const cb = this.onFrame[this.imageId];
+        delete this.onFrame[this.imageId];
+        const versionBefore = this.playVersion;
+        cb();
+        if (this.playVersion !== versionBefore) {
+          return;
+        }
+      }
+      if (this.active) {
+        this.setImage();
+      }
+    }
+    add(name, sprites, timing, defaultAnim = false) {
+      if (defaultAnim && this.animations.some((anim) => anim.default)) {
+        console.error("Only one default animation allowed!");
+      }
+      if (this.animations.some((anim) => anim.name === name)) {
+        console.error("Duplicate animation name!");
+      }
+      this.animations.push({
+        default: defaultAnim,
+        name,
+        sprites,
+        timing
+      });
+      if (defaultAnim) {
+        this.play(name);
+      }
+    }
+    addAnimation(anim, defaultAnim = false) {
+      this.add(
+        anim.name,
+        anim.sprites,
+        anim.timing,
+        anim.default || defaultAnim
+      );
+    }
+    drawRotated(context, angle, offset = new Vec2()) {
+      const x = this.entity.pos.x + offset.x;
+      const y = this.entity.pos.y + offset.y;
+      const w = this.image.width * 0.75;
+      const h = this.image.height * 0.5;
+      context.setTransform(1, 0, 0, 1, x + w - this.size.x, y + h);
+      context.rotate(angle);
+      context.drawImage(this.image, -w, -h);
+      context.setTransform(1, 0, 0, 1, 0, 0);
+    }
+    play(name, onEnd, onFrame) {
+      const index = this.animations.findIndex(
+        (anim) => anim.name === name
+      );
+      if (index < 0) {
+        throw new Error(`Animator.play: animation "${name}" not found`);
+      }
+      this.playVersion++;
+      const myVersion = this.playVersion;
+      this.imageId = 0;
+      this.timer = 0;
+      this.currentAnimation = index;
+      this.setImage();
+      const prevOnEnd = this.onEnd;
+      this.onEnd = onEnd;
+      this.onFrame = onFrame;
+      prevOnEnd?.();
+      if (this.playVersion !== myVersion) {
+        return;
+      }
+      this.active = true;
+    }
+    playIfNot(name, onEnd, onFrame) {
+      if (!this.isPlaying(name)) {
+        this.play(name, onEnd, onFrame);
+        return true;
+      }
+      return false;
+    }
+    playNextOnce(name) {
+      this.lastPlayed = name;
+    }
+    /**
+     * Play `name` once, then return to the previously-playing animation. Calling with the currently-playing name re-loops it indefinitely (lastPlayed restores to itself).
+     */
+    playOnce(name, onEnd, onFrame) {
+      this.lastPlayed = this.current?.name;
+      this.play(name, onEnd, onFrame);
+    }
+    randomTimer() {
+      this.timer = randomBetweenFloat(0, this.current.timing);
+    }
+    removeAllAnimations() {
+      this.animations.length = 0;
+      this.active = true;
+      this.onEnd = void 0;
+      this.onFrame = void 0;
+      _Animator.clearSpriteCache(this.namespace);
+    }
+    reset() {
+      const defaultAnim = this.animations.find(
+        (anim) => anim.default
+      );
+      if (defaultAnim) {
+        this.play(defaultAnim.name);
+        this.active = true;
+      } else {
+        this.active = false;
+      }
+    }
+    isPlaying(name) {
+      return this.current && this.current.name === name;
+    }
+    /**
+     * Update `image` and `size` from the current sprite. Assumes uniform sprite size within an animation. Caches rendered canvases per (animation, frame, lookLeft) — if you mutate `entity.flipX` after first render, call `removeAllAnimations()` or recreate the Animator to invalidate.
+     */
+    setImage() {
+      const animation = this.current;
+      const sprite = animation.sprites[this.imageId];
+      this.size.set(sprite.width, sprite.height);
+      if (this.entity.flipX === void 0) {
+        this.entity.flipX = this.size.x;
+      }
+      const key = `${this.namespace}.${animation.name}`;
+      let cache = _Animator.spriteCache.get(key);
+      if (!cache) {
+        cache = { unflipped: [], flipped: [] };
+        _Animator.spriteCache.set(key, cache);
+      }
+      const bucket = this.lookLeft ? cache.flipped : cache.unflipped;
+      if (!bucket[this.imageId]) {
+        const cc = createNewCanvas(this.size.x * 2, this.size.y);
+        cc.context.translate(
+          this.size.x + (this.lookLeft ? this.entity.flipX : 0),
+          0
+        );
+        if (this.lookLeft) {
+          cc.context.scale(-1, 1);
+        }
+        cc.context.drawImage(sprite, 0, 0);
+        bucket[this.imageId] = cc.canvas;
+      }
+      this.image = bucket[this.imageId];
+    }
+  };
+  __publicField(_Animator, "spriteCache", /* @__PURE__ */ new Map());
+  var Animator = _Animator;
+
+  // src/content/Particle.ts
+  var Particle = class {
+    constructor(pos, color, size = 2) {
+      __publicField(this, "color");
+      __publicField(this, "lifetime", 0);
+      __publicField(this, "maxLifeTime");
+      __publicField(this, "pos");
+      __publicField(this, "size");
+      __publicField(this, "vel");
+      __publicField(this, "_rect");
+      this.pos = pos.clone();
+      this.color = color;
+      this.size = size;
+      this._rect = pos.toRectAddSize(size);
+      this.vel = Vec2.fromAngle(
+        random2Pi(),
+        randomBetweenInt(50, 150),
+        randomBetweenInt(50, 150)
+      );
+      this.maxLifeTime = 0.5 + Math.random();
+    }
+    get alive() {
+      return this.lifetime < this.maxLifeTime;
+    }
+    get rect() {
+      return this._rect;
+    }
+    draw(context, offset = new Vec2()) {
+      context.fillStyle = this.color;
+      context.drawCircle(
+        {
+          x: this.pos.x + offset.x,
+          y: this.pos.y + offset.y
+        },
+        this.size,
+        "fill"
+      );
+    }
+    update(dt) {
+      this.lifetime += dt;
+      this.pos.x += this.vel.x * dt;
+      this.pos.y += this.vel.y * dt;
+      this._rect.set(this.pos.x, this.pos.y);
+    }
+    resetLifetime() {
+      this.lifetime -= this.maxLifeTime;
+    }
+  };
+
+  // src/content/Projectile.ts
+  var Projectile = class {
+    constructor(pos, image, vel = new Vec2()) {
+      __publicField(this, "maxLifetime", Infinity);
+      __publicField(this, "payload");
+      __publicField(this, "speed", 1200);
+      __publicField(this, "image");
+      __publicField(this, "lifetime", 0);
+      __publicField(this, "pos");
+      __publicField(this, "rotation", 0);
+      __publicField(this, "vel");
+      __publicField(this, "_rect");
+      __publicField(this, "originalImage");
+      this.pos = pos.clone();
+      this.originalImage = image;
+      this.vel = vel.clone();
+      this._rect = pos.toRectAddSize(image.width, image.height);
+      this.rebuildRotation();
+    }
+    get alive() {
+      return this.lifetime < this.maxLifetime;
+    }
+    get rect() {
+      return this._rect;
+    }
+    draw(context, offset = new Vec2()) {
+      context.drawImage(
+        this.image,
+        this.pos.x + offset.x,
+        this.pos.y + offset.y
+      );
+    }
+    update(dt) {
+      this.lifetime += dt;
+      this.pos.x += this.vel.x * this.speed * dt;
+      this.pos.y += this.vel.y * this.speed * dt;
+      this._rect.set(this.pos.x, this.pos.y);
+    }
+    /**
+     * Allocates a fresh rotated canvas on each call — no internal cache.
+     * Caching by quantized rotation could be a feature when projectiles need to re-aim every tick (homing/seeking).
+     */
+    rebuildRotation() {
+      this.rotation = Math.atan2(this.vel.y, this.vel.x);
+      this.image = this.originalImage.rotateBy(this.rotation);
+      this._rect.w = this.image.width;
+      this._rect.h = this.image.height;
+    }
+    remove() {
+      this.lifetime = this.maxLifetime * 2;
+    }
+  };
+
+  // src/core/CanvasManager.ts
+  var CANVAS_TYPES = {
+    ANY: /* @__PURE__ */ Symbol("any"),
+    DEFAULT: /* @__PURE__ */ Symbol("default"),
+    BACKGROUND: /* @__PURE__ */ Symbol("background"),
+    MAIN: /* @__PURE__ */ Symbol("main")
+  };
+  var CanvasManager = class {
+    constructor() {
+      __publicField(this, "canvasBoundingClientRect");
+      __publicField(this, "canvasHolder", {});
+      __publicField(this, "ratio", 1);
+      __publicField(this, "resizedSize", new Vec2());
+      __publicField(this, "mainHolder");
+    }
+    get canvas() {
+      return this.mainHolder.canvas;
+    }
+    get canvasContext() {
+      return this.mainHolder.context;
+    }
+    get height() {
+      return this.canvas.height;
+    }
+    set height(height) {
+      this.canvas.height = height;
+    }
+    get size() {
+      return new Vec2(this.width, this.height);
+    }
+    get width() {
+      return this.canvas.width;
+    }
+    set width(width) {
+      this.canvas.width = width;
+    }
+    finishSetup() {
+      if (this.mainHolder) {
+        throw new Error("Already set up.");
+      }
+      const mainCanvas = Object.values(this.canvasHolder).filter(
+        (holder) => holder.type === CANVAS_TYPES.MAIN
+      );
+      if (mainCanvas.length === 0) {
+        throw new Error("No main canvas defined!");
+      }
+      if (mainCanvas.length > 1) {
+        throw new Error("Multiple main canvas defined!");
+      }
+      this.mainHolder = mainCanvas[0];
+      if (this.width === 0 || this.height === 0) {
+        throw new Error("Main canvas has zero width or height.");
+      }
+      this.canvasBoundingClientRect = this.canvas.getBoundingClientRect();
+      if (Settings.enableResize) {
+        EventSystem.addEventListener("resized", () => this.resize());
+      }
+    }
+    resize() {
+      const windowRatio = window.innerHeight / window.innerWidth;
+      Object.values(this.canvasHolder).forEach((ch) => {
+        if (!ch.resize) {
+          return;
+        }
+        const canvasRatio = ch.canvas.height / ch.canvas.width;
+        let width;
+        let height;
+        if (windowRatio < canvasRatio) {
+          height = window.innerHeight;
+          width = height / canvasRatio;
+        } else {
+          width = window.innerWidth;
+          height = width * canvasRatio;
+        }
+        if (ch.canvas === this.canvas) {
+          this.resizedSize = new Vec2(width, height);
+          this.ratio = width / this.width;
+        }
+        ch.canvas.style.width = width + "px";
+        ch.canvas.style.height = height + "px";
+      });
+      this.canvasBoundingClientRect = this.canvas.getBoundingClientRect();
+    }
+    setFontSize(size, font = Settings.font) {
+      this.canvasContext.font = `${size}px "${font}"`;
+    }
+    setupCanvas(canvasType, selector, resize = true) {
+      if (!document.querySelector(selector)) {
+        throw new Error("Canvas '" + selector + "' does not exist!");
+      }
+      if (this.canvasHolder[selector]) {
+        throw new Error(`Canvas "${selector}" was already registered!`);
+      }
+      const newCanvas = Object.assign(
+        {},
+        getCanvasConstruct(selector),
+        {
+          id: selector,
+          resize,
+          type: canvasType
+        }
+      );
+      newCanvas.context.fillStyle = "white";
+      newCanvas.context.strokeStyle = "white";
+      newCanvas.context.font = "12px Arial";
+      this.canvasHolder[selector] = newCanvas;
+      return newCanvas;
+    }
+  };
+
+  // src/core/Gameloop.ts
+  var MAX_DT_SECONDS = 0.25;
+  var MAX_STEPS_PER_FRAME = 5;
+  var Gameloop = class {
+    constructor(game) {
+      __publicField(this, "levelTime", 0);
+      __publicField(this, "_isLooping", false);
+      __publicField(this, "accumulator", 0);
+      __publicField(this, "game");
+      __publicField(this, "stop", false);
+      this.game = game;
+    }
+    get isLooping() {
+      return this._isLooping;
+    }
+    startLoop() {
+      if (this._isLooping && this.stop) {
+        throw new Error(
+          'Gameloop teardown is pending; wait for the "gameloopStopped" event before restarting.'
+        );
+      }
+      this.stop = false;
+      this.looper();
+    }
+    stopLoop() {
+      this.stop = true;
+    }
+    draw(context) {
+      if (!Settings.doNotClear) {
+        if (Settings.useClearRect) {
+          context.clearRect(
+            0,
+            0,
+            this.game.canman.canvas.width,
+            this.game.canman.canvas.height
+          );
+        } else {
+          context.fillStyle = Settings.backgroundColor;
+          context.fillRect(
+            0,
+            0,
+            this.game.canman.canvas.width,
+            this.game.canman.canvas.height
+          );
+        }
+      }
+      this.game.draw(context);
+    }
+    looper() {
+      if (this._isLooping) {
+        return;
+      }
+      this._isLooping = true;
+      const context = this.game.canman.canvasContext;
+      const stopLoop = rafLoop((dt) => {
+        if (this.stop) {
+          this._isLooping = false;
+          EventSystem.dispatchEvent("gameloopStopped");
+          console.log("Simulation stopped.");
+          stopLoop();
+          return;
+        }
+        if (dt > MAX_DT_SECONDS) {
+          this.accumulator = 0;
+        } else {
+          this.accumulator += dt;
+        }
+        let steps = MAX_STEPS_PER_FRAME;
+        while (steps-- > 0 && this.accumulator >= Settings.fps) {
+          this.game.update(Settings.fps);
+          this.accumulator -= Settings.fps;
+          this.levelTime += Settings.fps * 1e3;
+        }
+        this.draw(context);
+      });
+      console.log("Simulation started.");
+    }
+  };
+
+  // src/input/Keyboard.ts
+  var KEYBOARD_KEYS = {
+    KEY_0: "Digit0",
+    KEY_1: "Digit1",
+    KEY_2: "Digit2",
+    KEY_3: "Digit3",
+    KEY_4: "Digit4",
+    KEY_5: "Digit5",
+    KEY_6: "Digit6",
+    KEY_7: "Digit7",
+    KEY_8: "Digit8",
+    KEY_9: "Digit9",
+    KEY_A: "KeyA",
+    KEY_B: "KeyB",
+    KEY_C: "KeyC",
+    KEY_D: "KeyD",
+    KEY_DOWN: "ArrowDown",
+    KEY_E: "KeyE",
+    KEY_ENTER: "Enter",
+    KEY_ESCAPE: "Escape",
+    KEY_F: "KeyF",
+    KEY_G: "KeyG",
+    KEY_H: "KeyH",
+    KEY_I: "KeyI",
+    KEY_J: "KeyJ",
+    KEY_K: "KeyK",
+    KEY_L: "KeyL",
+    KEY_LEFT: "ArrowLeft",
+    KEY_M: "KeyM",
+    KEY_N: "KeyN",
+    KEY_O: "KeyO",
+    KEY_P: "KeyP",
+    KEY_Q: "KeyQ",
+    KEY_R: "KeyR",
+    KEY_RIGHT: "ArrowRight",
+    KEY_S: "KeyS",
+    KEY_SPACE: "Space",
+    KEY_T: "KeyT",
+    KEY_TAB: "Tab",
+    KEY_U: "KeyU",
+    KEY_UP: "ArrowUp",
+    KEY_V: "KeyV",
+    KEY_W: "KeyW",
+    KEY_X: "KeyX",
+    KEY_Y: "KeyY",
+    KEY_Z: "KeyZ"
+  };
+  var Keyboard = class {
+    constructor(game) {
+      __publicField(this, "keys", {});
+      const keyEvent = (event) => {
+        const code = event.code;
+        const pressed = event.type === "keydown";
+        this.keys[code] = pressed;
+        if (Settings.debug && code === KEYBOARD_KEYS.KEY_ESCAPE && pressed) {
+          game.gameloop.stopLoop();
+        }
+        EventSystem.dispatchEvent(
+          "inputKeyboard",
+          this.keys,
+          code,
+          pressed
+        );
+      };
+      window.addEventListener("keydown", keyEvent, false);
+      window.addEventListener("keyup", keyEvent, false);
+      window.addEventListener("blur", () => this.reset(), false);
+      EventSystem.addEventListener("gameloopStopped", () => this.reset());
+    }
+    reset() {
+      for (const key in this.keys) {
+        this.keys[key] = false;
+      }
+    }
+    stopPress(code) {
+      this.keys[code] = false;
+    }
+    isPressed(code) {
+      return !!this.keys[code];
+    }
+  };
+
+  // src/input/Pointer.ts
+  var POINTER_KEYS = {
+    LEFT: 0,
+    MIDDLE: 1,
+    RIGHT: 2,
+    PREV: 3,
+    FORWARD: 4
+  };
+  var Pointer = class {
+    constructor(game) {
+      __publicField(this, "hasMoved", false);
+      __publicField(this, "lastEvent", null);
+      __publicField(this, "posReal", new Vec2());
+      __publicField(this, "posRealLast", new Vec2());
+      __publicField(this, "posScaled", new Vec2());
+      __publicField(this, "posScaledLast", new Vec2());
+      __publicField(this, "pressed", []);
+      __publicField(this, "game");
+      this.game = game;
+      const pointerMoveEvent = (event) => {
+        if (event.target === this.game.canman.canvas) {
+          event.preventDefault();
+        }
+        this.lastEvent = event;
+        this.hasMoved = true;
+        this.update(event);
+        EventSystem.dispatchEvent("inputPointer", this);
+      };
+      const pointerStateChangeEvent = (event) => {
+        if (event.target === this.game.canman.canvas) {
+          event.preventDefault();
+        }
+        this.lastEvent = event;
+        this.pressed[event.button] = event.type === "pointerdown";
+        EventSystem.dispatchEvent("inputPointer", this);
+      };
+      window.addEventListener("pointermove", pointerMoveEvent, false);
+      window.addEventListener("pointerdown", pointerStateChangeEvent, false);
+      window.addEventListener("pointerup", pointerStateChangeEvent, false);
+      window.addEventListener("blur", () => this.reset(), false);
+      document.addEventListener(
+        "contextmenu",
+        (event) => {
+          event.preventDefault();
+        },
+        false
+      );
+    }
+    reset() {
+      this.pressed.length = 0;
+    }
+    update(event) {
+      this.posRealLast.set(this.posReal.x, this.posReal.y);
+      this.posReal.set(event.clientX, event.clientY);
+      this.posScaledLast.set(this.posScaled.x, this.posScaled.y);
+      this.posScaled.set(
+        clamp(
+          (event.clientX - this.game.canman.canvasBoundingClientRect.left) / this.game.canman.canvasBoundingClientRect.width * this.game.canman.width | 0,
+          0,
+          this.game.canman.width
+        ),
+        clamp(
+          (event.clientY - this.game.canman.canvasBoundingClientRect.top) / this.game.canman.canvasBoundingClientRect.height * this.game.canman.height | 0,
+          0,
+          this.game.canman.height
+        )
+      );
+    }
+  };
+
+  // src/localization/Translator.ts
+  defineMethod(window, "t", function() {
+    throw new Error("Call 'prepareLanguage' first!");
+  });
+  var logMissingKey = throttleByKey((count, key) => {
+    const suffix = count > 1 ? ` (x${count} since last log)` : "";
+    console.warn(`"${key}" has no translation${suffix}`);
+  });
+  var logMissingLanguage = throttleByKey(
+    (count, current, fallback) => {
+      const suffix = count > 1 ? ` (x${count} since last log)` : "";
+      console.warn(
+        `Language "${current}" not found, falling back to "${fallback}"${suffix}`
+      );
+    }
+  );
+  function prepareLanguage(languages, defaultLanguage = "en") {
+    if (!languages[defaultLanguage]) {
+      throw new Error(
+        `Default language is defined as "${defaultLanguage}" but isn't supplied!`
+      );
+    }
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const lang in languages) {
+      for (const key in languages[lang]) {
+        allKeys.add(key);
+      }
+    }
+    const sortedKeys = [...allKeys].sort();
+    for (const lang in languages) {
+      sortedKeys.forEach((key) => {
+        if (languages[lang][key] === void 0) {
+          console.error(`"${lang}" misses "${key}"`);
+        }
+      });
+    }
+    defineMethod(window, "t", function(key) {
+      const currentLang = Settings.localStorage.language;
+      let language = languages[currentLang];
+      if (!language) {
+        logMissingLanguage(currentLang, currentLang, defaultLanguage);
+        language = languages[defaultLanguage];
+      }
+      if (language[key] === void 0) {
+        logMissingKey(key, key);
+        return key;
+      }
+      return language[key];
+    });
+  }
+
+  // src/prototypes/Audio.ts
+  defineMethod(
+    HTMLAudioElement.prototype,
+    "clone",
+    function() {
+      const node = this.cloneNode(true);
+      node.volume = this.volume;
+      return node;
+    }
+  );
+  defineMethod(HTMLAudioElement.prototype, "stop", function() {
+    this.pause();
+    this.currentTime = 0;
+    if (this.defaultVolume !== void 0) {
+      this.volume = this.defaultVolume;
+    }
+  });
+
+  // src/prototypes/CanvasRenderingContext2D.ts
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "fillBar",
+    function(rect, amount, c1 = "white", c2 = "black") {
+      this.fillStyle = c1;
+      this.fillRect(rect.x, rect.y, rect.w, rect.h);
+      this.fillStyle = c2;
+      this.fillRect(rect.x, rect.y, rect.w * amount, rect.h);
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "fillFramedBar",
+    function(rect, amount = 0.8, padding = 4, colors = ["white", "black", "red"]) {
+      this.fillStyle = colors[0];
+      this.fillRect(rect.x, rect.y, rect.w, rect.h);
+      this.fillStyle = colors[1];
+      this.fillRect(
+        rect.x + padding,
+        rect.y + padding,
+        rect.w - padding * 2,
+        rect.h - padding * 2
+      );
+      if (amount > 0) {
+        this.fillStyle = colors[2];
+        this.fillRect(
+          rect.x + padding,
+          rect.y + padding,
+          amount * (rect.w - padding * 2),
+          rect.h - padding * 2
+        );
+      }
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "drawCircle",
+    function(vecPos, rad, mode, amount = 1) {
+      this.beginPath();
+      this.arc(vecPos.x, vecPos.y, rad, 0, amount * 2 * Math.PI);
+      this[mode]();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "drawRect",
+    function(...args) {
+      let x;
+      let y;
+      let w;
+      let h;
+      let mode;
+      if (typeof args[0] === "number") {
+        [x, y, w, h, mode] = args;
+      } else {
+        [{ x, y, w, h }, mode] = args;
+      }
+      this.beginPath();
+      this.rect(x, y, w, h);
+      this[mode]();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "drawRoundRect",
+    function(...args) {
+      let x;
+      let y;
+      let w;
+      let h;
+      let mode;
+      let options;
+      if (typeof args[0] === "number") {
+        [x, y, w, h, mode, options] = args;
+      } else {
+        [{ x, y, w, h }, mode, options] = args;
+      }
+      const { padding = 0, radius = 16 } = options ?? {};
+      x += padding;
+      y += padding;
+      w -= padding * 2;
+      h -= padding * 2;
+      this.beginPath();
+      this.roundRect(x, y, w, h, radius);
+      this[mode]();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "strokeDottedRect",
+    function(rect) {
+      this.setLineDash([15, 15]);
+      this.lineWidth = 5;
+      this.beginPath();
+      this.moveTo(rect.x, rect.y);
+      this.lineTo(rect.x + rect.w, rect.y);
+      this.lineTo(rect.x + rect.w, rect.y + rect.h);
+      this.lineTo(rect.x, rect.y + rect.h);
+      this.lineTo(rect.x, rect.y);
+      this.stroke();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "strokeLine",
+    function(x1, y1, x2, y2) {
+      this.beginPath();
+      this.moveTo(x1, y1);
+      this.lineTo(x2, y2);
+      this.stroke();
+      this.closePath();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "drawPolygon",
+    function(sides, rect, mode) {
+      const rad = Math.min(rect.w, rect.h) * 0.5;
+      const Xcenter = rect.x + rect.w * 0.5;
+      const Ycenter = rect.y + rect.h * 0.5;
+      this.beginPath();
+      this.moveTo(Xcenter + rad, Ycenter);
+      for (let i = 1; i <= sides; i++) {
+        this.lineTo(
+          Math.round(Xcenter + rad * Math.cos(i * 2 * Math.PI / sides)),
+          Math.round(Ycenter + rad * Math.sin(i * 2 * Math.PI / sides))
+        );
+      }
+      this.closePath();
+      this[mode]();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "drawTriangle",
+    function(rect, mode) {
+      this.beginPath();
+      this.moveTo(rect.x, rect.y);
+      this.lineTo(rect.x + rect.w, rect.y);
+      this.lineTo(rect.x + rect.w * 0.5, rect.y + rect.h);
+      this[mode]();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "writeText",
+    function(text, x, y, measureTextOffset = 0.5) {
+      this.fillText(
+        text,
+        x - this.measureText(text).width * measureTextOffset,
+        y
+      );
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "writeMultilineText",
+    function(text, x, y, width, lineOffset = 50, maxAttempts = 50) {
+      const words = text.split(" ");
+      let attempts = 0;
+      while (words.length > 0 && attempts < maxAttempts) {
+        let count = words.length;
+        for (let i = 1; i <= words.length; i++) {
+          const textWidth = this.measureText(
+            words.slice(0, i).join(" ")
+          ).width;
+          if (textWidth > width) {
+            count = Math.max(1, i - 1);
+            break;
+          }
+        }
+        this.writeText(words.slice(0, count).join(" "), x, y, 0);
+        words.splice(0, count);
+        y += lineOffset;
+        attempts++;
+      }
+      if (attempts >= maxAttempts) {
+        console.error("maxAttempts reached", attempts);
+      }
+      return attempts < maxAttempts;
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "drawImageRotated",
+    function(image, x, y, radians) {
+      this.save();
+      this.translate(x + image.width * 0.5, y + image.height * 0.5);
+      this.rotate(radians);
+      this.drawImage(image, -image.width * 0.5, -image.height * 0.5);
+      this.restore();
+    }
+  );
+  defineMethod(
+    CanvasRenderingContext2D.prototype,
+    "generateColor",
+    function(size, color) {
+      const cc = createNewCanvas(size, size);
+      cc.context.strokeStyle = color;
+      cc.context.lineWidth = 6;
+      cc.context.drawRoundRect(0, 0, size, size, "stroke", {
+        padding: cc.context.lineWidth,
+        radius: 15
+      });
+      const data = cc.context.getImageData(0, 0, size, size).data;
+      const allColors = [];
+      for (let i = 0; i < data.length; i += 4) {
+        if (data[i + 3]) {
+          allColors.push([i / 4 % size, i / 4 / size | 0]);
+        }
+      }
+      const colors = [];
+      allColors.forEach((c) => {
+        if (c[0] > size * 0.5) {
+          colors.push(c);
+        }
+      });
+      for (let i = allColors.length - 1; i >= 0; i--) {
+        if (allColors[i][0] <= size * 0.5) {
+          colors.push(allColors[i]);
+        }
+      }
+      const drawPartialRoundRect = (rect, amount, offsetX = 0, offsetY = 0) => {
+        this.drawImage(cc.canvas, rect.x + offsetX, rect.y + offsetY);
+        this.fillStyle = "white";
+        for (let i = 0; i < Math.min(amount * colors.length, colors.length); i++) {
+          this.fillRect(
+            rect.x + colors[i][0] + offsetX,
+            rect.y + colors[i][1] + offsetY,
+            1,
+            1
+          );
+        }
+      };
+      return { colors, image: cc.canvas, drawPartialRoundRect };
+    }
+  );
+
+  // src/prototypes/index.ts
+  defineMethod(
+    HTMLImageElement.prototype,
+    "subImage",
+    HTMLCanvasElement.prototype.subImage
+  );
+
+  // src/core/Game.ts
+  var Game = class {
+    constructor(settingOverrides = {}) {
+      __publicField(this, "canman", new CanvasManager());
+      __publicField(this, "gameloop");
+      __publicField(this, "keyboard");
+      __publicField(this, "pointer");
+      __publicField(this, "initialized", false);
+      Settings.init(settingOverrides, this);
+      history.scrollRestoration = "manual";
+      this.gameloop = new Gameloop(this);
+      this.keyboard = new Keyboard(this);
+      this.pointer = new Pointer(this);
+    }
+    draw(_context) {
+      throw new Error("Override draw function!");
+    }
+    update(_dt) {
+      throw new Error("Override update function!");
+    }
+    async init() {
+      throw new Error(
+        "Override init() and start the game via preInit() \u2014 do not call init() directly."
+      );
+    }
+    async preInit(doInit = true) {
+      if (this.initialized) {
+        throw new Error(
+          "preInit() may only be called once per Game instance."
+        );
+      }
+      this.initialized = true;
+      this.canman.finishSetup();
+      window.addEventListener(
+        "resize",
+        debounce(() => EventSystem.dispatchEvent("resized"), 250),
+        false
+      );
+      this.gameloop.levelTime = 0;
+      if (doInit) {
+        await this.init();
+      }
+      EventSystem.dispatchEvent("resized");
+      if (Settings.autoloop) {
+        this.gameloop.startLoop();
+      }
+    }
+  };
+
+  // src/effects/Screenshake.ts
+  var SHAKE_TYPES = {
+    NORMAL: {
+      step: 3,
+      update(updateCss, time) {
+        const tr = `rotate(${randomBetweenFloat(-2, 2) * time}deg)`;
+        updateCss("transform", tr);
+        updateCss("webkitTransform", tr);
+        updateCss("filter", `blur(${time * 5}px)`);
+      }
+    },
+    FAST: {
+      step: 15,
+      update(updateCss, time) {
+        updateCss("filter", `blur(${time * 3}px)`);
+      }
+    }
+  };
+  var Screenshake = class {
+    constructor(element) {
+      __publicField(this, "isShaking", false);
+      __publicField(this, "shakeType", SHAKE_TYPES.NORMAL);
+      __publicField(this, "style");
+      this.style = element.style;
+    }
+    /** Best-effort style restore: each key the shake writes is snapshotted on first write and rewritten when the shake ends or is disposed. */
+    shake(shakeType = SHAKE_TYPES.NORMAL) {
+      if (this.isShaking) {
+        return null;
+      }
+      this.isShaking = true;
+      this.shakeType = shakeType;
+      let timer = 1;
+      const originalValue = /* @__PURE__ */ new Map();
+      const updateCssProxy = (key, value) => {
+        if (!originalValue.has(key)) {
+          originalValue.set(key, this.style[key]);
+        }
+        this.style[key] = value;
+      };
+      const stopLoop = rafLoop((dt) => {
+        this.shakeType.update(updateCssProxy, timer);
+        timer -= this.shakeType.step * dt;
+        if (timer <= 0) {
+          dispose();
+        }
+      });
+      let alive = true;
+      const dispose = () => {
+        if (!alive) {
+          return;
+        }
+        alive = false;
+        stopLoop();
+        originalValue.forEach((value, key) => {
+          this.style[key] = value;
+        });
+        this.isShaking = false;
+      };
+      return dispose;
+    }
+  };
+
+  // src/input/ControllerCursor.ts
+  var SPEED = 600;
+  var CROSSHAIR;
+  (async () => CROSSHAIR = await loadImage(
+    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAAilBMVEUAAAAaGhoZGRkZGRkbGxsZGRkaGhoWFhYgICAZGRkZGRkZGRkZGRkZGRkZGRkYGBgZGRkZGRkbGxsaGhoZGRkZGRkZGRkZGRkZGRkaGhoZGRkZGRkaGhoZGRkZGRkZGRkYGBgZGRkZGRkbGxsZGRkYGBgZGRkYGBgaGhoYGBgYGBgYGBgZGRkaGhqj+rsBAAAALXRSTlMA9fvsBINBCwfhZTnS2sByMcUZE8oe1TUqubeppJOLhlDyeiPOrp57X19dSkdeSFeiAAAELElEQVR42sSY2XaqQBBFD20jozKJI3E2Tun//72bKgmXZBmjLbT7KQ9J2HSdrqoFtMiCw2I2SUKvI0THC5PJbHEIMhjBOc/7HXWVTn9+dtAmbtdOhLqJSOyui3YYvXXUXXTeRmicfN9TNaxtYUf+shtbVtxd+pFdbC1Vo7fPm335Xe3Z0/VyI1FiWSiRm+V6WrPYNXcMwbSq8KCqcCXwMyWDKiXTAE3Q7auSMEpB/C7ApFGoSvpdPEs6q5IVA/hbgImrvM5SPIOMVorxfBe4U4BxfU8xq0hCmyAsM+1L4BEBlvd7ZeV0oyBtoQjvJIEHBRh58hQhbKlV/Uv4xNwBNAQYZy4uYdRIwsclRkkMaAowcXKJ8AceQy4UYfmApkCFbyli8VAZ3EIRwzGeF8B4qIjCxd04E0W8O2hCAM67IiYO7iQb8PEfgQYEmCOXYZDhLvIexyZAcwIIONK9/K735+d7YzQpgLHHBtkdBRtw/HI0K4B8yFVw/sz/pKxWswJVsiYubiILfv8MzQsg4zMoJG6x4PrnaEMAOedgcbP/cv7HaEcAY74LN7pySr9gBWhLAIFFL5j+GgCef0e0J4Ajz8bfYmBz/0WbAuCubOMqgaAL4LQr4NBVEMHVAoQUgDHaFcCYYhBeK0KkPvHRtgB8ek505QbQ/pugfQEktCun+MmMahObEIgpazP8oKs+mcOEAOb0rC6+Qy3Ac8wIOB41A3wjIKkTzAjgRE8LUGdK24I0JSBp55mixuhyBY0IVFdxhP/sKAHSnICkFOxQkeseAAtoH0GOL/Y0JF2TAi4N/j2+oEy8waQA3ij13yIYmxWIOYY1mxBmBRDSqdfqEZkWiDh31RgQqWmBVNBAqDaxAUwLYFDtZgn9ZF7A/to/HD4L8wJceQfAmVZB17yAS8vhuVwPpjAvwBN4Xq4i61cIrMu1hLrA8hUCS+oEQKY+2bxCYENPzhBQBuUrBKTFi9lBKbXFKwSwVUod+JNE8RqBgj9XzKgPGheoeuEMEx6FuoyEGAFPDMQJTwIfeuR9/t6QQw+fp0Go3wbcoWKGrn4jCOHpj6K1WtmWZa/UWn8ceejo74OhiCmEsQj198IOBDUiPZSwLPpjof0PlBL/mrd3GwiBIAiiAgRYCOcMfOzNP70TpNBCr4kAaX8zPVX+B6IluJ4luKIlSDbhOpZzms5lrMEmTI7hfoz3O/bgGEYX0f17s/07uYjCq3ib5y27iv1jxJ9jXpDwkowXpbws940Jb814c8rbcx5Q+IiGh1Q8puNBpY9qeVjt43o+sOAjGz+04mM7P7jko1s/vObjew8wcITDQywc4/Egk0e5OMzmcT4PNHqkk0OtHuv1YLNHuz3c7vF+Lzh4xcNLLgWajxedvOpVILt53a9AeCxQPguk1wLtt0B8blC/C+T3L/T/P3gDDpik2UVvAAAAAElFTkSuQmCC"
+  ))();
+  var ControllerCursor = class {
+    constructor(controller, game, axisId) {
+      __publicField(this, "axisId");
+      __publicField(this, "controller");
+      __publicField(this, "game");
+      __publicField(this, "pos");
+      this.controller = controller;
+      this.game = game;
+      this.axisId = axisId;
+      this.pos = game.canman.size.mult(0.5);
+    }
+    get centerPos() {
+      return this.pos.clone().add(CROSSHAIR.width * 0.5, CROSSHAIR.height * 0.5);
+    }
+    draw(context) {
+      context.drawImage(CROSSHAIR, this.pos.x, this.pos.y);
+    }
+    update(dt) {
+      const step = this.controller.stick(this.axisId).mult(SPEED * dt);
+      if (step.length() === 0) {
+        return;
+      }
+      this.pos.x = clamp(
+        this.pos.x + step.x,
+        0,
+        this.game.canman.width - CROSSHAIR.width
+      );
+      this.pos.y = clamp(
+        this.pos.y + step.y,
+        0,
+        this.game.canman.height - CROSSHAIR.height
+      );
+    }
+  };
+
+  // src/input/Controller.ts
+  var CONTROLLER_KEYS = {
+    A: 0,
+    B: 1,
+    X: 2,
+    Y: 3,
+    LB: 4,
+    RB: 5,
+    LT: 6,
+    RT: 7,
+    SELECT: 8,
+    START: 9,
+    LEFT_STICK: 10,
+    RIGHT_STICK: 11,
+    UP: 12,
+    DOWN: 13,
+    LEFT: 14,
+    RIGHT: 15,
+    GUIDE: 16
+  };
+  var AXIS_THRESHOLD = 0.3;
+  var Controller = class {
+    constructor(game) {
+      __publicField(this, "buttons", []);
+      __publicField(this, "cursors", []);
+      __publicField(this, "axes", []);
+      __publicField(this, "index", -1);
+      __publicField(this, "lastTime", 0);
+      if (!("getGamepads" in navigator)) {
+        console.error("Controller not supported!");
+        return;
+      }
+      for (let i = 0; i < 2; i++) {
+        this.cursors.push(new ControllerCursor(this, game, i));
+      }
+      window.addEventListener("gamepadconnected", (event) => {
+        this.index = event.gamepad.index;
+        console.log("Gamepad connected:", event.gamepad.id);
+        EventSystem.dispatchEvent(
+          "inputControllerConnected",
+          event.gamepad
+        );
+        this.vibrate();
+      });
+      window.addEventListener(
+        "gamepaddisconnected",
+        (event) => {
+          if (this.index === event.gamepad.index) {
+            this.index = -1;
+            console.log(
+              "Our Gamepad was disconnected:",
+              event.gamepad.index
+            );
+            EventSystem.dispatchEvent("inputControllerDisconnected");
+          } else {
+            console.log(
+              "Different Gamepad was disconnected:",
+              event.gamepad.index
+            );
+          }
+        }
+      );
+      window.addEventListener("blur", () => this.reset(), false);
+    }
+    draw(context) {
+      if (this.index < 0) {
+        return;
+      }
+      this.cursors.forEach((cursor) => cursor.draw(context));
+    }
+    update(dt) {
+      this.cursors.forEach((cursor) => cursor.update(dt));
+      const gp = this.getGamepad();
+      if (!gp || this.lastTime === gp.timestamp) {
+        return;
+      }
+      this.lastTime = gp.timestamp;
+      this.buttons = gp.buttons.map(
+        (button) => button.pressed
+      );
+      this.axes.length = 0;
+      const axes = gp.axes;
+      for (let i = 0; i + 1 < axes.length; i += 2) {
+        this.axes.push(new Vec2(axes[i], axes[i + 1]));
+      }
+    }
+    reset() {
+      this.buttons.length = 0;
+      this.axes.length = 0;
+    }
+    vibrate() {
+      const gp = this.getGamepad();
+      if (!gp) {
+        return false;
+      }
+      const vibrator = gp.vibrationActuator;
+      if (vibrator) {
+        vibrator.playEffect("dual-rumble", {
+          duration: 400,
+          weakMagnitude: 1,
+          startDelay: 0,
+          strongMagnitude: 1
+        });
+      }
+      return !!vibrator;
+    }
+    stick(index) {
+      if (this.index < 0 || index >= this.axes.length) {
+        return new Vec2();
+      }
+      return this.axes[index].clone().map((value) => threshold(value, AXIS_THRESHOLD)).map(
+        (value) => Math.sign(value) * map(Math.abs(value), AXIS_THRESHOLD, 1, 0, 1)
+      );
+    }
+    getGamepad() {
+      return this.index < 0 ? null : navigator.getGamepads()[this.index] ?? null;
+    }
+  };
+
+  // src/math/Polygon.ts
+  var warnZeroEdge = throttle((count) => {
+    console.warn(
+      `Polygon.collide: found a zero-edge polygon \u2014 no collision possible. (called x${count} since last trace)`
+    );
+  });
+  function pointDirection(xfrom, yfrom, xto, yto) {
+    return Math.atan2(yto - yfrom, xto - xfrom);
+  }
+  function intervalDistance(minA, maxA, minB, maxB) {
+    return minA < minB ? minB - maxA : minA - maxB;
+  }
+  function projectPolygon(axis, polygon, bounds) {
+    let dotProduct = axis.dotProduct(polygon.points[0]);
+    bounds.x = dotProduct;
+    bounds.y = dotProduct;
+    for (let i = 1; i < polygon.points.length; i++) {
+      dotProduct = polygon.points[i].dotProduct(axis);
+      if (dotProduct < bounds.x) {
+        bounds.x = dotProduct;
+      } else if (dotProduct > bounds.y) {
+        bounds.y = dotProduct;
+      }
+    }
+  }
+  var Polygon = class _Polygon {
+    constructor(...points) {
+      __publicField(this, "_center", new Vec2());
+      __publicField(this, "_points", []);
+      __publicField(this, "edges", []);
+      this.addPoints(...points);
+    }
+    /**
+     * `angle` is the simplification threshold in radians: vertices whose turn
+     * angle wraps to within ±`angle` of straight are dropped.
+     */
+    static fromCanvas(canvas, detail, angle) {
+      detail = Math.max(2, detail);
+      const w = canvas.width;
+      const h = canvas.height;
+      const data = canvas.getContext("2d").getImageData(0, 0, w, h).data;
+      const vertexX = [0];
+      const vertexY = [0];
+      const vertexK = [1];
+      let numPoints = 0;
+      let fy = -1;
+      let lx = 0;
+      let ly = 0;
+      for (let tx = 0; tx < w; tx += detail) {
+        for (let ty = 0; ty < h; ty += 1) {
+          if (data[(ty * w + tx) * 4 + 3] !== 0) {
+            vertexX[numPoints] = tx;
+            vertexY[numPoints] = ty;
+            vertexK[numPoints] = 1;
+            numPoints++;
+            if (fy < 0) {
+              fy = ty;
+            }
+            lx = tx;
+            ly = ty;
+            break;
+          }
+        }
+      }
+      for (let ty = 0; ty < h; ty += detail) {
+        for (let tx = w - 1; tx >= 0; tx -= 1) {
+          if (data[(ty * w + tx) * 4 + 3] !== 0 && ty > ly) {
+            vertexX[numPoints] = tx;
+            vertexY[numPoints] = ty;
+            vertexK[numPoints] = 1;
+            numPoints++;
+            lx = tx;
+            ly = ty;
+            break;
+          }
+        }
+      }
+      for (let tx = w - 1; tx >= 0; tx -= detail) {
+        for (let ty = h - 1; ty >= 0; ty -= 1) {
+          if (data[(ty * w + tx) * 4 + 3] !== 0 && tx < lx) {
+            vertexX[numPoints] = tx;
+            vertexY[numPoints] = ty;
+            vertexK[numPoints] = 1;
+            numPoints++;
+            lx = tx;
+            ly = ty;
+            break;
+          }
+        }
+      }
+      for (let ty = h - 1; ty >= 0; ty -= detail) {
+        for (let tx = 0; tx < w; tx += 1) {
+          if (data[(ty * w + tx) * 4 + 3] !== 0 && ty < ly && ty > fy) {
+            vertexX[numPoints] = tx;
+            vertexY[numPoints] = ty;
+            vertexK[numPoints] = 1;
+            numPoints++;
+            lx = tx;
+            ly = ty;
+            break;
+          }
+        }
+      }
+      if (numPoints < 3) {
+        throw new Error(
+          `Polygon.fromCanvas: scan produced "${numPoints}" vertices (need >=3). Canvas may be empty or detail (${detail}) too large.`
+        );
+      }
+      for (let i = 0; i < numPoints; i++) {
+        const a = i;
+        const b = (i + 1) % numPoints;
+        const c = (i + 2) % numPoints;
+        const ang1 = pointDirection(
+          vertexX[a],
+          vertexY[a],
+          vertexX[b],
+          vertexY[b]
+        );
+        const ang2 = pointDirection(
+          vertexX[b],
+          vertexY[b],
+          vertexX[c],
+          vertexY[c]
+        );
+        if (Math.abs(wrapRadians(ang1 - ang2)) <= angle) {
+          vertexK[b] = 0;
+        }
+      }
+      const points = [];
+      for (let i = 0; i < numPoints; i++) {
+        if (vertexK[i] === 1) {
+          points.push(new Vec2(vertexX[i], vertexY[i]));
+        }
+      }
+      return new _Polygon(...points);
+    }
+    static fromEdges(edges, size) {
+      const s = size instanceof Vec2 ? size : new Vec2(size, size);
+      const rad = Math.min(s.x, s.y) * 0.5;
+      const Xcenter = s.x * 0.5;
+      const Ycenter = s.y * 0.5;
+      const points = [];
+      for (let i = 1; i <= edges; i++) {
+        points.push(
+          new Vec2(
+            Math.round(
+              Xcenter + rad * Math.cos(i * 2 * Math.PI / edges)
+            ),
+            Math.round(
+              Ycenter + rad * Math.sin(i * 2 * Math.PI / edges)
+            )
+          )
+        );
+      }
+      return new _Polygon(...points);
+    }
+    static fromRect(rect) {
+      return new _Polygon(
+        new Vec2(rect.x, rect.y),
+        new Vec2(rect.x + rect.w, rect.y),
+        new Vec2(rect.x + rect.w, rect.y + rect.h),
+        new Vec2(rect.x, rect.y + rect.h)
+      );
+    }
+    get center() {
+      return this._center;
+    }
+    get points() {
+      return this._points;
+    }
+    draw(context, offset = new Vec2()) {
+      if (this._points.length === 0) {
+        return;
+      }
+      context.beginPath();
+      context.moveTo(
+        offset.x + this._points[0].x | 0,
+        offset.y + this._points[0].y | 0
+      );
+      for (let i = 1; i < this._points.length; i++) {
+        context.lineTo(
+          offset.x + this._points[i].x | 0,
+          offset.y + this._points[i].y | 0
+        );
+      }
+      context.closePath();
+      context.stroke();
+    }
+    addPoint(x, y) {
+      this._points.push(new Vec2(x, y));
+      this.update();
+      return this;
+    }
+    addPoints(...points) {
+      points.forEach((point) => this._points.push(point.clone()));
+      this.update();
+      return this;
+    }
+    offset(x = 0, y = 0) {
+      this._points.forEach((point) => point.add(x, y));
+      this.update();
+      return this;
+    }
+    rotate(angle, pos = this.center) {
+      if (!angle) {
+        return this;
+      }
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      this._points.forEach((point) => {
+        const dx = point.x - pos.x;
+        const dy = point.y - pos.y;
+        point.set(dx * cos - dy * sin + pos.x, dx * sin + dy * cos + pos.y);
+      });
+      this.update();
+      return this;
+    }
+    collide(otherPolygon, velocity = new Vec2()) {
+      const result = {
+        intersect: true,
+        minimumTranslationVector: new Vec2(),
+        willIntersect: true
+      };
+      const edgeCountA = this.edges.length;
+      const edgeCountB = otherPolygon.edges.length;
+      if (edgeCountA === 0 || edgeCountB === 0) {
+        warnZeroEdge();
+        return {
+          intersect: false,
+          minimumTranslationVector: new Vec2(),
+          willIntersect: false
+        };
+      }
+      let minDistance = Infinity;
+      let translationAxis = new Vec2();
+      let edge;
+      for (let edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++) {
+        if (edgeIndex < edgeCountA) {
+          edge = this.edges[edgeIndex];
+        } else {
+          edge = otherPolygon.edges[edgeIndex - edgeCountA];
+        }
+        const axis = new Vec2(-edge.y, edge.x);
+        axis.normalize();
+        const boundsA = new Vec2();
+        const boundsB = new Vec2();
+        projectPolygon(axis, this, boundsA);
+        projectPolygon(axis, otherPolygon, boundsB);
+        if (intervalDistance(boundsA.x, boundsA.y, boundsB.x, boundsB.y) > 0) {
+          result.intersect = false;
+        }
+        const velocityProjection = axis.dotProduct(velocity);
+        if (velocityProjection < 0) {
+          boundsA.x += velocityProjection;
+        } else {
+          boundsA.y += velocityProjection;
+        }
+        let distance = intervalDistance(
+          boundsA.x,
+          boundsA.y,
+          boundsB.x,
+          boundsB.y
+        );
+        if (distance > 0) {
+          result.willIntersect = false;
+        }
+        if (!result.intersect && !result.willIntersect) {
+          break;
+        }
+        distance = Math.abs(distance);
+        if (distance < minDistance) {
+          minDistance = distance;
+          translationAxis = axis.clone();
+          const d = this.center.clone().sub(otherPolygon.center);
+          if (d.dotProduct(translationAxis) < 0) {
+            translationAxis.negate();
+          }
+        }
+      }
+      if (result.willIntersect) {
+        result.minimumTranslationVector = translationAxis.mult(minDistance);
+      }
+      return result;
+    }
+    clone() {
+      return new _Polygon(...this._points);
+    }
+    update() {
+      if (this._points.length === 0) {
+        return;
+      }
+      let p1;
+      let p2;
+      this.edges.length = 0;
+      for (let i = 0; i < this._points.length; i++) {
+        p1 = this._points[i];
+        if (i + 1 >= this._points.length) {
+          p2 = this._points[0];
+        } else {
+          p2 = this._points[i + 1];
+        }
+        this.edges.push(p2.clone().sub(p1));
+      }
+      let totalX = 0;
+      let totalY = 0;
+      this.points.forEach((point) => {
+        totalX += point.x;
+        totalY += point.y;
+      });
+      this.center.set(
+        totalX / this._points.length,
+        totalY / this._points.length
+      );
+    }
+  };
+
+  // src/utilities/Json.ts
+  function deepClone(obj) {
+    return cloneInternal(obj, /* @__PURE__ */ new WeakMap());
+  }
+  function cloneInternal(obj, hash) {
+    if (Object(obj) !== obj || obj instanceof Function) {
+      return obj;
+    }
+    const o = obj;
+    if (hash.has(o)) {
+      return hash.get(o);
+    }
+    if (obj instanceof Date) {
+      const cloned = new Date(obj.getTime());
+      hash.set(o, cloned);
+      return cloned;
+    }
+    if (obj instanceof RegExp) {
+      const cloned = new RegExp(obj.source, obj.flags);
+      cloned.lastIndex = obj.lastIndex;
+      hash.set(o, cloned);
+      return cloned;
+    }
+    if (obj instanceof Map) {
+      const cloned = /* @__PURE__ */ new Map();
+      hash.set(o, cloned);
+      obj.forEach((v, k) => {
+        cloned.set(cloneInternal(k, hash), cloneInternal(v, hash));
+      });
+      return cloned;
+    }
+    if (obj instanceof Set) {
+      const cloned = /* @__PURE__ */ new Set();
+      hash.set(o, cloned);
+      obj.forEach((v) => {
+        cloned.add(cloneInternal(v, hash));
+      });
+      return cloned;
+    }
+    if (Array.isArray(obj)) {
+      const cloned = [];
+      hash.set(o, cloned);
+      obj.forEach((item, i) => {
+        cloned[i] = cloneInternal(item, hash);
+      });
+      return cloned;
+    }
+    if (obj instanceof ArrayBuffer) {
+      const cloned = obj.slice(0);
+      hash.set(o, cloned);
+      return cloned;
+    }
+    if (obj instanceof DataView) {
+      const buf = obj.buffer.slice(
+        obj.byteOffset,
+        obj.byteOffset + obj.byteLength
+      );
+      const cloned = new DataView(buf);
+      hash.set(o, cloned);
+      return cloned;
+    }
+    if (ArrayBuffer.isView(obj)) {
+      const cloned = obj.slice();
+      hash.set(o, cloned);
+      return cloned;
+    }
+    const result = Object.create(Object.getPrototypeOf(o));
+    hash.set(o, result);
+    Reflect.ownKeys(o).forEach((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(o, key);
+      if ("value" in descriptor) {
+        descriptor.value = cloneInternal(descriptor.value, hash);
+        Object.defineProperty(result, key, descriptor);
+        return;
+      }
+      const snapshot = cloneInternal(
+        o[key],
+        hash
+      );
+      Object.defineProperty(result, key, {
+        value: snapshot,
+        writable: true,
+        enumerable: descriptor.enumerable,
+        configurable: descriptor.configurable
+      });
+    });
+    return result;
+  }
+
+  // src/utilities/String.ts
+  function compact(str) {
+    return str.trim().replace(/\s+/g, " ");
+  }
+  function replaceCharAt(str, index, char) {
+    const codePoints = Array.from(str);
+    if (index < 0 || index >= codePoints.length) {
+      throw new Error(
+        `replaceCharAt index out of range: ${index} (length ${codePoints.length})`
+      );
+    }
+    const charPoints = Array.from(char);
+    if (charPoints.length !== 1) {
+      throw new Error(
+        `replaceCharAt requires a single character, got length ${charPoints.length}`
+      );
+    }
+    codePoints[index] = char;
+    return codePoints.join("");
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=gleam.js.map