canvasengine 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/index.js

@@ -1,4259 +1,62 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-
-// src/engine/directive.ts
-var directives = {};
-var Directive = class {
-};
-function registerDirective(name, directive) {
-  directives[name] = directive;
-}
-function applyDirective(element, directiveName) {
-  if (!directives[directiveName]) {
-    return null;
-  }
-  const directive = new directives[directiveName]();
-  directive.onInit?.(element);
-  return directive;
-}
-
-// src/engine/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  arrayEquals: () => arrayEquals,
-  calculateDistance: () => calculateDistance,
-  error: () => error,
-  fps2ms: () => fps2ms,
-  get: () => get,
-  isBrowser: () => isBrowser,
-  isFunction: () => isFunction,
-  isObject: () => isObject,
-  isObservable: () => isObservable,
-  isPromise: () => isPromise,
-  log: () => log,
-  preciseNow: () => preciseNow,
-  set: () => set,
-  setObservablePoint: () => setObservablePoint
-});
-import { Observable } from "rxjs";
-function isBrowser() {
-  return typeof window !== "undefined";
-}
-function preciseNow() {
-  return typeof performance !== "undefined" ? performance.now() : Date.now();
-}
-function fps2ms(fps) {
-  return 1e3 / fps;
-}
-function isPromise(value) {
-  return value && value instanceof Promise;
-}
-function arrayEquals(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const v = a[i];
-    const bv = b[i];
-    if (typeof v === "object" && v !== null) {
-      if (typeof bv !== "object" || bv === null) return false;
-      if (Array.isArray(v)) {
-        if (!Array.isArray(bv) || !arrayEquals(v, bv)) return false;
-      } else if (!objectEquals(v, bv)) {
-        return false;
-      }
-    } else if (v !== bv) {
-      return false;
-    }
-  }
-  return true;
-}
-function objectEquals(a, b) {
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) return false;
-  for (let key of keysA) {
-    if (!b.hasOwnProperty(key)) return false;
-    if (!deepEquals(a[key], b[key])) return false;
-  }
-  return true;
-}
-function deepEquals(a, b) {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a === "object" && a !== null) {
-    if (Array.isArray(a)) {
-      return Array.isArray(b) && arrayEquals(a, b);
-    }
-    return objectEquals(a, b);
-  }
-  return false;
-}
-function isFunction(val) {
-  return {}.toString.call(val) === "[object Function]";
-}
-function isObject(val) {
-  return typeof val == "object" && val != null && !Array.isArray(val) && val.constructor === Object;
-}
-function isObservable(val) {
-  return val instanceof Observable;
-}
-function set(obj, path, value, onlyPlainObject = false) {
-  if (Object(obj) !== obj) return obj;
-  if (typeof path === "string") {
-    path = path.split(".");
-  }
-  let len = path.length;
-  if (!len) return obj;
-  let current = obj;
-  for (let i = 0; i < len - 1; i++) {
-    let segment = path[i];
-    let nextSegment = path[i + 1];
-    let isNextNumeric = !isNaN(Number(nextSegment)) && isFinite(Number(nextSegment));
-    if (!current[segment] || typeof current[segment] !== "object") {
-      current[segment] = isNextNumeric && !onlyPlainObject ? [] : {};
-    }
-    current = current[segment];
-  }
-  current[path[len - 1]] = value;
-  return obj;
-}
-function get(obj, path) {
-  const keys = path.split(".");
-  let current = obj;
-  for (let key of keys) {
-    if (current[key] === void 0) {
-      return void 0;
-    }
-    current = current[key];
-  }
-  return current;
-}
-function log(text) {
-  console.log(text);
-}
-function error(text) {
-  console.error(text);
-}
-function setObservablePoint(observablePoint, point) {
-  if (typeof point === "number") {
-    observablePoint.set(point);
-  } else if (Array.isArray(point)) {
-    observablePoint.set(point[0], point[1]);
-  } else {
-    observablePoint.set(point.x, point.y);
-  }
-}
-function calculateDistance(x1, y1, x2, y2) {
-  const dx = x1 - x2;
-  const dy = y1 - y2;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-
-// src/directives/KeyboardControls.ts
-var keyCodeTable = {
-  3: "break",
-  8: "backspace",
-  // backspace / delete
-  9: "tab",
-  12: "clear",
-  13: "enter",
-  16: "shift",
-  17: "ctrl",
-  18: "alt",
-  19: "pause/break",
-  20: "caps lock",
-  27: "escape",
-  28: "conversion",
-  29: "non-conversion",
-  32: "space",
-  33: "page up",
-  34: "page down",
-  35: "end",
-  36: "home",
-  37: "left",
-  38: "up",
-  39: "right",
-  40: "down",
-  41: "select",
-  42: "print",
-  43: "execute",
-  44: "Print Screen",
-  45: "insert",
-  46: "delete",
-  48: "n0",
-  49: "n1",
-  50: "n2",
-  51: "n3",
-  52: "n4",
-  53: "n5",
-  54: "n6",
-  55: "n7",
-  56: "n8",
-  57: "n9",
-  58: ":",
-  59: "semicolon (firefox), equals",
-  60: "<",
-  61: "equals (firefox)",
-  63: "\xDF",
-  64: "@",
-  65: "a",
-  66: "b",
-  67: "c",
-  68: "d",
-  69: "e",
-  70: "f",
-  71: "g",
-  72: "h",
-  73: "i",
-  74: "j",
-  75: "k",
-  76: "l",
-  77: "m",
-  78: "n",
-  79: "o",
-  80: "p",
-  81: "q",
-  82: "r",
-  83: "s",
-  84: "t",
-  85: "u",
-  86: "v",
-  87: "w",
-  88: "x",
-  89: "y",
-  90: "z",
-  91: "Windows Key / Left \u2318 / Chromebook Search key",
-  92: "right window key",
-  93: "Windows Menu / Right \u2318",
-  96: "numpad 0",
-  97: "numpad 1",
-  98: "numpad 2",
-  99: "numpad 3",
-  100: "numpad 4",
-  101: "numpad 5",
-  102: "numpad 6",
-  103: "numpad 7",
-  104: "numpad 8",
-  105: "numpad 9",
-  106: "multiply",
-  107: "add",
-  108: "numpad period (firefox)",
-  109: "subtract",
-  110: "decimal point",
-  111: "divide",
-  112: "f1",
-  113: "f2",
-  114: "f3",
-  115: "f4",
-  116: "f5",
-  117: "f6",
-  118: "f7",
-  119: "f8",
-  120: "f9",
-  121: "f10",
-  122: "f11",
-  123: "f12",
-  124: "f13",
-  125: "f14",
-  126: "f15",
-  127: "f16",
-  128: "f17",
-  129: "f18",
-  130: "f19",
-  131: "f20",
-  132: "f21",
-  133: "f22",
-  134: "f23",
-  135: "f24",
-  144: "num lock",
-  145: "scroll lock",
-  160: "^",
-  161: "!",
-  163: "#",
-  164: "$",
-  165: "\xF9",
-  166: "page backward",
-  167: "page forward",
-  169: "closing paren (AZERTY)",
-  170: "*",
-  171: "~ + * key",
-  173: "minus (firefox), mute/unmute",
-  174: "decrease volume level",
-  175: "increase volume level",
-  176: "next",
-  177: "previous",
-  178: "stop",
-  179: "play/pause",
-  180: "e-mail",
-  181: "mute/unmute (firefox)",
-  182: "decrease volume level (firefox)",
-  183: "increase volume level (firefox)",
-  186: "semi-colon / \xF1",
-  187: "equal sign",
-  188: "comma",
-  189: "dash",
-  190: "period",
-  191: "forward slash / \xE7",
-  192: "grave accent / \xF1 / \xE6",
-  193: "?, / or \xB0",
-  194: "numpad period (chrome)",
-  219: "open bracket",
-  220: "back slash",
-  221: "close bracket / \xE5",
-  222: "single quote / \xF8",
-  223: "`",
-  224: "left or right \u2318 key (firefox)",
-  225: "altgr",
-  226: "< /git >",
-  230: "GNOME Compose Key",
-  231: "\xE7",
-  233: "XF86Forward",
-  234: "XF86Back",
-  240: "alphanumeric",
-  242: "hiragana/katakana",
-  243: "half-width/full-width",
-  244: "kanji",
-  255: "toggle touchpad"
-};
-var inverse = (obj) => {
-  const newObj = {};
-  for (let key in obj) {
-    const val = obj[key];
-    newObj[val] = key;
-  }
-  return newObj;
-};
-var inverseKeyCodeTable = inverse(keyCodeTable);
-var KeyboardControls = class extends Directive {
-  constructor() {
-    super(...arguments);
-    this.keyState = {};
-    this.boundKeys = {};
-    this.stop = false;
-    this.lastKeyPressed = null;
-    this._controlsOptions = {};
-    // TODO: This should be dynamic
-    this.serverFps = 60;
-    this.directionState = {
-      up: false,
-      down: false,
-      left: false,
-      right: false
-    };
-  }
-  onInit(element) {
-    const value = element.props.controls.value ?? element.props.controls;
-    if (!value) return;
-    this.setupListeners();
-    this.setInputs(value);
-    this.interval = setInterval(() => {
-      this.preStep();
-    }, fps2ms(this.serverFps ?? 60));
-  }
-  onMount(element) {
-  }
-  onUpdate(props) {
-    this.setInputs(props);
-  }
-  onDestroy() {
-    clearInterval(this.interval);
-    document.removeEventListener("keydown", (e) => {
-      this.onKeyChange(e, true);
-    });
-    document.removeEventListener("keyup", (e) => {
-      this.onKeyChange(e, false);
-    });
-  }
-  /** @internal */
-  preStep() {
-    if (this.stop) return;
-    const direction = this.getDirection();
-    if (direction !== "none") {
-      const directionControl = this.boundKeys[direction];
-      if (directionControl) {
-        const { keyDown } = directionControl.options;
-        if (keyDown) {
-          this.applyInput(direction);
-        }
-      }
-    } else {
-      const boundKeys = Object.keys(this.boundKeys);
-      for (let keyName of boundKeys) {
-        this.applyInput(keyName);
-      }
-    }
-  }
-  applyInput(keyName) {
-    const keyState = this.keyState[keyName];
-    if (!keyState) return;
-    const { isDown, count } = keyState;
-    if (isDown) {
-      const { repeat, keyDown } = this.boundKeys[keyName].options;
-      if (repeat || count == 0) {
-        let parameters = this.boundKeys[keyName].parameters;
-        if (typeof parameters === "function") {
-          parameters = parameters();
-        }
-        if (keyDown) {
-          keyDown(this.boundKeys[keyName]);
-        }
-        this.keyState[keyName].count++;
-      }
-    }
-  }
-  setupListeners() {
-    document.addEventListener("keydown", (e) => {
-      this.onKeyChange(e, true);
-    });
-    document.addEventListener("keyup", (e) => {
-      this.onKeyChange(e, false);
-    });
-  }
-  bindKey(keys, actionName, options, parameters) {
-    if (!Array.isArray(keys)) keys = [keys];
-    const keyOptions = Object.assign({
-      repeat: false
-    }, options);
-    keys.forEach((keyName) => {
-      this.boundKeys[keyName] = { actionName, options: keyOptions, parameters };
-    });
-  }
-  applyKeyDown(name) {
-    const code = inverseKeyCodeTable[name];
-    const e = new Event("keydown");
-    e.keyCode = code;
-    this.onKeyChange(e, true);
-  }
-  applyKeyUp(name) {
-    const code = inverseKeyCodeTable[name];
-    const e = new Event("keyup");
-    e.keyCode = code;
-    this.onKeyChange(e, false);
-  }
-  applyKeyPress(name) {
-    return new Promise((resolve) => {
-      this.applyKeyDown(name);
-      setTimeout(() => {
-        this.applyKeyUp(name);
-        resolve();
-      }, 200);
-    });
-  }
-  onKeyChange(e, isDown) {
-    e = e || window.event;
-    const keyName = keyCodeTable[e.keyCode];
-    if (keyName && this.boundKeys[keyName]) {
-      if (this.keyState[keyName] == null) {
-        this.keyState[keyName] = {
-          count: 0,
-          isDown: true
-        };
-      }
-      this.keyState[keyName].isDown = isDown;
-      if (!isDown) {
-        this.keyState[keyName].count = 0;
-        const { keyUp } = this.boundKeys[keyName].options;
-        if (keyUp) {
-          keyUp(this.boundKeys[keyName]);
-        }
-      }
-      this.lastKeyPressed = isDown ? e.keyCode : null;
-    }
-    if (keyName) {
-      this.updateDirectionState(keyName, isDown);
-    }
-  }
-  updateDirectionState(keyName, isDown) {
-    switch (keyName) {
-      case "up":
-        this.directionState.up = isDown;
-        break;
-      case "down":
-        this.directionState.down = isDown;
-        break;
-      case "left":
-        this.directionState.left = isDown;
-        break;
-      case "right":
-        this.directionState.right = isDown;
-        break;
-    }
-  }
-  getDirection() {
-    const { up, down, left, right } = this.directionState;
-    if (up && left) return "up_left";
-    if (up && right) return "up_right";
-    if (down && left) return "down_left";
-    if (down && right) return "down_right";
-    if (up) return "up";
-    if (down) return "down";
-    if (left) return "left";
-    if (right) return "right";
-    return "none";
-  }
-  /**
-       * From the name of the entry, we retrieve the control information
-       * 
-       * ```ts 
-       * import { Input, inject, KeyboardControls } from '@rpgjs/client'
-       * 
-       * const controls = inject(KeyboardControls)
-       * controls.getControl(Input.Enter)
-  
-       * if (control) {
-       *    console.log(control.actionName) // action
-       * }
-       * ```
-       * @title Get Control
-       * @method getControl(inputName)
-       * @param {string} inputName
-       * @returns { { actionName: string, options: any } | undefined }
-       * @memberof KeyboardControls
-       */
-  getControl(inputName) {
-    return this.boundKeys[inputName];
-  }
-  /**
-   * Returns all controls
-   * 
-   * @method getControls()
-   * @since 4.2.0
-   * @returns { { [key: string]: BoundKey } }
-   * @memberof KeyboardControls
-   */
-  getControls() {
-    return this.boundKeys;
-  }
-  /**
-   * Triggers an input according to the name of the control
-   * 
-   * ```ts 
-   * import { Control, inject, KeyboardControls } from '@rpgjs/client'
-   * 
-   * const controls = inject(KeyboardControls)
-   * controls.applyControl(Control.Action)
-   * ```
-   * 
-   * You can put a second parameter or indicate on whether the key is pressed or released
-   * 
-   * ```ts 
-   * import { Control, inject, KeyboardControls } from '@rpgjs/client'
-   * 
-   * const controls = inject(KeyboardControls)
-   * controls.applyControl(Control.Up, true) // keydown
-   * controls.applyControl(Control.Up, false) // keyup
-   * ```
-   * @title Apply Control
-   * @method applyControl(controlName,isDown)
-   * @param {string} controlName
-   * @param {boolean} [isDown]
-   * @returns {Promise<void>}
-   * @memberof KeyboardControls
-   */
-  async applyControl(controlName, isDown) {
-    const control = this._controlsOptions[controlName];
-    if (control) {
-      const input = Array.isArray(control.bind) ? control.bind[0] : control.bind;
-      if (isDown === void 0) {
-        await this.applyKeyPress(input);
-      } else if (isDown) {
-        this.applyKeyDown(input);
-      } else {
-        this.applyKeyUp(input);
-      }
-    }
-  }
-  /**
-   * Stop listening to the inputs. Pressing a key won't do anything
-   * 
-   * @title Stop Inputs
-   * @method stopInputs()
-   * @returns {void}
-   * @memberof KeyboardControls
-   */
-  stopInputs() {
-    this.stop = true;
-  }
-  /**
-   * Listen to the inputs again
-   * 
-   * @title Listen Inputs
-   * @method listenInputs()
-   * @returns {void}
-   * @memberof KeyboardControls
-   */
-  listenInputs() {
-    this.stop = false;
-    this.keyState = {};
-  }
-  /**
-       * Assign custom inputs to the scene
-       * 
-       * The object is the following:
-       * 
-       * * the key of the object is the name of the control. Either it is existing controls (Up, Dow, Left, Right, Action, Back) or customized controls
-       * * The value is an object representing control information:
-       *      * repeat {boolean} The key can be held down to repeat the action. (false by default)
-       *      * bind {string | string[]} To which key is linked the control
-       *      * method {Function} Function to be triggered. If you do not set this property, the name of the control is sent directly to the server.
-       *      * delay {object|number} (since v3.2.0) Indicates how long (in milliseconds) the player can press the key again to perform the action
-       *          * delay.duration
-       *          * delay.otherControls {string | string[]} Indicates the other controls that will also have the delay at the same time
-       * 
-       * ```ts 
-       * import { Control, Input, inject, KeyboardControls } from '@rpgjs/client'
-       * 
-       * const controls = inject(KeyboardControls)
-       * controls.setInputs({
-              [Control.Up]: {
-                  repeat: true,
-                  bind: Input.Up
-              },
-              [Control.Down]: {
-                  repeat: true,
-                  bind: Input.Down
-              },
-              [Control.Right]: {
-                  repeat: true,
-                  bind: Input.Right
-              },
-              [Control.Left]: {
-                  repeat: true,
-                  bind: Input.Left
-              },
-              [Control.Action]: {
-                  bind: [Input.Space, Input.Enter]
-              },
-              [Control.Back]: {
-                  bind: Input.Escape
-              },
-  
-              // The myscustom1 control is sent to the server when the A key is pressed.
-              mycustom1: {
-                  bind: Input.A
-              },
-  
-              // the myAction method is executed when the B key is pressed
-              mycustom2: {
-                  bind: Input.B,
-                  method({ actionName }) {
-                      console.log('cool', actionName)
-                  }
-              },
-  
-              // The player can redo the action after 400ms
-              mycustom3: {
-                  bind: Input.C,
-                  delay: 400 // ms
-              },
-  
-              // The player can redo the action (mycustom4) and the directions after 400ms
-              mycustom4: {
-                  bind: Input.C,
-                  delay: {
-                      duration: 400,
-                      otherControls: [Control.Up, Control.Down, Control.Left, Control.Right]
-                  }
-              }
-          })
-       * 
-       * ```
-       * @enum {string} Control 
-       * 
-       * Control.Up | up
-       * Control.Down | down
-       * Control.Left | left
-       * Control.Right | right
-       * Control.Action | action
-       * Control.Back | back
-       * 
-       * @enum {string} Mouse Event 
-       * 
-       * click | Click
-       * dblclick | Double Click
-       * mousedown | Mouse Down
-       * mouseup | Mouse Up
-       * mouseover | Mouse Over
-       * mousemove | Mouse Move
-       * mouseout | Mouse Out
-       * contextmenu | Context Menu
-       * 
-       * 
-       * @enum {string} Input 
-       * 
-       * break | Pause
-      * backspace | Backspace / Delete
-      * tab | Tab
-      * clear | Clear
-      * enter | Enter
-      * shift | Shift
-      * ctrl | Control
-      * alt | Alt
-      * pause/break | Pause / Break
-      * caps lock | Caps Lock
-      * escape | Escape
-      * conversion | Conversion
-      * non-conversion | Non-conversion
-      * space | Space
-      * page up | Page Up
-      * page down | Page Down
-      * end | End
-      * home | Home
-      * left | Left Arrow
-      * up | Up Arrow
-      * right | Right Arrow
-      * down | Down Arrow
-      * select | Select
-      * print | Print
-      * execute | Execute
-      * Print Screen | Print Screen
-      * insert | Insert
-      * delete | Delete
-      * n0 | 0
-      * n1 | 1
-      * n2 | 2
-      * n3 | 3
-      * n4 | 4
-      * n5 | 5
-      * n6 | 6
-      * n7 | 7
-      * n8 | 8
-      * n9 | 9
-      * : | Colon
-      * semicolon (firefox), equals | Semicolon (Firefox), Equals
-      * < | Less Than
-      * equals (firefox) | Equals (Firefox)
-      * ß | Eszett
-      * @ | At
-      * a | A
-      * b | B
-      * c | C
-      * d | D
-      * e | E
-      * f | F
-      * g | G
-      * h | H
-      * i | I
-      * j | J
-      * k | K
-      * l | L
-      * m | M
-      * n | N
-      * o | O
-      * p | P
-      * q | Q
-      * r | R
-      * s | S
-      * t | T
-      * u | U
-      * v | V
-      * w | W
-      * x | X
-      * y | Y
-      * z | Z
-      * Windows Key / Left ⌘ / Chromebook Search key | Windows Key / Left Command ⌘ / Chromebook Search Key
-      * right window key | Right Windows Key
-      * Windows Menu / Right ⌘ | Windows Menu / Right Command ⌘
-      * numpad 0 | Numpad 0
-      * numpad 1 | Numpad 1
-      * numpad 2 | Numpad 2
-      * numpad 3 | Numpad 3
-      * numpad 4 | Numpad 4
-      * numpad 5 | Numpad 5
-      * numpad 6 | Numpad 6
-      * numpad 7 | Numpad 7
-      * numpad 8 | Numpad 8
-      * numpad 9 | Numpad 9
-      * multiply | Multiply
-      * add | Add
-      * numpad period (firefox) | Numpad Period (Firefox)
-      * subtract | Subtract
-      * decimal point | Decimal Point
-      * divide | Divide
-      * f1 | F1
-      * f2 | F2
-      * f3 | F3
-      * f4 | F4
-      * f5 | F5
-      * f6 | F6
-      * f7 | F7
-      * f8 | F8
-      * f9 | F9
-      * f10 | F10
-      * f11 | F11
-      * f12 | F12
-      * f13 | F13
-      * f14 | F14
-      * f15 | F15
-      * f16 | F16
-      * f17 | F17
-      * f18 | F18
-      * f19 | F19
-      * f20 | F20
-      * f21 | F21
-      * f22 | F22
-      * f23 | F23
-      * f24 | F24
-      * num lock | Num Lock
-      * scroll lock | Scroll Lock
-      * ^ | Caret
-      * ! | Exclamation Point
-      * # | Hash
-      * $ | Dollar Sign
-      * ù | Grave Accent U
-      * page backward | Page Backward
-      * page forward | Page Forward
-      * closing paren (AZERTY) | Closing Parenthesis (AZERTY)
-      * * | Asterisk
-      * ~ + * key | Tilde + Asterisk Key
-      * minus (firefox), mute/unmute | Minus (Firefox), Mute/Unmute
-      * decrease volume level | Decrease Volume Level
-      * increase volume level | Increase Volume Level
-      * next | Next
-      * previous | Previous
-      * stop | Stop
-      * play/pause | Play/Pause
-      * e-mail | Email
-      * mute/unmute (firefox) | Mute/Unmute (Firefox)
-      * decrease volume level (firefox) | Decrease Volume Level (Firefox)
-      * increase volume level (firefox) | Increase Volume Level (Firefox)
-      * semi-colon / ñ | Semicolon / ñ
-      * equal sign | Equal Sign
-      * comma | Comma
-      * dash | Dash
-      * period | Period
-      * forward slash / ç | Forward Slash / ç
-      * grave accent / ñ / æ | Grave Accent / ñ / æ
-      * ?, / or ° | ?, / or °
-      * numpad period (chrome) | Numpad Period (Chrome)
-      * open bracket | Open Bracket
-      * back slash | Backslash
-      * close bracket / å | Close Bracket / å
-      * single quote / ø | Single Quote / ø
-      * \` | Backtick
-      * left or right ⌘ key (firefox) | Left or Right Command Key (Firefox)
-      * altgr | AltGr
-      * < /git > | < /git >
-      * GNOME Compose Key | GNOME Compose Key
-      * ç | ç
-      * XF86Forward | XF86Forward
-      * XF86Back | XF86Back
-      * alphanumeric | Alphanumeric
-      * hiragana/katakana | Hiragana/Katakana
-      * half-width/full-width | Half-Width/Full-Width
-      * kanji | Kanji
-      * toggle touchpad | Toggle Touchpad
-       * 
-       * @title Set Inputs
-       * @method setInputs(inputs)
-       * @param {object} inputs
-       * @memberof KeyboardControls
-       */
-  setInputs(inputs) {
-    if (!inputs) return;
-    this.boundKeys = {};
-    let inputsTransformed = {};
-    for (let control in inputs) {
-      const option = inputs[control];
-      const { bind } = option;
-      let inputsKey = bind;
-      if (!Array.isArray(inputsKey)) {
-        inputsKey = [bind];
-      }
-      for (let input of inputsKey) {
-        this.bindKey(input, control, option);
-      }
-    }
-    this._controlsOptions = inputs;
-  }
-  get options() {
-    return this._controlsOptions;
-  }
-};
-registerDirective("controls", KeyboardControls);
-
-// src/directives/Scheduler.ts
-var Scheduler = class extends Directive {
-  constructor() {
-    super(...arguments);
-    this.fps = 60;
-    this.deltaTime = 0;
-    this.frame = 0;
-    this.timestamp = 0;
-    this.requestedDelay = 0;
-    this.lastTimestamp = 0;
-    this._stop = false;
-  }
-  onInit(element) {
-    this.tick = element.propObservables?.tick;
-  }
-  onDestroy() {
-  }
-  onMount(element) {
-  }
-  onUpdate(props) {
-  }
-  nextTick(timestamp) {
-    this.lastTimestamp = this.lastTimestamp || this.timestamp;
-    this.deltaTime = preciseNow() - this.timestamp;
-    this.timestamp = timestamp;
-    this.tick.set({
-      timestamp: this.timestamp,
-      deltaTime: this.deltaTime,
-      frame: this.frame,
-      deltaRatio: ~~this.deltaTime / ~~fps2ms(this.fps)
-    });
-    this.lastTimestamp = this.timestamp;
-    this.frame++;
-  }
-  /**
-   * start the schedule
-   * @return {Scheduler} returns this scheduler instance
-   */
-  start(options = {}) {
-    if (options.maxFps) this.maxFps = options.maxFps;
-    if (options.fps) this.fps = options.fps;
-    if (options.delay) this.requestedDelay = options.delay;
-    const requestAnimationFrame = (fn) => {
-      if (isBrowser()) {
-        window.requestAnimationFrame(fn.bind(this));
-      } else {
-        setTimeout(() => {
-          this.requestedDelay = 0;
-          fn(preciseNow());
-        }, fps2ms(this.fps) + this.requestedDelay);
-      }
-    };
-    if (!this.maxFps) {
-      const loop2 = (timestamp) => {
-        requestAnimationFrame(loop2);
-        this.nextTick(timestamp);
-      };
-      requestAnimationFrame(loop2);
-    } else {
-      const msInterval = fps2ms(this.maxFps);
-      let now = preciseNow();
-      let then = preciseNow();
-      const loop2 = (timestamp) => {
-        if (this._stop) return;
-        requestAnimationFrame(loop2);
-        now = preciseNow();
-        const elapsed = now - then;
-        if (elapsed > msInterval) {
-          then = now - elapsed % msInterval;
-          this.nextTick(timestamp);
-        }
-      };
-      requestAnimationFrame(loop2);
-    }
-    return this;
-  }
-  stop() {
-    this._stop = true;
-  }
-};
-registerDirective("tick", Scheduler);
-
-// src/hooks/useProps.ts
-import { isSignal as isSignal2, signal as signal2 } from "@signe/reactive";
-
-// src/engine/reactive.ts
-import { isComputed, isSignal, signal } from "@signe/reactive";
-import {
-  Observable as Observable2,
-  Subject,
-  defer,
-  from,
-  map,
-  of,
-  share
-} from "rxjs";
-var components = {};
-var isElement = (value) => {
-  return value && typeof value === "object" && "tag" in value && "props" in value && "componentInstance" in value;
-};
-var isPrimitive = (value) => {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === void 0;
-};
-function registerComponent(name, component) {
-  components[name] = component;
-}
-function destroyElement(element) {
-  if (Array.isArray(element)) {
-    element.forEach((e) => destroyElement(e));
-    return;
-  }
-  if (!element) {
-    return;
-  }
-  if (element.props?.children) {
-    for (let child of element.props.children) {
-      destroyElement(child);
-    }
-  }
-  for (let name in element.directives) {
-    element.directives[name].onDestroy?.(element);
-  }
-  if (element.componentInstance && element.componentInstance.onDestroy) {
-    element.componentInstance.onDestroy(element.parent, () => {
-      element.propSubscriptions?.forEach((sub) => sub.unsubscribe());
-      element.effectSubscriptions?.forEach((sub) => sub.unsubscribe());
-      element.effectUnmounts?.forEach((fn) => fn?.());
-    });
-  } else {
-    element.propSubscriptions?.forEach((sub) => sub.unsubscribe());
-    element.effectSubscriptions?.forEach((sub) => sub.unsubscribe());
-    element.effectUnmounts?.forEach((fn) => fn?.());
-  }
-}
-function createComponent(tag, props) {
-  if (!components[tag]) {
-    throw new Error(`Component ${tag} is not registered`);
-  }
-  const instance = new components[tag]();
-  const element = {
-    tag,
-    props: {},
-    componentInstance: instance,
-    propSubscriptions: [],
-    propObservables: props,
-    parent: null,
-    directives: {},
-    effectUnmounts: [],
-    effectSubscriptions: [],
-    effectMounts: [],
-    destroy() {
-      destroyElement(this);
-    },
-    allElements: new Subject()
-  };
-  if (props) {
-    const recursiveProps = (props2, path = "") => {
-      const _set = (path2, key, value) => {
-        if (path2 == "") {
-          element.props[key] = value;
-          return;
-        }
-        set(element.props, path2 + "." + key, value);
-      };
-      Object.entries(props2).forEach(([key, value]) => {
-        if (isSignal(value)) {
-          const _value = value;
-          if ("dependencies" in _value && _value.dependencies.size == 0) {
-            _set(path, key, _value());
-            return;
-          }
-          element.propSubscriptions.push(
-            _value.observable.subscribe((value2) => {
-              _set(path, key, value2);
-              if (element.directives[key]) {
-                element.directives[key].onUpdate?.(value2, element);
-              }
-              if (key == "tick") {
-                return;
-              }
-              instance.onUpdate?.(
-                path == "" ? {
-                  [key]: value2
-                } : set({}, path + "." + key, value2)
-              );
-            })
-          );
-        } else {
-          if (isObject(value) && key != "context" && !isElement(value)) {
-            recursiveProps(value, (path ? path + "." : "") + key);
-          } else {
-            _set(path, key, value);
-          }
-        }
-      });
-    };
-    recursiveProps(props);
-  }
-  instance.onInit?.(element.props);
-  const elementsListen = new Subject();
-  if (props?.isRoot) {
-    element.allElements = elementsListen;
-    element.props.context.rootElement = element;
-    element.componentInstance.onMount?.(element);
-    propagateContext(element);
-  }
-  if (props) {
-    for (let key in props) {
-      const directive = applyDirective(element, key);
-      if (directive) element.directives[key] = directive;
-    }
-  }
-  function onMount(parent, element2, index) {
-    element2.props.context = parent.props.context;
-    element2.parent = parent;
-    element2.componentInstance.onMount?.(element2, index);
-    for (let name in element2.directives) {
-      element2.directives[name].onMount?.(element2);
-    }
-    element2.effectMounts.forEach((fn) => {
-      element2.effectUnmounts.push(fn(element2));
-    });
-  }
-  ;
-  async function propagateContext(element2) {
-    if (element2.props.attach) {
-      const isReactiveAttach = isSignal(element2.propObservables?.attach);
-      if (!isReactiveAttach) {
-        element2.props.children.push(element2.props.attach);
-      } else {
-        await new Promise((resolve) => {
-          let lastElement = null;
-          element2.propSubscriptions.push(element2.propObservables.attach.observable.subscribe(async (args) => {
-            const value = args?.value ?? args;
-            if (!value) {
-              throw new Error(`attach in ${element2.tag} is undefined or null, add a component`);
-            }
-            if (lastElement) {
-              destroyElement(lastElement);
-            }
-            lastElement = value;
-            await createElement(element2, value);
-            resolve(void 0);
-          }));
-        });
-      }
-    }
-    if (!element2.props.children) {
-      return;
-    }
-    for (let child of element2.props.children) {
-      if (!child) continue;
-      await createElement(element2, child);
-    }
-  }
-  ;
-  async function createElement(parent, child) {
-    if (isPromise(child)) {
-      child = await child;
-    }
-    if (child instanceof Observable2) {
-      child.subscribe(
-        ({
-          elements: comp,
-          prev
-        }) => {
-          const components2 = comp.filter((c) => c !== null);
-          if (prev) {
-            components2.forEach((c) => {
-              const index = parent.props.children.indexOf(prev.props.key);
-              onMount(parent, c, index + 1);
-              propagateContext(c);
-            });
-            return;
-          }
-          components2.forEach((component) => {
-            if (!Array.isArray(component)) {
-              onMount(parent, component);
-              propagateContext(component);
-            } else {
-              component.forEach((comp2) => {
-                onMount(parent, comp2);
-                propagateContext(comp2);
-              });
-            }
-          });
-          elementsListen.next(void 0);
-        }
-      );
-    } else {
-      onMount(parent, child);
-      await propagateContext(child);
-    }
-  }
-  return element;
-}
-function loop(itemsSubject, createElementFn) {
-  if (isComputed(itemsSubject) && itemsSubject.dependencies.size == 0) {
-    itemsSubject = signal(itemsSubject());
-  } else if (!isSignal(itemsSubject)) {
-    itemsSubject = signal(itemsSubject);
-  }
-  return defer(() => {
-    let elements = [];
-    let elementMap = /* @__PURE__ */ new Map();
-    let isFirstSubscription = true;
-    const isArraySignal = (signal10) => Array.isArray(signal10());
-    return new Observable2((subscriber) => {
-      const subscription = isArraySignal(itemsSubject) ? itemsSubject.observable.subscribe((change) => {
-        if (isFirstSubscription) {
-          isFirstSubscription = false;
-          elements.forEach((el) => el.destroy());
-          elements = [];
-          elementMap.clear();
-          const items = itemsSubject();
-          if (items) {
-            items.forEach((item, index) => {
-              const element = createElementFn(item, index);
-              if (element) {
-                elements.push(element);
-                elementMap.set(index, element);
-              }
-            });
-          }
-          subscriber.next({
-            elements: [...elements]
-          });
-          return;
-        }
-        if (change.type === "init" || change.type === "reset") {
-          elements.forEach((el) => el.destroy());
-          elements = [];
-          elementMap.clear();
-          const items = itemsSubject();
-          if (items) {
-            items.forEach((item, index) => {
-              const element = createElementFn(item, index);
-              if (element) {
-                elements.push(element);
-                elementMap.set(index, element);
-              }
-            });
-          }
-        } else if (change.type === "add" && change.index !== void 0) {
-          const newElements = change.items.map((item, i) => {
-            const element = createElementFn(item, change.index + i);
-            if (element) {
-              elementMap.set(change.index + i, element);
-            }
-            return element;
-          }).filter((el) => el !== null);
-          elements.splice(change.index, 0, ...newElements);
-        } else if (change.type === "remove" && change.index !== void 0) {
-          const removed = elements.splice(change.index, 1);
-          removed.forEach((el) => {
-            el.destroy();
-            elementMap.delete(change.index);
-          });
-        } else if (change.type === "update" && change.index !== void 0 && change.items.length === 1) {
-          const index = change.index;
-          const newItem = change.items[0];
-          if (index >= elements.length || elements[index] === void 0 || !elementMap.has(index)) {
-            const newElement = createElementFn(newItem, index);
-            if (newElement) {
-              elements.splice(index, 0, newElement);
-              elementMap.set(index, newElement);
-            } else {
-              console.warn(`Element creation returned null for index ${index} during add-like update.`);
-            }
-          } else {
-            const oldElement = elements[index];
-            oldElement.destroy();
-            const newElement = createElementFn(newItem, index);
-            if (newElement) {
-              elements[index] = newElement;
-              elementMap.set(index, newElement);
-            } else {
-              elements.splice(index, 1);
-              elementMap.delete(index);
-            }
-          }
-        }
-        subscriber.next({
-          elements: [...elements]
-          // Create a new array to ensure change detection
-        });
-      }) : itemsSubject.observable.subscribe((change) => {
-        const key = change.key;
-        if (isFirstSubscription) {
-          isFirstSubscription = false;
-          elements.forEach((el) => el.destroy());
-          elements = [];
-          elementMap.clear();
-          const items = itemsSubject();
-          if (items) {
-            Object.entries(items).forEach(([key2, value]) => {
-              const element = createElementFn(value, key2);
-              if (element) {
-                elements.push(element);
-                elementMap.set(key2, element);
-              }
-            });
-          }
-          subscriber.next({
-            elements: [...elements]
-          });
-          return;
-        }
-        if (change.type === "init" || change.type === "reset") {
-          elements.forEach((el) => el.destroy());
-          elements = [];
-          elementMap.clear();
-          const items = itemsSubject();
-          if (items) {
-            Object.entries(items).forEach(([key2, value]) => {
-              const element = createElementFn(value, key2);
-              if (element) {
-                elements.push(element);
-                elementMap.set(key2, element);
-              }
-            });
-          }
-        } else if (change.type === "add" && change.key && change.value !== void 0) {
-          const element = createElementFn(change.value, key);
-          if (element) {
-            elements.push(element);
-            elementMap.set(key, element);
-          }
-        } else if (change.type === "remove" && change.key) {
-          const index = elements.findIndex((el) => elementMap.get(key) === el);
-          if (index !== -1) {
-            const [removed] = elements.splice(index, 1);
-            removed.destroy();
-            elementMap.delete(key);
-          }
-        } else if (change.type === "update" && change.key && change.value !== void 0) {
-          const index = elements.findIndex((el) => elementMap.get(key) === el);
-          if (index !== -1) {
-            const oldElement = elements[index];
-            oldElement.destroy();
-            const newElement = createElementFn(change.value, key);
-            if (newElement) {
-              elements[index] = newElement;
-              elementMap.set(key, newElement);
-            }
-          }
-        }
-        subscriber.next({
-          elements: [...elements]
-          // Create a new array to ensure change detection
-        });
-      });
-      return subscription;
-    });
-  });
-}
-function cond(condition, createElementFn) {
-  let element = null;
-  if (isSignal(condition)) {
-    const signalCondition = condition;
-    return new Observable2((subscriber) => {
-      return signalCondition.observable.subscribe((bool) => {
-        if (bool) {
-          let _el = createElementFn();
-          if (isPromise(_el)) {
-            from(_el).subscribe((el) => {
-              element = el;
-              subscriber.next({
-                type: "init",
-                elements: [el]
-              });
-            });
-          } else {
-            element = _el;
-            subscriber.next({
-              type: "init",
-              elements: [element]
-            });
-          }
-        } else if (element) {
-          destroyElement(element);
-          subscriber.next({
-            elements: []
-          });
-        } else {
-          subscriber.next({
-            elements: []
-          });
-        }
-      });
-    }).pipe(share());
-  } else {
-    if (condition) {
-      let _el = createElementFn();
-      if (isPromise(_el)) {
-        return from(_el).pipe(
-          map((el) => ({
-            type: "init",
-            elements: [el]
-          }))
-        );
-      }
-      return of({
-        type: "init",
-        elements: [_el]
-      });
-    }
-    return of({
-      elements: []
-    });
-  }
-}
-
-// src/hooks/useProps.ts
-var useProps = (props, defaults = {}) => {
-  if (isSignal2(props)) {
-    return props();
-  }
-  const obj = {};
-  for (let key in props) {
-    const value = props[key];
-    obj[key] = isPrimitive(value) ? signal2(value) : value;
-  }
-  for (let key in defaults) {
-    if (!(key in obj)) {
-      obj[key] = isPrimitive(defaults[key]) ? signal2(defaults[key]) : defaults[key];
-    }
-  }
-  return obj;
-};
-var useDefineProps = (props) => {
-  return (schema) => {
-    const rawProps = isSignal2(props) ? props() : props;
-    const validatedProps = {};
-    for (const key in schema) {
-      const propConfig = schema[key];
-      const value = rawProps[key];
-      let validatedValue;
-      if (typeof propConfig === "function") {
-        validateType(key, value, [propConfig]);
-        validatedValue = value;
-      } else if (Array.isArray(propConfig)) {
-        validateType(key, value, propConfig);
-        validatedValue = value;
-      } else if (propConfig && typeof propConfig === "object") {
-        if (propConfig.required && value === void 0) {
-          throw new Error(`Missing required prop: ${key}`);
-        }
-        if (propConfig.type) {
-          const types = Array.isArray(propConfig.type) ? propConfig.type : [propConfig.type];
-          validateType(key, value, types);
-        }
-        if (propConfig.validator && !propConfig.validator(value, rawProps)) {
-          throw new Error(`Invalid prop: custom validation failed for prop "${key}"`);
-        }
-        if (value === void 0 && "default" in propConfig) {
-          validatedValue = typeof propConfig.default === "function" ? propConfig.default(rawProps) : propConfig.default;
-        } else {
-          validatedValue = value;
-        }
-      }
-      validatedProps[key] = isSignal2(validatedValue) ? validatedValue : signal2(validatedValue);
-    }
-    return {
-      ...useProps(rawProps),
-      ...validatedProps
-    };
-  };
-};
-function validateType(key, value, types) {
-  if (value === void 0 || value === null) return;
-  const valueToCheck = isSignal2(value) ? value() : value;
-  const valid = types.some((type) => {
-    if (type === Number) return typeof valueToCheck === "number";
-    if (type === String) return typeof valueToCheck === "string";
-    if (type === Boolean) return typeof valueToCheck === "boolean";
-    if (type === Function) return typeof valueToCheck === "function";
-    if (type === Object) return typeof valueToCheck === "object";
-    if (type === Array) return Array.isArray(valueToCheck);
-    if (type === null) return valueToCheck === null;
-    return valueToCheck instanceof type;
-  });
-  if (!valid) {
-    throw new Error(
-      `Invalid prop: type check failed for prop "${key}". Expected ${types.map((t) => t.name).join(" or ")}`
-    );
-  }
-}
-
-// src/directives/ViewportFollow.ts
-var ViewportFollow = class extends Directive {
-  onInit(element) {
-  }
-  onMount(element) {
-    this.onUpdate(element.props.viewportFollow, element);
-  }
-  onUpdate(viewportFollow, element) {
-    const { viewport } = element.props.context;
-    if (!viewport) {
-      throw error("ViewportFollow directive requires a Viewport component to be mounted in the same context");
-    }
-    if (viewportFollow) {
-      if (viewportFollow === true) {
-        viewport.follow(element.componentInstance);
-      } else {
-        const options = useProps(viewportFollow, {
-          speed: void 0,
-          acceleration: void 0,
-          radius: void 0
-        });
-        viewport.follow(element.componentInstance, {
-          speed: options.speed(),
-          acceleration: options.acceleration(),
-          radius: options.radius()
-        });
-      }
-    } else if (viewportFollow === null) {
-      viewport.plugins.remove("follow");
-    }
-  }
-  onDestroy(element) {
-    const { viewportFollow } = element.props;
-    const { viewport } = element.props.context;
-    if (viewportFollow) viewport.plugins.remove("follow");
-  }
-};
-registerDirective("viewportFollow", ViewportFollow);
-
-// src/directives/Sound.ts
-import { effect } from "@signe/reactive";
-import { Howl } from "howler";
-var EVENTS = ["load", "loaderror", "playerror", "play", "end", "pause", "stop", "mute", "volume", "rate", "seek", "fade", "unlock"];
-var Sound = class extends Directive {
-  constructor() {
-    super(...arguments);
-    this.sounds = [];
-    this.eventsFn = [];
-    this.maxVolume = 1;
-    this.maxDistance = 100;
-  }
-  onInit(element) {
-  }
-  onMount(element) {
-    const { props } = element;
-    const tick2 = props.context.tick;
-    const propsSound = props.sound.value ?? props.sound;
-    if (!propsSound.src) {
-      return;
-    }
-    const { src, autoplay, loop: loop2, volume, spatial } = propsSound;
-    const sources = Array.isArray(src) ? src : [src];
-    for (const source of sources) {
-      if (!source) continue;
-      const sound = new Howl({
-        src: source,
-        autoplay,
-        loop: loop2,
-        volume
-      });
-      for (let event of EVENTS) {
-        if (!propsSound[event]) continue;
-        const fn = propsSound[event];
-        this.eventsFn.push(fn);
-        sound.on(event, fn);
-      }
-      this.sounds.push(sound);
-    }
-    if (spatial && this.sounds.length > 0) {
-      const { soundListenerPosition } = props.context;
-      if (!soundListenerPosition) {
-        throw new error("SoundListenerPosition directive is required for spatial sound in component parent");
-      }
-      const { x: listenerX, y: listenerY } = soundListenerPosition;
-      this.tickSubscription = effect(() => {
-        tick2();
-        const { x, y } = element.componentInstance;
-        const distance = calculateDistance(x, y, listenerX(), listenerY());
-        const volume2 = Math.max(this.maxVolume - distance / this.maxDistance, 0);
-        this.sounds.forEach((sound) => sound.volume(volume2));
-      }).subscription;
-    }
-    this.onUpdate(propsSound);
-  }
-  onUpdate(props) {
-    const soundProps = props.value ?? props;
-    const { volume, loop: loop2, mute, seek, playing, rate, spatial } = soundProps;
-    this.sounds.forEach((sound) => {
-      if (volume !== void 0) sound.volume(volume);
-      if (loop2 !== void 0) sound.loop(loop2);
-      if (mute !== void 0) sound.mute(mute);
-      if (seek !== void 0) sound.seek(seek);
-      if (playing !== void 0) {
-        if (playing) sound.play();
-        else sound.pause();
-      }
-      if (rate !== void 0) sound.rate(rate);
-    });
-    if (spatial) {
-      this.maxVolume = spatial.maxVolume ?? this.maxVolume;
-      this.maxDistance = spatial.maxDistance ?? this.maxDistance;
-    }
-  }
-  onDestroy() {
-    this.sounds.forEach((sound) => {
-      sound.stop();
-      for (let event of EVENTS) {
-        const eventFn = this.eventsFn.find((fn) => fn === this.eventsFn[event]);
-        if (eventFn) {
-          sound.off(event, eventFn);
-        }
-      }
-    });
-    this.sounds = [];
-    this.eventsFn = [];
-    this.tickSubscription?.unsubscribe();
-  }
-};
-var SoundListenerPosition = class extends Directive {
-  onMount(element) {
-    element.props.context.soundListenerPosition = element.propObservables?.soundListenerPosition;
-  }
-  onInit(element) {
-  }
-  onUpdate(props) {
-  }
-  onDestroy() {
-  }
-};
-registerDirective("sound", Sound);
-registerDirective("soundListenerPosition", SoundListenerPosition);
-
-// src/directives/Drag.ts
-import { effect as effect2, isComputed as isComputed2, isSignal as isSignal3 } from "@signe/reactive";
-import { Rectangle, Point } from "pixi.js";
-import { snap } from "popmotion";
-
-// src/hooks/addContext.ts
-var addContext = (element, key, value) => {
-  element.props.context = {
-    ...element.props.context ?? {},
-    [key]: value
-  };
-};
-
-// src/directives/Drag.ts
-var Drop = class extends Directive {
-  constructor() {
-    super(...arguments);
-    this.elementRef = null;
-  }
-  onInit(element) {
-    this.elementRef = element;
-  }
-  onMount(element) {
-    addContext(element, "drop", element);
-  }
-  onUpdate() {
-  }
-  onDestroy() {
-    this.elementRef = null;
-  }
-};
-var Drag = class extends Directive {
-  constructor() {
-    super(...arguments);
-    this.elementRef = null;
-    this.stageRef = null;
-    this.offsetInParent = new Point();
-    this.isDragging = false;
-    this.viewport = null;
-    this.animationFrameId = null;
-    this.lastPointerPosition = new Point();
-    this.pressedKeys = /* @__PURE__ */ new Set();
-    this.pointerIsDown = false;
-    this.onDragMoveHandler = () => {
-    };
-    this.onDragEndHandler = () => {
-    };
-    this.onDragStartHandler = () => {
-    };
-    this.onKeyDownHandler = () => {
-    };
-    this.onKeyUpHandler = () => {
-    };
-    this.subscriptions = [];
-  }
-  onInit(element) {
-    this.elementRef = element;
-    this.onDragMoveHandler = this.onDragMove.bind(this);
-    this.onDragEndHandler = this.onDragEnd.bind(this);
-    this.onDragStartHandler = this.onPointerDown.bind(this);
-    this.onKeyDownHandler = this.onKeyDown.bind(this);
-    this.onKeyUpHandler = this.onKeyUp.bind(this);
-  }
-  onMount(element) {
-    const { rootElement, canvasSize, viewport, tick: tick2 } = element.props.context;
-    const instance = element.componentInstance;
-    const dragProps = this.dragProps;
-    const haveNotProps = Object.keys(dragProps).length === 0;
-    if (haveNotProps) {
-      this.onDestroy();
-      return;
-    }
-    if (!instance) return;
-    this.stageRef = rootElement.componentInstance;
-    if (!this.stageRef) return;
-    this.viewport = viewport;
-    instance.eventMode = "static";
-    this.stageRef.eventMode = "static";
-    const _effect = effect2(() => {
-      if (this.stageRef) {
-        this.stageRef.hitArea = new Rectangle(0, 0, canvasSize().width, canvasSize().height);
-      }
-    });
-    instance.on("pointerdown", this.onDragStartHandler);
-    this.stageRef.on("pointerup", this.onDragEndHandler);
-    this.stageRef.on("pointerupoutside", this.onDragEndHandler);
-    const keysToPress = dragProps.keyToPress ? dragProps.keyToPress : [];
-    window.addEventListener("keydown", this.onKeyDownHandler);
-    window.addEventListener("keyup", this.onKeyUpHandler);
-    this.subscriptions = [
-      tick2.observable.subscribe(() => {
-        if (this.isDragging && this.viewport) {
-          this.updateViewportPosition(this.lastPointerPosition);
-        }
-      }),
-      _effect.subscription
-    ];
-  }
-  get dragProps() {
-    const drag = this.elementRef?.props.drag;
-    const options = useProps(drag?.value ?? drag, {
-      snap: 0,
-      viewport: {},
-      direction: "all",
-      keyToPress: []
-    });
-    options.viewport = useProps(options.viewport, {
-      edgeThreshold: 300,
-      maxSpeed: 40
-    });
-    return options;
-  }
-  get axis() {
-    const direction = this.dragProps.direction();
-    const axis = {
-      x: true,
-      y: true
-    };
-    if (direction === "x") {
-      axis.y = false;
-    }
-    if (direction === "y") {
-      axis.x = false;
-    }
-    return axis;
-  }
-  /**
-   * Updates element position when dragging and starts continuous viewport movement
-   * @param event The pointer event that triggered the drag move
-   */
-  onDragMove(event) {
-    if (!this.isDragging || !this.elementRef?.componentInstance || !this.elementRef.componentInstance.parent) return;
-    const instance = this.elementRef.componentInstance;
-    const parent = instance.parent;
-    const dragProps = this.dragProps;
-    const propObservables = this.elementRef.propObservables;
-    const snapTo = snap(dragProps?.snap() ?? 0);
-    dragProps?.move?.(event);
-    const currentParentLocalPointer = parent.toLocal(event.global);
-    const newX = currentParentLocalPointer.x - this.offsetInParent.x;
-    const newY = currentParentLocalPointer.y - this.offsetInParent.y;
-    if (dragProps?.snap()) {
-      instance.position.x = snapTo(newX);
-      instance.position.y = snapTo(newY);
-    } else {
-      if (this.axis.x) instance.position.x = newX;
-      if (this.axis.y) instance.position.y = newY;
-    }
-    this.lastPointerPosition.copyFrom(event.global);
-    const { x: xProp, y: yProp } = propObservables;
-    const updatePosition = (prop, value) => {
-      if (isComputed2(prop)) {
-        prop.dependencies.forEach((dependency) => {
-          dependency.set(value);
-        });
-      } else if (isSignal3(prop)) {
-        prop.set(value);
-      }
-    };
-    if (xProp !== void 0) updatePosition(xProp, instance.position.x);
-    if (yProp !== void 0) updatePosition(yProp, instance.position.y);
-  }
-  /**
-   * Moves the viewport if the dragged element is near screen edges
-   * @param globalPosition The global pointer position
-   */
-  updateViewportPosition(globalPosition) {
-    if (!this.viewport || !this.elementRef) return;
-    const dragProps = this.dragProps;
-    const edgeThreshold = dragProps?.viewport?.edgeThreshold();
-    const maxSpeed = dragProps?.viewport?.maxSpeed();
-    const screenLeft = 0;
-    const screenRight = this.viewport.screenWidth;
-    const screenTop = 0;
-    const screenBottom = this.viewport.screenHeight;
-    const instance = this.elementRef.componentInstance;
-    const distanceFromLeft = globalPosition.x - screenLeft;
-    const distanceFromRight = screenRight - globalPosition.x;
-    const distanceFromTop = globalPosition.y - screenTop;
-    const distanceFromBottom = screenBottom - globalPosition.y;
-    let moveX = 0;
-    let moveY = 0;
-    if (distanceFromLeft < edgeThreshold) {
-      const velocity = maxSpeed * (1 - distanceFromLeft / edgeThreshold);
-      moveX = -velocity;
-    } else if (distanceFromRight < edgeThreshold) {
-      const velocity = maxSpeed * (1 - distanceFromRight / edgeThreshold);
-      moveX = velocity;
-    }
-    if (distanceFromTop < edgeThreshold) {
-      const velocity = maxSpeed * (1 - distanceFromTop / edgeThreshold);
-      moveY = -velocity;
-    } else if (distanceFromBottom < edgeThreshold) {
-      const velocity = maxSpeed * (1 - distanceFromBottom / edgeThreshold);
-      moveY = velocity;
-    }
-    if (moveX !== 0 || moveY !== 0) {
-      const lastViewValue = this.viewport.center;
-      this.viewport.moveCenter(
-        this.viewport.center.x + moveX,
-        this.viewport.center.y + moveY
-      );
-      if (this.axis.x && lastViewValue.x !== this.viewport.center.x) {
-        instance.position.x += moveX;
-      }
-      if (this.axis.y && lastViewValue.y !== this.viewport.center.y) {
-        instance.position.y += moveY;
-      }
-    }
-  }
-  /**
-   * Handles drag end event and stops viewport movement
-   */
-  onDragEnd() {
-    this.pointerIsDown = false;
-    if (!this.isDragging) return;
-    const dragProps = this.dragProps;
-    this.isDragging = false;
-    dragProps?.end?.();
-    if (this.stageRef) {
-      this.stageRef.off("pointermove", this.onDragMoveHandler);
-    }
-  }
-  onKeyDown(event) {
-    this.pressedKeys.add(event.code);
-    this.pressedKeys.add(event.key.toLowerCase());
-    if (this.pointerIsDown && !this.isDragging && this.areRequiredKeysPressed()) {
-      this.startDrag();
-    }
-  }
-  onKeyUp(event) {
-    this.pressedKeys.delete(event.code);
-    this.pressedKeys.delete(event.key.toLowerCase());
-    if (this.isDragging && !this.areRequiredKeysPressed()) {
-      this.onDragEnd();
-    }
-  }
-  areRequiredKeysPressed() {
-    const keyToPress = this.dragProps.keyToPress ? this.dragProps.keyToPress : [];
-    if (!keyToPress || keyToPress.length === 0) {
-      return true;
-    }
-    return keyToPress.some((key) => {
-      if (this.pressedKeys.has(key)) {
-        return true;
-      }
-      if (key.toLowerCase() === "space") {
-        return this.pressedKeys.has("Space") || this.pressedKeys.has(" ");
-      }
-      if (key.toLowerCase() === "shift") {
-        return this.pressedKeys.has("ShiftLeft") || this.pressedKeys.has("ShiftRight");
-      }
-      if (key.toLowerCase() === "control" || key.toLowerCase() === "ctrl") {
-        return this.pressedKeys.has("ControlLeft") || this.pressedKeys.has("ControlRight");
-      }
-      if (key.toLowerCase() === "alt") {
-        return this.pressedKeys.has("AltLeft") || this.pressedKeys.has("AltRight");
-      }
-      return false;
-    });
-  }
-  onPointerDown(event) {
-    if (!this.elementRef?.componentInstance || !this.stageRef || !this.elementRef.componentInstance.parent) return;
-    this.pointerIsDown = true;
-    const instance = this.elementRef.componentInstance;
-    const parent = instance.parent;
-    const parentLocalPointer = parent.toLocal(event.global);
-    this.offsetInParent.x = parentLocalPointer.x - instance.position.x;
-    this.offsetInParent.y = parentLocalPointer.y - instance.position.y;
-    this.lastPointerPosition.copyFrom(event.global);
-    if (this.areRequiredKeysPressed()) {
-      this.startDrag();
-    }
-  }
-  startDrag() {
-    if (this.isDragging || !this.stageRef) return;
-    this.isDragging = true;
-    const dragProps = this.dragProps;
-    dragProps?.start?.();
-    this.stageRef.on("pointermove", this.onDragMoveHandler);
-  }
-  onUpdate(props) {
-    if (props.type && props.type === "reset") {
-      this.onDestroy();
-      this.onMount(this.elementRef);
-    }
-  }
-  onDestroy() {
-    this.subscriptions.forEach((subscription) => subscription.unsubscribe());
-    const instance = this.elementRef?.componentInstance;
-    if (instance) {
-      instance.off("pointerdown", this.onDragStartHandler);
-    }
-    if (this.stageRef) {
-      this.stageRef.off("pointermove", this.onDragMoveHandler);
-      this.stageRef.off("pointerup", this.onDragEndHandler);
-      this.stageRef.off("pointerupoutside", this.onDragEndHandler);
-    }
-    window.removeEventListener("keydown", this.onKeyDownHandler);
-    window.removeEventListener("keyup", this.onKeyUpHandler);
-    this.stageRef = null;
-    this.viewport = null;
-    this.pressedKeys.clear();
-    this.pointerIsDown = false;
-  }
-};
-registerDirective("drag", Drag);
-registerDirective("drop", Drop);
-
-// src/directives/Transition.ts
-import { DisplacementFilter, Sprite, Texture, WRAP_MODES } from "pixi.js";
-import { animate } from "popmotion";
-var Transition = class extends Directive {
-  onInit(element) {
-  }
-  onMount(element) {
-    const { image } = element.props.transition;
-    const displacementSprite = new Sprite(Texture.from(image));
-    displacementSprite.texture.baseTexture.wrapMode = WRAP_MODES.REPEAT;
-    const displacementFilter = new DisplacementFilter(displacementSprite);
-    const instance = element.componentInstance;
-    instance.filters = [displacementFilter];
-    instance.addChild(displacementSprite);
-    setTimeout(() => {
-      animate({
-        from: 0,
-        to: 1,
-        duration: 500,
-        onUpdate: (progress) => {
-          displacementFilter.scale.x = progress;
-          displacementFilter.scale.y = progress;
-        }
-      });
-    }, 5e3);
-  }
-  onUpdate(props) {
-  }
-  onDestroy() {
-  }
-};
-registerDirective("transition", Transition);
-
-// src/index.ts
-export * from "@signe/reactive";
-import { Howler } from "howler";
-
-// src/components/Canvas.ts
-import { effect as effect3, signal as signal5 } from "@signe/reactive";
-import { Container as Container3 } from "pixi.js";
-
-// src/components/DisplayObject.ts
-import { signal as signal4 } from "@signe/reactive";
-import { BlurFilter, ObservablePoint } from "pixi.js";
-
-// src/utils/functions.ts
-function isPercent(value) {
-  if (!value) return false;
-  if (typeof value === "string") {
-    return value.endsWith("%");
-  }
-  return false;
-}
-
-// src/components/DisplayObject.ts
-import { BehaviorSubject } from "rxjs";
-var EVENTS2 = [
-  "added",
-  "childAdded",
-  "childRemoved",
-  "click",
-  "clickcapture",
-  "destroyed",
-  "globalmousemove",
-  "globalpointermove",
-  "globaltouchmove",
-  "mousedown",
-  "mousedowncapture",
-  "mouseenter",
-  "mouseentercapture",
-  "mouseleave",
-  "mouseleavecapture",
-  "mousemove",
-  "mousemovecapture",
-  "mouseout",
-  "mouseoutcapture",
-  "mouseover",
-  "mouseovercapture",
-  "mouseup",
-  "mouseupcapture",
-  "mouseupoutside",
-  "mouseupoutsidecapture",
-  "pointercancel",
-  "pointercancelcapture",
-  "pointerdown",
-  "pointerdowncapture",
-  "pointerenter",
-  "pointerentercapture",
-  "pointerleave",
-  "pointerleavecapture",
-  "pointermove",
-  "pointermovecapture",
-  "pointerout",
-  "pointeroutcapture",
-  "pointerover",
-  "pointerovercapture",
-  "pointertap",
-  "pointertapcapture",
-  "pointerup",
-  "pointerupcapture",
-  "pointerupoutside",
-  "pointerupoutsidecapture",
-  "removed",
-  "rightclick",
-  "rightclickcapture",
-  "rightdown",
-  "rightdowncapture",
-  "rightup",
-  "rightupcapture",
-  "rightupoutside",
-  "rightupoutsidecapture",
-  "tap",
-  "tapcapture",
-  "touchcancel",
-  "touchcancelcapture",
-  "touchend",
-  "touchendcapture",
-  "touchendoutside",
-  "touchendoutsidecapture",
-  "touchmove",
-  "touchmovecapture",
-  "touchstart",
-  "touchstartcapture",
-  "wheel",
-  "wheelcapture"
-];
-function DisplayObject(extendClass) {
-  var _canvasContext, _a;
-  return _a = class extends extendClass {
-    constructor() {
-      super(...arguments);
-      __privateAdd(this, _canvasContext, null);
-      this.isFlex = false;
-      this.fullProps = {};
-      this.isMounted = false;
-      this._anchorPoints = new ObservablePoint({ _onUpdate: () => {
-      } }, 0, 0);
-      this.isCustomAnchor = false;
-      this.displayWidth = signal4(0);
-      this.displayHeight = signal4(0);
-      this.overrideProps = [];
-      this.layout = null;
-      this.onBeforeDestroy = null;
-      this.onAfterMount = null;
-      this.subjectInit = new BehaviorSubject(null);
-      this.disableLayout = false;
-    }
-    get deltaRatio() {
-      return __privateGet(this, _canvasContext)?.scheduler?.tick.value.deltaRatio;
-    }
-    get parentIsFlex() {
-      if (this.disableLayout) return false;
-      return this.parent?.isFlex;
-    }
-    onInit(props) {
-      this._id = props.id;
-      for (let event of EVENTS2) {
-        if (props[event] && !this.overrideProps.includes(event)) {
-          this.eventMode = "static";
-          this.on(event, props[event]);
-        }
-      }
-      if (props.onBeforeDestroy || props["on-before-destroy"]) {
-        this.onBeforeDestroy = props.onBeforeDestroy || props["on-before-destroy"];
-      }
-      if (props.onAfterMount || props["on-after-mount"]) {
-        this.onAfterMount = props.onAfterMount || props["on-after-mount"];
-      }
-      if (props.justifyContent || props.alignItems || props.flexDirection || props.flexWrap || props.alignContent || props.display == "flex" || isPercent(props.width) || isPercent(props.height) || props.isRoot) {
-        this.layout = {};
-        this.isFlex = true;
-      }
-      this.subjectInit.next(this);
-    }
-    async onMount({ parent, props }, index) {
-      __privateSet(this, _canvasContext, props.context);
-      if (parent) {
-        const instance = parent.componentInstance;
-        if (instance.isFlex && !this.layout && !this.disableLayout) {
-          try {
-            this.layout = {};
-          } catch (error2) {
-            console.warn("Failed to set layout:", error2);
-          }
-        }
-        if (index === void 0) {
-          instance.addChild(this);
-        } else {
-          instance.addChildAt(this, index);
-        }
-        this.isMounted = true;
-        this.onUpdate(props);
-        if (this.onAfterMount) {
-          await this.onAfterMount();
-        }
-      }
-    }
-    onUpdate(props) {
-      this.fullProps = {
-        ...this.fullProps,
-        ...props
-      };
-      if (!__privateGet(this, _canvasContext) || !this.parent) return;
-      if (props.x !== void 0) this.setX(props.x);
-      if (props.y !== void 0) this.setY(props.y);
-      if (props.scale !== void 0)
-        setObservablePoint(this.scale, props.scale);
-      if (props.anchor !== void 0 && !this.isCustomAnchor) {
-        setObservablePoint(this.anchor, props.anchor);
-      }
-      if (props.width !== void 0) this.setWidth(props.width);
-      if (props.height !== void 0) this.setHeight(props.height);
-      if (props.minWidth !== void 0) this.setMinWidth(props.minWidth);
-      if (props.minHeight !== void 0) this.setMinHeight(props.minHeight);
-      if (props.maxWidth !== void 0) this.setMaxWidth(props.maxWidth);
-      if (props.maxHeight !== void 0) this.setMaxHeight(props.maxHeight);
-      if (props.aspectRatio !== void 0)
-        this.setAspectRatio(props.aspectRatio);
-      if (props.flexGrow !== void 0) this.setFlexGrow(props.flexGrow);
-      if (props.flexShrink !== void 0) this.setFlexShrink(props.flexShrink);
-      if (props.flexBasis !== void 0) this.setFlexBasis(props.flexBasis);
-      if (props.rowGap !== void 0) this.setRowGap(props.rowGap);
-      if (props.columnGap !== void 0) this.setColumnGap(props.columnGap);
-      if (props.top !== void 0) this.setTop(props.top);
-      if (props.left !== void 0) this.setLeft(props.left);
-      if (props.right !== void 0) this.setRight(props.right);
-      if (props.bottom !== void 0) this.setBottom(props.bottom);
-      if (props.objectFit !== void 0) this.setObjectFit(props.objectFit);
-      if (props.objectPosition !== void 0)
-        this.setObjectPosition(props.objectPosition);
-      if (props.transformOrigin !== void 0)
-        this.setTransformOrigin(props.transformOrigin);
-      if (props.skew !== void 0) setObservablePoint(this.skew, props.skew);
-      if (props.tint) this.tint = props.tint;
-      if (props.rotation !== void 0) this.rotation = props.rotation;
-      if (props.angle !== void 0) this.angle = props.angle;
-      if (props.zIndex !== void 0) this.zIndex = props.zIndex;
-      if (props.roundPixels !== void 0) this.roundPixels = props.roundPixels;
-      if (props.cursor) this.cursor = props.cursor;
-      if (props.visible !== void 0) this.visible = props.visible;
-      if (props.alpha !== void 0) this.alpha = props.alpha;
-      if (props.pivot) setObservablePoint(this.pivot, props.pivot);
-      if (props.flexDirection) this.setFlexDirection(props.flexDirection);
-      if (props.flexWrap) this.setFlexWrap(props.flexWrap);
-      if (props.justifyContent) this.setJustifyContent(props.justifyContent);
-      if (props.alignItems) this.setAlignItems(props.alignItems);
-      if (props.alignContent) this.setAlignContent(props.alignContent);
-      if (props.alignSelf) this.setAlignSelf(props.alignSelf);
-      if (props.margin) this.setMargin(props.margin);
-      if (props.padding) this.setPadding(props.padding);
-      if (props.gap) this.setGap(props.gap);
-      if (props.border) this.setBorder(props.border);
-      if (props.positionType) this.setPositionType(props.positionType);
-      if (props.filters) this.filters = props.filters;
-      if (props.maskOf) {
-        if (isElement(props.maskOf)) {
-          props.maskOf.componentInstance.mask = this;
-        }
-      }
-      if (props.blendMode) this.blendMode = props.blendMode;
-      if (props.filterArea) this.filterArea = props.filterArea;
-      const currentFilters = this.filters || [];
-      if (props.blur) {
-        let blurFilter = currentFilters.find(
-          (filter2) => filter2 instanceof BlurFilter
-        );
-        if (!blurFilter) {
-          const options = typeof props.blur === "number" ? {
-            strength: props.blur
-          } : props.blur;
-          blurFilter = new BlurFilter(options);
-          currentFilters.push(blurFilter);
-        }
-        Object.assign(blurFilter, props.blur);
-      }
-      this.filters = currentFilters;
-    }
-    async onDestroy(parent, afterDestroy) {
-      if (this.onBeforeDestroy) {
-        await this.onBeforeDestroy();
-      }
-      super.destroy();
-      if (afterDestroy) afterDestroy();
-    }
-    setFlexDirection(direction) {
-      this.layout = { flexDirection: direction };
-    }
-    setFlexWrap(wrap) {
-      this.layout = { flexWrap: wrap };
-    }
-    setAlignContent(align) {
-      this.layout = { alignContent: align };
-    }
-    setAlignSelf(align) {
-      this.layout = { alignSelf: align };
-    }
-    setAlignItems(align) {
-      this.layout = { alignItems: align };
-    }
-    setJustifyContent(justifyContent) {
-      this.layout = { justifyContent };
-    }
-    setPosition(position) {
-      if (position instanceof Array) {
-        if (position.length === 2) {
-          this.layout = {
-            positionY: position[0],
-            positionX: position[1]
-          };
-        } else if (position.length === 4) {
-          this.layout = {
-            positionTop: position[0],
-            positionRight: position[1],
-            positionBottom: position[2],
-            positionLeft: position[3]
-          };
-        }
-      } else {
-        this.layout = { position };
-      }
-    }
-    setX(x) {
-      x = x + this.getWidth() * this._anchorPoints.x;
-      if (!this.parentIsFlex) {
-        this.x = x;
-      } else {
-        this.x = x;
-        this.layout = { x };
-      }
-    }
-    setY(y) {
-      y = y + this.getHeight() * this._anchorPoints.y;
-      if (!this.parentIsFlex) {
-        this.y = y;
-      } else {
-        this.y = y;
-        this.layout = { y };
-      }
-    }
-    setPadding(padding) {
-      if (padding instanceof Array) {
-        if (padding.length === 2) {
-          this.layout = {
-            paddingVertical: padding[0],
-            paddingHorizontal: padding[1]
-          };
-        } else if (padding.length === 4) {
-          this.layout = {
-            paddingTop: padding[0],
-            paddingRight: padding[1],
-            paddingBottom: padding[2],
-            paddingLeft: padding[3]
-          };
-        }
-      } else {
-        this.layout = { padding };
-      }
-    }
-    setMargin(margin) {
-      if (margin instanceof Array) {
-        if (margin.length === 2) {
-          this.layout = {
-            marginVertical: margin[0],
-            marginHorizontal: margin[1]
-          };
-        } else if (margin.length === 4) {
-          this.layout = {
-            marginTop: margin[0],
-            marginRight: margin[1],
-            marginBottom: margin[2],
-            marginLeft: margin[3]
-          };
-        }
-      } else {
-        this.layout = { margin };
-      }
-    }
-    setGap(gap) {
-      this.layout = { gap };
-    }
-    setBorder(border) {
-      if (border instanceof Array) {
-        if (border.length === 2) {
-          this.layout = {
-            borderVertical: border[0],
-            borderHorizontal: border[1]
-          };
-        } else if (border.length === 4) {
-          this.layout = {
-            borderTop: border[0],
-            borderRight: border[1],
-            borderBottom: border[2],
-            borderLeft: border[3]
-          };
-        }
-      } else {
-        this.layout = { border };
-      }
-    }
-    setPositionType(positionType) {
-      this.layout = { position: positionType };
-    }
-    setWidth(width) {
-      this.displayWidth.set(width);
-      if (!this.parentIsFlex) {
-        this.width = width;
-      } else {
-        this.layout = { width };
-      }
-    }
-    setHeight(height) {
-      this.displayHeight.set(height);
-      if (!this.parentIsFlex) {
-        this.height = height;
-      } else {
-        this.layout = { height };
-      }
-    }
-    getWidth() {
-      return this.displayWidth();
-    }
-    getHeight() {
-      return this.displayHeight();
-    }
-    // Min/Max constraints
-    setMinWidth(minWidth) {
-      this.layout = { minWidth };
-    }
-    setMinHeight(minHeight) {
-      this.layout = { minHeight };
-    }
-    setMaxWidth(maxWidth) {
-      this.layout = { maxWidth };
-    }
-    setMaxHeight(maxHeight) {
-      this.layout = { maxHeight };
-    }
-    // Aspect ratio
-    setAspectRatio(aspectRatio) {
-      this.layout = { aspectRatio };
-    }
-    // Flex properties
-    setFlexGrow(flexGrow) {
-      this.layout = { flexGrow };
-    }
-    setFlexShrink(flexShrink) {
-      this.layout = { flexShrink };
-    }
-    setFlexBasis(flexBasis) {
-      this.layout = { flexBasis };
-    }
-    // Gap properties
-    setRowGap(rowGap) {
-      this.layout = { rowGap };
-    }
-    setColumnGap(columnGap) {
-      this.layout = { columnGap };
-    }
-    // Position insets
-    setTop(top) {
-      this.layout = { top };
-    }
-    setLeft(left) {
-      this.layout = { left };
-    }
-    setRight(right) {
-      this.layout = { right };
-    }
-    setBottom(bottom) {
-      this.layout = { bottom };
-    }
-    // Object properties
-    setObjectFit(objectFit) {
-      this.layout = { objectFit };
-    }
-    setObjectPosition(objectPosition) {
-      this.layout = { objectPosition };
-    }
-    setTransformOrigin(transformOrigin) {
-      this.layout = { transformOrigin };
-    }
-  }, _canvasContext = new WeakMap(), _a;
-}
-
-// src/components/Canvas.ts
-registerComponent("Canvas", class Canvas extends DisplayObject(Container3) {
-});
-var Canvas2 = async (props = {}) => {
-  let { cursorStyles, width, height, class: className } = useProps(props);
-  if (!props.width) width = signal5(800);
-  if (!props.height) height = signal5(600);
-  const canvasSize = signal5({
-    width: 0,
-    height: 0
-  });
-  props.isRoot = true;
-  const options = {
-    ...props,
-    context: {
-      canvasSize,
-      app: signal5(null)
-    },
-    width: width?.(),
-    height: height?.()
-  };
-  if (!props.tick) {
-    options.context.tick = options.tick = signal5({
-      timestamp: 0,
-      deltaTime: 0,
-      frame: 0,
-      deltaRatio: 1
-    });
-  }
-  const canvasElement = createComponent("Canvas", options);
-  canvasElement.render = (rootElement, app) => {
-    if (!app) {
-      return;
-    }
-    const renderer = app.renderer;
-    const canvasEl = renderer.view.canvas;
-    globalThis.__PIXI_STAGE__ = canvasElement.componentInstance;
-    globalThis.__PIXI_RENDERER__ = renderer;
-    if (props.tickStart !== false) canvasElement.directives.tick.start();
-    effect3(() => {
-      canvasElement.propObservables.tick();
-      renderer.render(canvasElement.componentInstance);
-    });
-    app.stage = canvasElement.componentInstance;
-    app.stage.layout = {
-      width: app.screen.width,
-      height: app.screen.height,
-      justifyContent: props.justifyContent,
-      alignItems: props.alignItems
-    };
-    canvasSize.set({ width: app.screen.width, height: app.screen.height });
-    app.renderer.on("resize", (width2, height2) => {
-      canvasSize.set({ width: width2, height: height2 });
-      if (app.stage.layout) {
-        app.stage.layout = {
-          width: width2,
-          height: height2
-        };
-      }
-    });
-    if (props.tickStart !== false) canvasElement.directives.tick.start();
-    app.ticker.add(() => {
-      canvasElement.propObservables.tick();
-    });
-    if (cursorStyles) {
-      effect3(() => {
-        renderer.events.cursorStyles = cursorStyles();
-      });
-    }
-    if (className) {
-      effect3(() => {
-        canvasEl.classList.add(className());
-      });
-    }
-    const existingCanvas = rootElement.querySelector("canvas");
-    if (existingCanvas) {
-      rootElement.replaceChild(canvasEl, existingCanvas);
-    } else {
-      rootElement.appendChild(canvasEl);
-    }
-    options.context.app.set(app);
-  };
-  return canvasElement;
-};
-
-// src/components/Container.ts
-import { Container as PixiContainer } from "pixi.js";
-var CanvasContainer = class extends DisplayObject(PixiContainer) {
-  constructor() {
-    super(...arguments);
-    this.isCustomAnchor = true;
-  }
-  onUpdate(props) {
-    if (props.anchor) {
-      setObservablePoint(this._anchorPoints, props.anchor);
-      props.pivot = [
-        this.getWidth() * this._anchorPoints.x,
-        this.getHeight() * this._anchorPoints.y
-      ];
-    }
-    super.onUpdate(props);
-    if (props.sortableChildren != void 0) {
-      this.sortableChildren = props.sortableChildren;
-    }
-  }
-  async onMount(args) {
-    await super.onMount(args);
-    const { componentInstance, props } = args;
-    const { pixiChildren } = props;
-    if (pixiChildren) {
-      pixiChildren.forEach((child) => {
-        componentInstance.addChild(child);
-      });
-    }
-  }
-};
-registerComponent("Container", CanvasContainer);
-var Container4 = (props) => {
-  return createComponent("Container", props);
-};
-
-// src/components/Graphic.ts
-import { effect as effect4, isSignal as isSignal4, signal as signal6 } from "@signe/reactive";
-import { Assets, Graphics as PixiGraphics } from "pixi.js";
-var CanvasGraphics = class extends DisplayObject(PixiGraphics) {
-  /**
-   * Initializes the graphics component with reactive width and height handling.
-   * 
-   * This method handles different types of width and height props:
-   * - **Numbers**: Direct pixel values
-   * - **Strings with %**: Percentage values that trigger flex layout and use layout box dimensions
-   * - **Signals**: Reactive values that update automatically
-   * 
-   * When percentage values are detected, the component:
-   * 1. Sets `display: 'flex'` to enable layout calculations
-   * 2. Listens to layout events to get computed dimensions
-   * 3. Updates internal width/height signals with layout box values
-   * 
-   * The draw function receives the reactive width and height signals as parameters.
-   * 
-   * @param props - Component properties including width, height, and draw function
-   * @example
-   * ```typescript
-   * // With pixel values
-   * Graphics({ width: 100, height: 50, draw: (g, w, h) => g.rect(0, 0, w(), h()) });
-   * 
-   * // With percentage values (uses layout box)
-   * Graphics({ width: "50%", height: "100%", draw: (g, w, h) => g.rect(0, 0, w(), h()) });
-   * 
-   * // With signals
-   * const width = signal(100);
-   * Graphics({ width, height: 50, draw: (g, w, h) => g.rect(0, 0, w(), h()) });
-   * ```
-   */
-  async onInit(props) {
-    await super.onInit(props);
-  }
-  /**
-   * Called when the component is mounted to the scene graph.
-   * Creates the reactive effect for drawing using the original signals from propObservables.
-   * @param {Element<DisplayObject>} element - The element being mounted with props and propObservables.
-   * @param {number} [index] - The index of the component among its siblings.
-   */
-  async onMount(element, index) {
-    await super.onMount(element, index);
-    const { props, propObservables } = element;
-    const width = isSignal4(propObservables?.width) ? propObservables.width : signal6(props.width || 0);
-    const height = isSignal4(propObservables?.height) ? propObservables.height : signal6(props.height || 0);
-    this.width = width;
-    this.height = height;
-    const isWidthPercentage = isPercent(width());
-    const isHeightPercentage = isPercent(height());
-    if (props.draw) {
-      this.clearEffect = effect4(() => {
-        const w = width();
-        const h2 = height();
-        if (typeof w == "string" || typeof h2 == "string") {
-          return;
-        }
-        if (w == 0 || h2 == 0) {
-          return;
-        }
-        this.clear();
-        props.draw?.(this, w, h2);
-        this.subjectInit.next(this);
-      });
-    }
-    this.on("layout", (event) => {
-      const layoutBox = event.computedLayout;
-      if (isWidthPercentage && isSignal4(width)) {
-        width.set(layoutBox.width);
-      }
-      if (isHeightPercentage && isSignal4(height)) {
-        height.set(layoutBox.height);
-      }
-    });
-  }
-  /**
-   * Called when component props are updated.
-   * Updates the internal width and height signals when props change.
-   * @param props - Updated properties
-   */
-  onUpdate(props) {
-    super.onUpdate(props);
-    if (props.width !== void 0 && this.width) {
-      if (isSignal4(props.width)) {
-        this.width = props.width;
-      } else {
-        this.width.set(props.width);
-      }
-    }
-    if (props.height !== void 0 && this.height) {
-      if (isSignal4(props.height)) {
-        this.height = props.height;
-      } else {
-        this.height.set(props.height);
-      }
-    }
-  }
-  /**
-   * Called when the component is about to be destroyed.
-   * This method should be overridden by subclasses to perform any cleanup.
-   * It ensures that the clearEffect subscription is unsubscribed before calling the original afterDestroy callback.
-   * @param parent The parent element.
-   * @param afterDestroy A callback function to be executed after the component's own destruction logic.
-   * @example
-   * // This method is typically called by the engine internally.
-   * // await component.onDestroy(parentElement, () => console.log('Component destroyed'));
-   */
-  async onDestroy(parent, afterDestroy) {
-    const _afterDestroyCallback = async () => {
-      this.clearEffect.subscription.unsubscribe();
-      afterDestroy();
-    };
-    await super.onDestroy(parent, _afterDestroyCallback);
-  }
-};
-registerComponent("Graphics", CanvasGraphics);
-function Graphics(props) {
-  return createComponent("Graphics", props);
-}
-function Rect(props) {
-  const { color, borderRadius, border } = useProps(props, {
-    borderRadius: null,
-    border: null
-  });
-  return Graphics({
-    draw: (g, width, height) => {
-      if (borderRadius()) {
-        g.roundRect(0, 0, width, height, borderRadius());
-      } else {
-        g.rect(0, 0, width, height);
-      }
-      if (border) {
-        g.stroke(border);
-      }
-      g.fill(color());
-    },
-    ...props
-  });
-}
-function drawShape(g, shape, props) {
-  const { color, border } = props;
-  if ("radius" in props) {
-    g.circle(0, 0, props.radius());
-  } else {
-    g.ellipse(0, 0, props.width() / 2, props.height() / 2);
-  }
-  if (border()) {
-    g.stroke(border());
-  }
-  g.fill(color());
-}
-function Circle(props) {
-  const { radius, color, border } = useProps(props, {
-    border: null
-  });
-  return Graphics({
-    draw: (g) => drawShape(g, "circle", { radius, color, border }),
-    ...props
-  });
-}
-function Ellipse(props) {
-  const { width, height, color, border } = useProps(props, {
-    border: null
-  });
-  return Graphics({
-    draw: (g, gWidth, gHeight) => drawShape(g, "ellipse", { width: signal6(gWidth), height: signal6(gHeight), color, border }),
-    ...props
-  });
-}
-function Triangle(props) {
-  const { width, height, color, border } = useProps(props, {
-    border: null,
-    color: "#000"
-  });
-  return Graphics({
-    draw: (g, gWidth, gHeight) => {
-      g.moveTo(0, gHeight);
-      g.lineTo(gWidth / 2, 0);
-      g.lineTo(gWidth, gHeight);
-      g.lineTo(0, gHeight);
-      g.fill(color());
-      if (border) {
-        g.stroke(border);
-      }
-    },
-    ...props
-  });
-}
-function Svg(props) {
-  return Graphics({
-    draw: async (g) => {
-      if (props.src) {
-        const svgData = await Assets.load({
-          src: props.src,
-          data: {
-            parseAsGraphicsContext: true
-          }
-        });
-        const graphics = new PixiGraphics(svgData);
-        g.context = graphics.context;
-      } else if (props.content) {
-        g.svg(props.content);
-      } else if (props.svg) {
-        g.svg(props.svg);
-      }
-    },
-    ...props
-  });
-}
-
-// src/components/Mesh.ts
-import { Mesh as PixiMesh, Geometry, Assets as Assets2 } from "pixi.js";
-var CanvasMesh = class extends DisplayObject(PixiMesh) {
-  /**
-   * Constructor for the CanvasMesh component.
-   * Initializes the PixiMesh with default geometry and shader to prevent errors.
-   * 
-   * @example
-   * ```typescript
-   * // This constructor is called internally by the engine
-   * const mesh = new CanvasMesh();
-   * ```
-   */
-  constructor() {
-    super({
-      geometry: new Geometry()
-    });
-  }
-  /**
-   * Initializes the mesh component with the provided properties.
-   * This method is called before onUpdate to set up initial state.
-   * 
-   * @param props - The initial properties
-   * @example
-   * ```typescript
-   * // This method is called internally when the component is created
-   * mesh.onInit({
-   *   geometry: myGeometry,
-   *   texture: "texture.png"
-   * });
-   * ```
-   */
-  onInit(props) {
-    super.onInit(props);
-    if (props.geometry) {
-      try {
-        this.geometry = props.geometry;
-      } catch (error2) {
-        console.warn("Failed to set geometry:", error2);
-      }
-    }
-    if (props.shader) {
-      this.shader = props.shader;
-    }
-  }
-  /**
-   * Updates the mesh component when properties change.
-   * Handles texture loading, shader updates, and other property changes.
-   * 
-   * @param props - The updated properties
-   * @example
-   * ```typescript
-   * // This method is called internally when props change
-   * mesh.onUpdate({
-   *   tint: 0x00ff00,
-   *   texture: "new-texture.png"
-   * });
-   * ```
-   */
-  async onUpdate(props) {
-    super.onUpdate(props);
-    if (props.geometry) {
-      try {
-        this.geometry = props.geometry;
-      } catch (error2) {
-        console.warn("Failed to update geometry:", error2);
-      }
-    }
-    if (props.shader) {
-      this.shader = props.shader;
-    }
-    if (props.texture) {
-      if (typeof props.texture === "string") {
-        this.texture = await Assets2.load(props.texture);
-      } else {
-        this.texture = props.texture;
-      }
-    } else if (props.image) {
-      this.texture = await Assets2.load(props.image);
-    }
-    if (props.tint !== void 0) {
-      this.tint = props.tint;
-    }
-    if (props.blendMode !== void 0) {
-      this.blendMode = props.blendMode;
-    }
-    if (props.roundPixels !== void 0) {
-      this.roundPixels = props.roundPixels;
-    }
-  }
-  /**
-   * Called when the component is about to be destroyed.
-   * Cleans up the draw effect subscription and calls the parent destroy method.
-   * 
-   * @param parent - The parent element
-   * @param afterDestroy - Callback function to execute after destruction
-   * @example
-   * ```typescript
-   * // This method is typically called by the engine internally
-   * await mesh.onDestroy(parentElement, () => console.log('Mesh destroyed'));
-   * ```
-   */
-  async onDestroy(parent, afterDestroy) {
-    const _afterDestroyCallback = async () => {
-      afterDestroy();
-    };
-    await super.onDestroy(parent, _afterDestroyCallback);
-  }
-};
-registerComponent("Mesh", CanvasMesh);
-var Mesh = (props) => {
-  return createComponent("Mesh", props);
-};
-
-// src/engine/signal.ts
-var currentSubscriptionsTracker = null;
-var mountTracker = null;
-function mount(fn) {
-  mountTracker?.(fn);
-}
-function tick(fn) {
-  mount((el) => {
-    const { context } = el.props;
-    let subscription;
-    if (context.tick) {
-      subscription = context.tick.observable.subscribe(({ value }) => {
-        fn(value, el);
-      });
-    }
-    return () => {
-      subscription?.unsubscribe();
-    };
-  });
-}
-function h(componentFunction, props = {}, ...children) {
-  const allSubscriptions = /* @__PURE__ */ new Set();
-  const allMounts = /* @__PURE__ */ new Set();
-  currentSubscriptionsTracker = (subscription) => {
-    allSubscriptions.add(subscription);
-  };
-  mountTracker = (fn) => {
-    allMounts.add(fn);
-  };
-  if (children[0] instanceof Array) {
-    children = children[0];
-  }
-  let component = componentFunction({ ...props, children });
-  if (!component) {
-    component = {};
-  }
-  component.effectSubscriptions = Array.from(allSubscriptions);
-  component.effectMounts = [
-    ...Array.from(allMounts),
-    ...component.effectMounts ?? []
-  ];
-  if (component instanceof Promise) {
-    component.then((component2) => {
-      if (component2.props.isRoot) {
-        allMounts.forEach((fn) => fn(component2));
-      }
-    });
-  }
-  currentSubscriptionsTracker = null;
-  mountTracker = null;
-  return component;
-}
-
-// src/components/Scene.ts
-function Scene(props) {
-  return h(Container4);
-}
-
-// src/components/ParticleEmitter.ts
-import * as particles from "@barvynkoa/particle-emitter";
-var CanvasParticlesEmitter = class extends CanvasContainer {
-  constructor() {
-    super(...arguments);
-    this.elapsed = Date.now();
-  }
-  async onMount(params) {
-    await super.onMount(params);
-    const { props } = params;
-    const tick2 = props.context.tick;
-    this.emitter = new particles.Emitter(this, props.config);
-    this.subscriptionTick = tick2.observable.subscribe((value) => {
-      if (!this.emitter) return;
-      const now = Date.now();
-      this.emitter.update((now - this.elapsed) * 1e-3);
-      this.elapsed = now;
-    });
-  }
-  onUpdate(props) {
-  }
-  async onDestroy(parent, afterDestroy) {
-    const _afterDestroy = async () => {
-      this.emitter?.destroy();
-      this.emitter = null;
-      this.subscriptionTick.unsubscribe();
-      afterDestroy();
-    };
-    await super.onDestroy(parent, _afterDestroy);
-  }
-};
-registerComponent("ParticlesEmitter", CanvasParticlesEmitter);
-function ParticlesEmitter(props) {
-  return createComponent("ParticlesEmitter", props);
-}
-
-// src/components/Sprite.ts
-import { Howl as Howl2 } from "howler";
-import { computed, effect as effect6, isSignal as isSignal5 } from "@signe/reactive";
-import {
-  Assets as Assets3,
-  Container as Container5,
-  Sprite as PixiSprite,
-  Rectangle as Rectangle2,
-  Texture as Texture3
-} from "pixi.js";
-
-// src/engine/animation.ts
-import { effect as effect5, signal as signal7 } from "@signe/reactive";
-import { animate as animatePopmotion } from "popmotion";
-function isAnimatedSignal(signal10) {
-  return signal10.animatedState !== void 0;
-}
-function animatedSignal(initialValue, options = {}) {
-  const state = {
-    current: initialValue,
-    start: initialValue,
-    end: initialValue
-  };
-  let animation;
-  const publicSignal = signal7(initialValue);
-  const privateSignal = signal7(state);
-  effect5(() => {
-    const currentState = privateSignal();
-    publicSignal.set(currentState.current);
-  });
-  function animatedSignal2(newValue, animationConfig = {}) {
-    if (newValue === void 0) {
-      return privateSignal();
-    }
-    const prevState = privateSignal();
-    const newState = {
-      current: prevState.current,
-      start: prevState.current,
-      end: newValue
-    };
-    privateSignal.set(newState);
-    if (animation) {
-      animation.stop();
-    }
-    animation = animatePopmotion({
-      // TODO
-      duration: 20,
-      ...options,
-      ...animationConfig,
-      from: prevState.current,
-      to: newValue,
-      onUpdate: (value) => {
-        privateSignal.update((s) => ({ ...s, current: value }));
-        if (options.onUpdate) {
-          options.onUpdate(value);
-        }
-      }
-    });
-  }
-  const fn = function() {
-    return privateSignal().current;
-  };
-  for (const key in publicSignal) {
-    fn[key] = publicSignal[key];
-  }
-  fn.animatedState = privateSignal;
-  fn.update = (updater) => {
-    animatedSignal2(updater(privateSignal().current));
-  };
-  fn.set = async (newValue, animationConfig = {}) => {
-    return new Promise((resolve) => {
-      animatedSignal2(newValue, {
-        ...animationConfig,
-        onComplete: resolve
-      });
-    });
-  };
-  return fn;
-}
-async function animatedSequence(sequence) {
-  for (const item of sequence) {
-    if (Array.isArray(item)) {
-      await Promise.all(item.map((fn) => fn()));
-    } else {
-      await item();
-    }
-  }
-}
-
-// src/components/Sprite.ts
-var log2 = console.log;
-var CanvasSprite = class extends DisplayObject(PixiSprite) {
-  constructor() {
-    super(...arguments);
-    this.currentAnimation = null;
-    this.time = 0;
-    this.frameIndex = 0;
-    this.animations = /* @__PURE__ */ new Map();
-    this.subscriptionSheet = [];
-    this.sheetParams = {};
-    this.sheetCurrentAnimation = "stand" /* Stand */;
-    this.app = null;
-    this.currentAnimationContainer = null;
-  }
-  get renderer() {
-    return this.app?.renderer;
-  }
-  async createTextures(options) {
-    const { width, height, framesHeight, framesWidth, image, offset } = options;
-    if (!image || typeof image !== "string" || image.trim() === "") {
-      console.warn("Invalid image path provided to createTextures:", image);
-      return [];
-    }
-    const texture = await Assets3.load(image);
-    const spriteWidth = options.spriteWidth;
-    const spriteHeight = options.spriteHeight;
-    const frames = [];
-    const offsetX = offset && offset.x || 0;
-    const offsetY = offset && offset.y || 0;
-    for (let i = 0; i < framesHeight; i++) {
-      frames[i] = [];
-      for (let j = 0; j < framesWidth; j++) {
-        const rectX = j * spriteWidth + offsetX;
-        const rectY = i * spriteHeight + offsetY;
-        if (rectY > height) {
-          throw log2(
-            `Warning, there is a problem with the height of the "${this.id}" spritesheet. When cutting into frames, the frame exceeds the height of the image.`
-          );
-        }
-        if (rectX > width) {
-          throw log2(
-            `Warning, there is a problem with the width of the "${this.id}" spritesheet. When cutting into frames, the frame exceeds the width of the image.`
-          );
-        }
-        frames[i].push(
-          new Texture3({
-            source: texture.source,
-            frame: new Rectangle2(rectX, rectY, spriteWidth, spriteHeight)
-          })
-        );
-      }
-    }
-    return frames;
-  }
-  async createAnimations() {
-    const { textures } = this.spritesheet;
-    if (!textures) {
-      return;
-    }
-    for (let animationName in textures) {
-      const props = [
-        "width",
-        "height",
-        "framesHeight",
-        "framesWidth",
-        "rectWidth",
-        "rectHeight",
-        "offset",
-        "image",
-        "sound"
-      ];
-      const parentObj = props.reduce(
-        (prev, val) => ({ ...prev, [val]: this.spritesheet[val] }),
-        {}
-      );
-      const optionsTextures = {
-        ...parentObj,
-        ...textures[animationName]
-      };
-      const {
-        rectWidth,
-        width = 0,
-        framesWidth = 1,
-        rectHeight,
-        height = 0,
-        framesHeight = 1
-      } = optionsTextures;
-      optionsTextures.spriteWidth = rectWidth ? rectWidth : width / framesWidth;
-      optionsTextures.spriteHeight = rectHeight ? rectHeight : height / framesHeight;
-      this.animations.set(animationName, {
-        frames: await this.createTextures(
-          optionsTextures
-        ),
-        name: animationName,
-        animations: textures[animationName].animations,
-        params: [],
-        data: optionsTextures,
-        sprites: []
-      });
-    }
-  }
-  async onMount(params) {
-    const { props, propObservables } = params;
-    const tick2 = props.context.tick;
-    const sheet = props.sheet ?? {};
-    this.app = props.context.app();
-    if (sheet?.onFinish) {
-      this.onFinish = sheet.onFinish;
-    }
-    this.subscriptionTick = tick2.observable.subscribe((value) => {
-      this.update(value);
-    });
-    if (props.sheet?.definition) {
-      this.spritesheet = props.sheet.definition;
-      await this.createAnimations();
-    }
-    if (sheet.params) {
-      for (let key in propObservables?.sheet["params"]) {
-        const value = propObservables?.sheet["params"][key];
-        if (isSignal5(value)) {
-          this.subscriptionSheet.push(
-            value.observable.subscribe((value2) => {
-              if (this.animations.size == 0) return;
-              this.play(this.sheetCurrentAnimation, [{ [key]: value2 }]);
-            })
-          );
-        } else {
-          this.play(this.sheetCurrentAnimation, [{ [key]: value }]);
-        }
-      }
-    }
-    const isMoving = computed(() => {
-      const { x, y } = propObservables ?? {};
-      if (!x || !y) return false;
-      const xSignal = x;
-      const ySignal = y;
-      const isMovingX = isAnimatedSignal(xSignal) && xSignal.animatedState().current !== xSignal.animatedState().end;
-      const isMovingY = isAnimatedSignal(ySignal) && ySignal.animatedState().current !== ySignal.animatedState().end;
-      return isMovingX || isMovingY;
-    });
-    effect6(() => {
-      const _isMoving = isMoving();
-      if (!this.isMounted) return;
-      if (_isMoving) {
-        this.sheetCurrentAnimation = "walk" /* Walk */;
-      } else {
-        this.sheetCurrentAnimation = "stand" /* Stand */;
-      }
-      if (this.spritesheet) this.play(this.sheetCurrentAnimation, [this.sheetParams]);
-    });
-    super.onMount(params);
-  }
-  async onUpdate(props) {
-    super.onUpdate(props);
-    const setTexture = async (image) => {
-      if (!image || typeof image !== "string" || image.trim() === "") {
-        console.warn("Invalid image path provided to setTexture:", image);
-        return null;
-      }
-      const onProgress = this.fullProps.loader?.onProgress;
-      const texture = await Assets3.load(image, (progress) => {
-        if (onProgress) onProgress(progress);
-        if (progress == 1) {
-          const onComplete = this.fullProps.loader?.onComplete;
-          if (onComplete) {
-            setTimeout(() => {
-              onComplete(texture);
-            });
-          }
-        }
-      });
-      return texture;
-    };
-    const sheet = props.sheet;
-    if (sheet?.params) this.sheetParams = sheet?.params;
-    if (sheet?.playing && this.isMounted) {
-      this.sheetCurrentAnimation = sheet?.playing;
-      this.play(this.sheetCurrentAnimation, [this.sheetParams]);
-    }
-    if (props.hitbox) this.hitbox = props.hitbox;
-    if (props.scaleMode) this.baseTexture.scaleMode = props.scaleMode;
-    else if (props.image && this.fullProps.rectangle === void 0) {
-      const texture = await setTexture(this.fullProps.image);
-      if (texture) {
-        this.texture = texture;
-      }
-    } else if (props.texture) {
-      if (isElement(props.texture)) {
-        const textureInstance = props.texture.componentInstance;
-        textureInstance.subjectInit.subscribe((value) => {
-          console.log("a", value?.width);
-        });
-        this.texture = this.renderer?.generateTexture(props.texture.componentInstance);
-      } else {
-        this.texture = props.texture;
-      }
-    }
-    if (props.rectangle !== void 0) {
-      const { x, y, width, height } = props.rectangle?.value ?? props.rectangle;
-      const texture = await setTexture(this.fullProps.image);
-      if (texture) {
-        this.texture = new Texture3({
-          source: texture.source,
-          frame: new Rectangle2(x, y, width, height)
-        });
-      }
-    }
-  }
-  async onDestroy(parent, afterDestroy) {
-    await super.onDestroy(parent);
-    this.subscriptionSheet.forEach((sub) => sub.unsubscribe());
-    this.subscriptionTick.unsubscribe();
-    if (this.currentAnimationContainer && this.parent instanceof Container5) {
-      this.parent.removeChild(this.currentAnimationContainer);
-    }
-  }
-  has(name) {
-    return this.animations.has(name);
-  }
-  get(name) {
-    return this.animations.get(name);
-  }
-  isPlaying(name) {
-    if (!name) return !!this.currentAnimation;
-    if (this.currentAnimation == null) return false;
-    return this.currentAnimation.name == name;
-  }
-  stop() {
-    this.currentAnimation = null;
-    this.destroy();
-  }
-  play(name, params = []) {
-    const animParams = this.currentAnimation?.params;
-    if (this.isPlaying(name) && arrayEquals(params, animParams || [])) return;
-    const animation = this.get(name);
-    if (!animation) {
-      throw new Error(
-        `Impossible to play the ${name} animation because it doesn't exist on the "${this.id}" spritesheet`
-      );
-    }
-    const cloneParams = structuredClone(params);
-    this.removeChildren();
-    animation.sprites = [];
-    this.currentAnimation = animation;
-    this.currentAnimation.params = cloneParams;
-    this.time = 0;
-    this.frameIndex = 0;
-    let animations = animation.animations;
-    animations = isFunction(animations) ? animations(...cloneParams) : animations;
-    this.currentAnimationContainer = new Container5();
-    for (let container of animations) {
-      const sprite = new PixiSprite();
-      for (let frame of container) {
-        this.currentAnimation.sprites.push(frame);
-      }
-      this.currentAnimationContainer.addChild(sprite);
-    }
-    const sound = this.currentAnimation.data.sound;
-    if (sound) {
-      new Howl2({
-        src: sound,
-        autoplay: true,
-        loop: false,
-        volume: 1
-      });
-    }
-    this.update({
-      deltaRatio: 1
-    });
-  }
-  update({ deltaRatio }) {
-    if (!this.isPlaying() || !this.currentAnimation || !this.currentAnimationContainer)
-      return;
-    const self = this;
-    const { frames, sprites, data } = this.currentAnimation;
-    let frame = sprites[this.frameIndex];
-    const nextFrame = sprites[this.frameIndex + 1];
-    for (let _sprite of this.currentAnimationContainer.children) {
-      let applyTransformValue = function(prop, alias) {
-        const optionProp = alias || prop;
-        const val = getVal(optionProp);
-        if (val !== void 0) {
-          self[prop] = val;
-        }
-      };
-      const sprite = _sprite;
-      if (!frame || frame.frameY == void 0 || frame.frameX == void 0) {
-        continue;
-      }
-      this.texture = frames[frame.frameY][frame.frameX];
-      const getVal = (prop) => {
-        return frame[prop] ?? data[prop] ?? this.spritesheet[prop];
-      };
-      const applyTransform = (prop) => {
-        const val = getVal(prop);
-        if (val) {
-          this[prop].set(...val);
-        }
-      };
-      if (this.applyTransform) {
-        frame = {
-          ...frame,
-          ...this.applyTransform(frame, data, this.spritesheet)
-        };
-      }
-      const realSize = getVal("spriteRealSize");
-      const heightOfSprite = typeof realSize == "number" ? realSize : realSize?.height;
-      const widthOfSprite = typeof realSize == "number" ? realSize : realSize?.width;
-      const applyAnchorBySize = () => {
-        if (heightOfSprite && this.hitbox) {
-          const { spriteWidth, spriteHeight } = data;
-          const w = (spriteWidth - this.hitbox.w) / 2 / spriteWidth;
-          const gap = (spriteHeight - heightOfSprite) / 2;
-          const h2 = (spriteHeight - this.hitbox.h - gap) / spriteHeight;
-          this.anchor.set(w, h2);
-        }
-      };
-      if (frame.sound) {
-      }
-      applyAnchorBySize();
-      applyTransform("anchor");
-      applyTransform("scale");
-      applyTransform("skew");
-      applyTransform("pivot");
-      applyTransformValue("alpha", "opacity");
-      applyTransformValue("x");
-      applyTransformValue("y");
-      applyTransformValue("angle");
-      applyTransformValue("rotation");
-      applyTransformValue("visible");
-    }
-    if (!nextFrame) {
-      this.time = 0;
-      this.frameIndex = 0;
-      if (this.onFinish && sprites.length > 1) this.onFinish();
-      return;
-    }
-    this.time += deltaRatio ?? 1;
-    if (this.time >= nextFrame.time) {
-      this.frameIndex++;
-    }
-  }
-};
-registerComponent("Sprite", CanvasSprite);
-var Sprite2 = (props) => {
-  return createComponent("Sprite", props);
-};
-
-// src/components/Video.ts
-import { effect as effect7, signal as signal8 } from "@signe/reactive";
-function Video(props) {
-  const eventsMap = {
-    audioprocess: null,
-    canplay: null,
-    canplaythrough: null,
-    complete: null,
-    durationchange: null,
-    emptied: null,
-    ended: null,
-    loadeddata: null,
-    loadedmetadata: null,
-    pause: null,
-    play: null,
-    playing: null,
-    progress: null,
-    ratechange: null,
-    seeked: null,
-    seeking: null,
-    stalled: null,
-    suspend: null,
-    timeupdate: null,
-    volumechange: null,
-    waiting: null
-  };
-  const video = signal8(null);
-  const defineProps = useDefineProps(props);
-  const { play, loop: loop2, muted } = defineProps({
-    play: {
-      type: Boolean,
-      default: true
-    },
-    loop: {
-      type: Boolean,
-      default: false
-    },
-    muted: {
-      type: Boolean,
-      default: false
-    }
-  });
-  effect7(() => {
-    const _video = video();
-    const state = play();
-    if (_video && state !== void 0) {
-      if (state) {
-        _video.play();
-      } else {
-        _video.pause();
-      }
-    }
-    if (_video && loop2()) {
-      _video.loop = loop2();
-    }
-    if (_video && muted()) {
-      _video.muted = muted();
-    }
-  });
-  mount(() => {
-    return () => {
-      for (let event in eventsMap) {
-        if (eventsMap[event]) {
-          video().removeEventListener(event, eventsMap[event]);
-        }
-      }
-    };
-  });
-  return h(Sprite2, {
-    ...props,
-    image: props.src,
-    loader: {
-      onComplete: (texture) => {
-        const source = texture.source.resource;
-        video.set(source);
-        if (props?.loader?.onComplete) {
-          props.loader.onComplete(texture);
-        }
-        for (let event in eventsMap) {
-          if (props[event]) {
-            const cb = (ev) => {
-              props[event](ev);
-            };
-            eventsMap[event] = cb;
-            source.addEventListener(event, cb);
-          }
-        }
-      }
-    }
-  });
-}
-
-// src/components/Text.ts
-import { Text as PixiText } from "pixi.js";
-
-// src/engine/trigger.ts
-import { effect as effect8, signal as signal9 } from "@signe/reactive";
-function isTrigger(arg) {
-  return arg?.start && arg?.listen;
-}
-function trigger(globalConfig) {
-  const _signal = signal9({
-    config: globalConfig,
-    value: 0,
-    resolve: (value) => void 0
-  });
-  return {
-    start: (config) => {
-      return new Promise((resolve) => {
-        _signal.set({
-          config: {
-            ...globalConfig,
-            ...config
-          },
-          resolve,
-          value: Math.random()
-        });
-      });
-    },
-    listen: () => {
-      return {
-        config: globalConfig,
-        seed: _signal()
-      };
-    }
-  };
-}
-function on(triggerSignal, callback) {
-  if (!isTrigger(triggerSignal)) {
-    throw new Error("In 'on(arg)' must have a trigger signal type");
-  }
-  effect8(() => {
-    const result = triggerSignal.listen();
-    if (result?.seed.value) {
-      const ret = callback(result?.seed.config);
-      if (ret && typeof ret.then === "function") {
-        ret.then(result?.seed.resolve);
-      }
-    }
-  });
-}
-
-// src/components/Text.ts
-var CanvasText = class extends DisplayObject(PixiText) {
-  constructor() {
-    super(...arguments);
-    this.fullText = "";
-    this.currentIndex = 0;
-    this.typewriterSpeed = 1;
-    // Default speed
-    this._wordWrapWidth = 0;
-    this.typewriterOptions = {};
-  }
-  /**
-   * Called when the component is mounted to the scene graph.
-   * Initializes the typewriter effect if configured.
-   * @param {Element<CanvasText>} element - The element being mounted with parent and props.
-   * @param {number} [index] - The index of the component among its siblings.
-   */
-  async onMount(element, index) {
-    const { props } = element;
-    await super.onMount(element, index);
-    const tick2 = props.context.tick;
-    if (props.text && props.typewriter) {
-      this.fullText = props.text;
-      this.text = "";
-      this.currentIndex = 0;
-      if (props.typewriter) {
-        this.typewriterOptions = props.typewriter;
-        if (this.typewriterOptions.skip && isTrigger(this.typewriterOptions.skip)) {
-          on(this.typewriterOptions.skip, () => {
-            this.skipTypewriter();
-          });
-        }
-      }
-    }
-    this.subscriptionTick = tick2.observable.subscribe(() => {
-      if (props.typewriter) {
-        this.typewriterEffect();
-      }
-    });
-  }
-  onUpdate(props) {
-    super.onUpdate(props);
-    if (props.typewriter) {
-      if (props.typewriter) {
-        this.typewriterOptions = props.typewriter;
-      }
-    }
-    if (props.text !== void 0) {
-      this.text = "" + props.text;
-    }
-    if (props.text !== void 0 && props.text !== this.fullText && this.fullProps.typewriter) {
-      this.text = "";
-      this.currentIndex = 0;
-      this.fullText = props.text;
-    }
-    if (props.style) {
-      for (const key in props.style) {
-        this.style[key] = props.style[key];
-      }
-      if (props.style.wordWrapWidth) {
-        this._wordWrapWidth = props.style.wordWrapWidth;
-      }
-    }
-    if (props.color) {
-      this.style.fill = props.color;
-    }
-    if (props.size) {
-      this.style.fontSize = props.size;
-    }
-    if (props.fontFamily) {
-      this.style.fontFamily = props.fontFamily;
-    }
-    if (this._wordWrapWidth) {
-      this.setWidth(this._wordWrapWidth);
-    } else {
-      this.setWidth(this.width);
-    }
-    this.setHeight(this.height);
-  }
-  get onCompleteCallback() {
-    return this.typewriterOptions.onComplete;
-  }
-  typewriterEffect() {
-    if (this.currentIndex < this.fullText.length) {
-      const nextIndex = Math.min(
-        this.currentIndex + (this.typewriterOptions.speed ?? 1),
-        this.fullText.length
-      );
-      this.text = this.fullText.slice(0, nextIndex);
-      this.currentIndex = nextIndex;
-      if (this.currentIndex === this.fullText.length && this.onCompleteCallback) {
-        this.onCompleteCallback();
-      }
-    }
-  }
-  // Add a method to skip the typewriter effect
-  skipTypewriter() {
-    if (this.skipSignal) {
-      this.skipSignal();
-    }
-    this.text = this.fullText;
-    this.currentIndex = this.fullText.length;
-  }
-  /**
-   * Called when the component is about to be destroyed.
-   * Unsubscribes from the tick observable.
-   * @param {Element<any>} parent - The parent element.
-   * @param {() => void} [afterDestroy] - An optional callback function to be executed after the component's own destruction logic.
-   */
-  async onDestroy(parent, afterDestroy) {
-    const _afterDestroy = async () => {
-      if (this.subscriptionTick) {
-        this.subscriptionTick.unsubscribe();
-      }
-      if (afterDestroy) {
-        afterDestroy();
-      }
-    };
-    await super.onDestroy(parent, _afterDestroy);
-  }
-};
-registerComponent("Text", CanvasText);
-function Text(props) {
-  return createComponent("Text", props);
-}
-
-// src/components/TilingSprite.ts
-import { TilingSprite as PixiTilingSprite, Texture as Texture4 } from "pixi.js";
-var CanvasTilingSprite = class extends DisplayObject(PixiTilingSprite) {
-  onUpdate(props) {
-    super.onUpdate(props);
-    if (props.image) {
-      this.texture = Texture4.from(props.image);
-    }
-    if (props.tileScale) {
-      this.tileScale.set(props.tileScale.x, props.tileScale.y);
-    }
-    if (props.tilePosition) {
-      this.tilePosition.set(props.tilePosition.x, props.tilePosition.y);
-    }
-    if (props.width !== void 0) {
-      this.width = props.width;
-    }
-    if (props.height !== void 0) {
-      this.height = props.height;
-    }
-  }
-};
-registerComponent("TilingSprite", CanvasTilingSprite);
-function TilingSprite(props) {
-  return createComponent("TilingSprite", props);
-}
-
-// src/components/Viewport.ts
-import { Viewport as PixiViewport } from "pixi-viewport";
-import { effect as effect9 } from "@signe/reactive";
-var EVENTS3 = [
-  "bounce-x-end",
-  "bounce-x-start",
-  "bounce-y-end",
-  "bounce-y-start",
-  "clicked",
-  "drag-end",
-  "drag-start",
-  "frame-end",
-  "mouse-edge-end",
-  "mouse-edge-start",
-  "moved",
-  "moved-end",
-  "pinch-end",
-  "pinch-start",
-  "snap-end",
-  "snap-start",
-  "snap-zoom-end",
-  "snap-zoom-start",
-  "wheel-scroll",
-  "zoomed",
-  "zoomed-end"
-];
-var CanvasViewport = class extends DisplayObject(PixiViewport) {
-  constructor() {
-    const defaultOptions = {
-      noTicker: true,
-      events: {
-        domElement: {
-          addEventListener: () => {
-          }
-        }
-      }
-    };
-    super(defaultOptions);
-    this.overrideProps = ["wheel"];
-  }
-  onInit(props) {
-    super.onInit(props);
-    for (let event of EVENTS3) {
-      if (props[event]) this.on(event, props[event]);
-    }
-  }
-  /**
-   * Called when the component is mounted to the scene graph.
-   * Initializes viewport settings and subscriptions.
-   * @param {Element<CanvasViewport>} element - The element being mounted. Its `props` property (of type ViewportProps) contains component properties and context.
-   * @param {number} [index] - The index of the component among its siblings.
-   */
-  async onMount(element, index) {
-    await super.onMount(element, index);
-    const { props } = element;
-    const { tick: tick2, app, canvasSize } = props.context;
-    let isDragging = false;
-    effect9(() => {
-      this.screenWidth = canvasSize().width;
-      this.screenHeight = canvasSize().height;
-    });
-    effect9(() => {
-      const _app = app();
-      if (!_app) return;
-      const renderer = _app.renderer;
-      renderer.events.domElement.addEventListener(
-        "wheel",
-        this.input.wheelFunction
-      );
-      this.options.events = renderer.events;
-    });
-    this.tickSubscription = tick2.observable.subscribe(({ value }) => {
-      this.update(value.timestamp);
-    });
-    element.props.context.viewport = this;
-    this.updateViewportSettings(props);
-  }
-  onUpdate(props) {
-    super.onUpdate(props);
-    this.updateViewportSettings(props);
-  }
-  updateViewportSettings(props) {
-    if (props.screenWidth !== void 0) {
-      this.screenWidth = props.screenWidth;
-    }
-    if (props.screenHeight !== void 0) {
-      this.screenHeight = props.screenHeight;
-    }
-    if (props.worldWidth !== void 0) {
-      this.worldWidth = props.worldWidth;
-    }
-    if (props.worldHeight !== void 0) {
-      this.worldHeight = props.worldHeight;
-    }
-    if (props.drag) {
-      this.drag(props.drag);
-    }
-    if (props.clamp) {
-      this.clamp(props.clamp.value ?? props.clamp);
-    }
-    if (props.wheel) {
-      if (props.wheel === true) {
-        this.wheel();
-      } else {
-        this.wheel(props.wheel);
-      }
-    }
-    if (props.decelerate) {
-      if (props.decelerate === true) {
-        this.decelerate();
-      } else {
-        this.decelerate(props.decelerate);
-      }
-    }
-    if (props.pinch) {
-      if (props.pinch === true) {
-        this.pinch();
-      } else {
-        this.pinch(props.pinch);
-      }
-    }
-  }
-  /**
-   * Called when the component is about to be destroyed.
-   * Unsubscribes from the tick observable.
-   * @param {Element<any>} parent - The parent element.
-   * @param {() => void} [afterDestroy] - An optional callback function to be executed after the component's own destruction logic.
-   */
-  async onDestroy(parent, afterDestroy) {
-    const _afterDestroy = async () => {
-      this.tickSubscription.unsubscribe();
-      afterDestroy();
-    };
-    await super.onDestroy(parent, _afterDestroy);
-  }
-};
-registerComponent("Viewport", CanvasViewport);
-function Viewport(props) {
-  return createComponent("Viewport", props);
-}
-
-// src/components/NineSliceSprite.ts
-import { Assets as Assets4, NineSliceSprite as PixiNineSliceSprite } from "pixi.js";
-var CanvasNineSliceSprite = class extends DisplayObject(PixiNineSliceSprite) {
-  constructor() {
-    super({
-      width: 0,
-      height: 0
-    });
-  }
-  async onUpdate(props) {
-    for (const [key, value] of Object.entries(props)) {
-      if (value !== void 0) {
-        if (key === "image") {
-          this.texture = await Assets4.load(value);
-        } else if (key in this) {
-          this[key] = value;
-        }
-      }
-    }
-  }
-};
-registerComponent("NineSliceSprite", CanvasNineSliceSprite);
-function NineSliceSprite(props) {
-  return createComponent("NineSliceSprite", props);
-}
-
-// src/components/DOMContainer.ts
-import { DOMContainer as PixiDOMContainer } from "pixi.js";
-
-// src/components/DOMElement.ts
-import { isSignal as isSignal6 } from "@signe/reactive";
-var EVENTS4 = [
-  "click",
-  "mouseover",
-  "mouseout",
-  "mouseenter",
-  "mouseleave",
-  "mousemove",
-  "mouseup",
-  "mousedown",
-  "touchstart",
-  "touchend",
-  "touchmove",
-  "touchcancel",
-  "wheel",
-  "scroll",
-  "resize",
-  "focus",
-  "blur",
-  "change",
-  "input",
-  "submit",
-  "reset",
-  "keydown",
-  "keyup",
-  "keypress",
-  "contextmenu",
-  "drag",
-  "dragend",
-  "dragenter",
-  "dragleave",
-  "dragover",
-  "drop",
-  "dragstart",
-  "select",
-  "selectstart",
-  "selectend",
-  "selectall",
-  "selectnone"
-];
-var CanvasDOMElement = class {
-  constructor() {
-    this.eventListeners = /* @__PURE__ */ new Map();
-    this.onBeforeDestroy = null;
-    this.valueSignal = null;
-    this.isFormElementType = false;
-  }
-  /**
-   * Checks if the element is a form element that supports the value attribute
-   * @param elementType - The element type string from props
-   * @returns true if the element is a form element with value support
-   */
-  isFormElement(elementType) {
-    const formElements = ["input", "textarea", "select"];
-    return formElements.includes(elementType.toLowerCase());
-  }
-  onInit(props) {
-    if (typeof props.element === "string") {
-      this.element = document.createElement(props.element);
-      this.isFormElementType = this.isFormElement(props.element);
-    } else {
-      this.element = props.element.value;
-      this.isFormElementType = this.isFormElement(this.element.tagName);
-    }
-    if (props.onBeforeDestroy || props["on-before-destroy"]) {
-      this.onBeforeDestroy = props.onBeforeDestroy || props["on-before-destroy"];
-    }
-    for (const event of EVENTS4) {
-      if (props.attrs?.[event]) {
-        const eventHandler = (e) => {
-          if (event === "submit" && this.element.tagName.toLowerCase() === "form") {
-            e.preventDefault();
-            const formData = new FormData(this.element);
-            const formObject = {};
-            formData.forEach((value, key) => {
-              if (formObject[key]) {
-                if (Array.isArray(formObject[key])) {
-                  formObject[key].push(value);
-                } else {
-                  formObject[key] = [formObject[key], value];
-                }
-              } else {
-                formObject[key] = value;
-              }
-            });
-            props.attrs[event]?.(e, formObject);
-          } else {
-            props.attrs[event]?.(e);
-          }
-        };
-        this.eventListeners.set(event, eventHandler);
-        this.element.addEventListener(event, eventHandler, false);
-      }
-    }
-    if (props.children) {
-      for (const child of props.children) {
-        if (isObservable(child)) {
-          child.subscribe(({ elements }) => {
-            for (const element of elements) {
-              this.element.appendChild(element.componentInstance.element);
-            }
-          });
-        } else {
-          this.element.appendChild(child.componentInstance.element);
-        }
-      }
-    }
-    this.onUpdate(props);
-  }
-  onMount(context) {
-    const props = context.propObservables;
-    const attrs = props.attrs;
-    if (this.isFormElementType && attrs?.value && isSignal6(attrs.value)) {
-      this.valueSignal = attrs.value;
-      this.element.value = this.valueSignal();
-      const inputHandler = (e) => {
-        const target = e.target;
-        this.valueSignal.set(target.value);
-      };
-      this.eventListeners.set("input", inputHandler);
-      this.element.addEventListener("input", inputHandler, false);
-    }
-  }
-  onUpdate(props) {
-    if (!this.element) return;
-    for (const [key, value] of Object.entries(props.attrs || {})) {
-      if (key === "class") {
-        const classList = value.items || value.value || value;
-        this.element.className = "";
-        if (typeof classList === "string") {
-          this.element.className = classList;
-        } else if (Array.isArray(classList)) {
-          this.element.classList.add(...classList);
-        } else if (typeof classList === "object" && classList !== null) {
-          for (const [className, shouldAdd] of Object.entries(classList)) {
-            if (shouldAdd) {
-              this.element.classList.add(className);
-            }
-          }
-        }
-      } else if (key === "style") {
-        const styleValue = value.items || value.value || value;
-        if (typeof styleValue === "string") {
-          this.element.setAttribute("style", styleValue);
-        } else if (typeof styleValue === "object" && styleValue !== null) {
-          for (const [styleProp, styleVal] of Object.entries(styleValue)) {
-            if (styleVal !== null && styleVal !== void 0) {
-              this.element.style[styleProp] = styleVal;
-            }
-          }
-        }
-      } else if (key === "value" && this.isFormElementType) {
-        if (isSignal6(value)) {
-          const currentValue = this.element.value;
-          const signalValue = value();
-          if (currentValue !== signalValue) {
-            this.element.value = signalValue;
-          }
-        } else {
-          this.element.value = value;
-        }
-      } else if (!EVENTS4.includes(key)) {
-        this.element.setAttribute(key, value);
-      }
-    }
-    if (props.textContent) {
-      this.element.textContent = props.textContent;
-    }
-  }
-  async onDestroy(parent, afterDestroy) {
-    if (this.element) {
-      if (this.onBeforeDestroy) {
-        await this.onBeforeDestroy();
-      }
-      for (const [event, handler] of this.eventListeners) {
-        this.element.removeEventListener(event, handler, false);
-      }
-      this.eventListeners.clear();
-      this.element.remove();
-      if (afterDestroy) {
-        afterDestroy();
-      }
-    }
-  }
-};
-registerComponent("DOMElement", CanvasDOMElement);
-var DOMElement = (props) => {
-  return createComponent("DOMElement", props);
-};
-
-// src/components/DOMContainer.ts
-var CanvasDOMContainer = class extends DisplayObject(PixiDOMContainer) {
-  constructor() {
-    super(...arguments);
-    this.disableLayout = true;
-  }
-  onInit(props) {
-    const div = h(DOMElement, { element: "div" }, props.children);
-    this.element = div.componentInstance.element;
-  }
-};
-registerComponent("DOMContainer", CanvasDOMContainer);
-var DOMContainer = (props) => {
-  return createComponent("DOMContainer", props);
-};
-
-// src/engine/bootstrap.ts
-import "@pixi/layout";
-import { Application as Application3 } from "pixi.js";
-var bootstrapCanvas = async (rootElement, canvas, options) => {
-  const app = new Application3();
-  await app.init({
-    resizeTo: rootElement,
-    autoStart: false,
-    ...options ?? {}
-  });
-  const canvasElement = await h(canvas);
-  if (canvasElement.tag != "Canvas") {
-    throw new Error("Canvas is required");
-  }
-  canvasElement.render(rootElement, app);
-  const { backgroundColor } = useProps(canvasElement.props, {
-    backgroundColor: "black"
-  });
-  app.renderer.background.color = backgroundColor();
-  return {
-    canvasElement,
-    app
-  };
-};
-
-// src/utils/Ease.ts
-import {
-  linear,
-  easeIn,
-  easeInOut,
-  easeOut,
-  circIn,
-  circInOut,
-  circOut,
-  backIn,
-  backInOut,
-  backOut,
-  anticipate,
-  bounceIn,
-  bounceInOut,
-  bounceOut
-} from "popmotion";
-var Easing = {
-  linear,
-  easeIn,
-  easeInOut,
-  easeOut,
-  circIn,
-  circInOut,
-  circOut,
-  backIn,
-  backInOut,
-  backOut,
-  anticipate,
-  bounceIn,
-  bounceInOut,
-  bounceOut
-};
-
-// src/utils/RadialGradient.ts
-import { Texture as Texture6, ImageSource, DOMAdapter, Matrix } from "pixi.js";
-var RadialGradient = class {
-  /**
-   * Creates a new RadialGradient instance
-   * @param x0 - The x-coordinate of the starting circle
-   * @param y0 - The y-coordinate of the starting circle
-   * @param x1 - The x-coordinate of the ending circle
-   * @param y1 - The y-coordinate of the ending circle
-   * @param x2 - The x-coordinate for gradient transformation
-   * @param y2 - The y-coordinate for gradient transformation
-   * @param focalPoint - The focal point of the gradient (0-1), defaults to 0
-   */
-  constructor(x0, y0, x1, y1, x2, y2, focalPoint = 0) {
-    this.x0 = x0;
-    this.y0 = y0;
-    this.x1 = x1;
-    this.y1 = y1;
-    this.x2 = x2;
-    this.y2 = y2;
-    this.focalPoint = focalPoint;
-    this.gradient = null;
-    this.texture = null;
-    this.size = 600;
-    this.size = x0;
-    const halfSize = this.size * 0.5;
-    this.canvas = DOMAdapter.get().createCanvas();
-    this.canvas.width = this.size;
-    this.canvas.height = this.size;
-    this.ctx = this.canvas.getContext("2d");
-    if (this.ctx) {
-      this.gradient = this.ctx.createRadialGradient(
-        halfSize * (1 - focalPoint),
-        halfSize,
-        0,
-        halfSize,
-        halfSize,
-        halfSize - 0.5
-      );
-    }
-  }
-  /**
-   * Adds a color stop to the gradient
-   * @param offset - The position of the color stop (0-1)
-   * @param color - The color value (any valid CSS color string)
-   */
-  addColorStop(offset, color) {
-    if (this.gradient) {
-      this.gradient.addColorStop(offset, color);
-    }
-  }
-  /**
-   * Renders the gradient and returns the texture with its transformation matrix
-   * @param options - Render options
-   * @param options.translate - Optional translation coordinates
-   * @returns Object containing the texture and transformation matrix
-   */
-  render({ translate } = {}) {
-    const { x0, y0, x1, y1, x2, y2, focalPoint } = this;
-    const defaultSize = this.size;
-    if (this.ctx && this.gradient) {
-      this.ctx.fillStyle = this.gradient;
-      this.ctx.fillRect(0, 0, defaultSize, defaultSize);
-      this.texture = new Texture6({
-        source: new ImageSource({
-          resource: this.canvas,
-          addressModeU: "clamp-to-edge",
-          addressModeV: "clamp-to-edge"
-        })
-      });
-      const m = new Matrix();
-      const dx = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
-      const dy = Math.sqrt((x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0));
-      const angle = Math.atan2(y1 - y0, x1 - x0);
-      const scaleX = dx / defaultSize;
-      const scaleY = dy / defaultSize;
-      m.rotate(-angle);
-      m.scale(scaleX, scaleY);
-      if (translate) {
-        m.translate(translate.x, translate.y);
-      }
-      this.transform = m;
-    }
-    return {
-      texture: this.texture,
-      matrix: this.transform
-    };
-  }
-};
-
-// src/index.ts
-import { isObservable as isObservable2 } from "rxjs";
-import * as Howl3 from "howler";
+import { h as a } from "./index-5TTorHyA.js";
+import { A as r, C as n, m as o, l as c, D as l, v as p, a3 as m, a2 as S, a0 as g, n as u, G as b, c as d, M as C, N as j, O as T, P as E, a1 as O, R as f, o as v, p as w, S as h, q as D, r as P, T as k, b as x, V as y, t as A, $ as H, _ as M, Y as V, d as G, H as N, z as R, I as q, e as U, Q as z, Z as B, f as I, g as J, w as K, j as L, i as Q, x as W, k as X, U as Y, B as Z, K as _, J as $, X as F, y as aa, s as sa, L as ea, W as ia, a as ta, u as ra } from "./index-5TTorHyA.js";
+const e = a.Howler;
 export {
-  Canvas2 as Canvas,
-  Circle,
-  Container4 as Container,
-  DOMContainer,
-  DOMElement,
-  DisplayObject,
-  EVENTS2 as EVENTS,
-  Easing,
-  Ellipse,
-  Graphics,
-  Howl3 as Howl,
-  Howler,
-  Mesh,
-  NineSliceSprite,
-  ParticlesEmitter,
-  RadialGradient,
-  Rect,
-  Scene,
-  Sprite2 as Sprite,
-  Svg,
-  Text,
-  TilingSprite,
-  Triangle,
-  utils_exports as Utils,
-  Video,
-  Viewport,
-  animatedSequence,
-  animatedSignal,
-  bootstrapCanvas,
-  cond,
-  createComponent,
-  currentSubscriptionsTracker,
-  h,
-  isAnimatedSignal,
-  isElement,
-  isObservable2 as isObservable,
-  isPrimitive,
-  isTrigger,
-  loop,
-  mount,
-  mountTracker,
-  on,
-  registerComponent,
-  tick,
-  trigger,
-  useDefineProps,
-  useProps
-};
-//# sourceMappingURL=index.js.map
+  r as ArraySubject,
+  n as Canvas,
+  o as Circle,
+  c as Container,
+  l as DOMContainer,
+  p as DOMElement,
+  m as DisplayObject,
+  S as EVENTS,
+  g as Easing,
+  u as Ellipse,
+  b as Graphics,
+  d as Howl,
+  e as Howler,
+  C as Mesh,
+  j as NineSliceSprite,
+  T as ObjectSubject,
+  E as ParticlesEmitter,
+  O as RadialGradient,
+  f as Rect,
+  v as Scene,
+  w as Sprite,
+  h as Svg,
+  D as Text,
+  P as TilingSprite,
+  k as Triangle,
+  x as Utils,
+  y as Video,
+  A as Viewport,
+  H as animatedSequence,
+  M as animatedSignal,
+  V as bootstrapCanvas,
+  G as computed,
+  N as cond,
+  R as createComponent,
+  q as currentSubscriptionsTracker,
+  U as effect,
+  z as h,
+  B as isAnimatedSignal,
+  I as isArraySubject,
+  J as isComputed,
+  K as isElement,
+  L as isObjectSubject,
+  Q as isObservable,
+  W as isPrimitive,
+  X as isSignal,
+  Y as isTrigger,
+  Z as loop,
+  _ as mount,
+  $ as mountTracker,
+  F as on,
+  aa as registerComponent,
+  sa as signal,
+  ea as tick,
+  ia as trigger,
+  ta as useDefineProps,
+  ra as useProps
+};
+//# sourceMappingURL=index.js.map