@limrun/ui 0.20.1 → 0.20.2

package/dist/core-BhHpU_lr.mjs

@@ -0,0 +1,2113 @@
+const Je = {
+  INJECT_KEYCODE: 0,
+  INJECT_TEXT: 1,
+  INJECT_TOUCH_EVENT: 2,
+  // iOS-specific: send two touch points in one message (Option/Alt+drag pinch)
+  INJECT_TWO_FINGER_TOUCH_EVENT: 18,
+  INJECT_SCROLL_EVENT: 3,
+  BACK_OR_SCREEN_ON: 4,
+  EXPAND_NOTIFICATION_PANEL: 5,
+  EXPAND_SETTINGS_PANEL: 6,
+  COLLAPSE_PANELS: 7,
+  GET_CLIPBOARD: 8,
+  SET_CLIPBOARD: 9,
+  SET_DISPLAY_POWER: 10,
+  ROTATE_DEVICE: 11
+}, He = {
+  ACTION_DOWN: 0,
+  ACTION_UP: 1,
+  ACTION_MOVE: 2,
+  ACTION_CANCEL: 3,
+  ACTION_POINTER_DOWN: 5,
+  ACTION_POINTER_UP: 6,
+  BUTTON_PRIMARY: 1,
+  BUTTON_SECONDARY: 2,
+  BUTTON_TERTIARY: 4
+}, i = {
+  // Actions
+  ACTION_DOWN: 0,
+  ACTION_UP: 1,
+  // Meta state flags (from android.view.KeyEvent)
+  META_NONE: 0,
+  META_SHIFT_ON: 1,
+  META_ALT_ON: 2,
+  META_CTRL_ON: 4096,
+  // META_CTRL_LEFT_ON | META_CTRL_RIGHT_ON
+  META_META_ON: 65536,
+  // META_META_LEFT_ON | META_META_RIGHT_ON
+  // Keycodes (from android.view.KeyEvent)
+  KEYCODE_UNKNOWN: 0,
+  KEYCODE_SOFT_LEFT: 1,
+  KEYCODE_SOFT_RIGHT: 2,
+  KEYCODE_HOME: 3,
+  KEYCODE_BACK: 4,
+  KEYCODE_CALL: 5,
+  KEYCODE_ENDCALL: 6,
+  KEYCODE_0: 7,
+  KEYCODE_1: 8,
+  KEYCODE_2: 9,
+  KEYCODE_3: 10,
+  KEYCODE_4: 11,
+  KEYCODE_5: 12,
+  KEYCODE_6: 13,
+  KEYCODE_7: 14,
+  KEYCODE_8: 15,
+  KEYCODE_9: 16,
+  KEYCODE_STAR: 17,
+  KEYCODE_POUND: 18,
+  DPAD_UP: 19,
+  // KEYCODE_DPAD_UP
+  DPAD_DOWN: 20,
+  // KEYCODE_DPAD_DOWN
+  DPAD_LEFT: 21,
+  // KEYCODE_DPAD_LEFT
+  DPAD_RIGHT: 22,
+  // KEYCODE_DPAD_RIGHT
+  KEYCODE_DPAD_CENTER: 23,
+  KEYCODE_VOLUME_UP: 24,
+  KEYCODE_VOLUME_DOWN: 25,
+  KEYCODE_POWER: 26,
+  KEYCODE_CAMERA: 27,
+  KEYCODE_CLEAR: 28,
+  KEYCODE_A: 29,
+  KEYCODE_B: 30,
+  KEYCODE_C: 31,
+  KEYCODE_D: 32,
+  KEYCODE_E: 33,
+  KEYCODE_F: 34,
+  KEYCODE_G: 35,
+  KEYCODE_H: 36,
+  KEYCODE_I: 37,
+  KEYCODE_J: 38,
+  KEYCODE_K: 39,
+  KEYCODE_L: 40,
+  KEYCODE_M: 41,
+  KEYCODE_N: 42,
+  KEYCODE_O: 43,
+  KEYCODE_P: 44,
+  KEYCODE_Q: 45,
+  KEYCODE_R: 46,
+  KEYCODE_S: 47,
+  KEYCODE_T: 48,
+  KEYCODE_U: 49,
+  KEYCODE_V: 50,
+  KEYCODE_W: 51,
+  KEYCODE_X: 52,
+  KEYCODE_Y: 53,
+  KEYCODE_Z: 54,
+  KEYCODE_COMMA: 55,
+  KEYCODE_PERIOD: 56,
+  KEYCODE_ALT_LEFT: 57,
+  KEYCODE_ALT_RIGHT: 58,
+  KEYCODE_SHIFT_LEFT: 59,
+  KEYCODE_SHIFT_RIGHT: 60,
+  KEYCODE_TAB: 61,
+  KEYCODE_SPACE: 62,
+  KEYCODE_SYM: 63,
+  KEYCODE_EXPLORER: 64,
+  KEYCODE_ENVELOPE: 65,
+  ENTER: 66,
+  // KEYCODE_ENTER
+  DEL: 67,
+  // KEYCODE_DEL (Backspace)
+  KEYCODE_GRAVE: 68,
+  // `
+  KEYCODE_MINUS: 69,
+  // -
+  KEYCODE_EQUALS: 70,
+  // =
+  KEYCODE_LEFT_BRACKET: 71,
+  // [
+  KEYCODE_RIGHT_BRACKET: 72,
+  // ]
+  KEYCODE_BACKSLASH: 73,
+  // \
+  KEYCODE_SEMICOLON: 74,
+  // ;
+  KEYCODE_APOSTROPHE: 75,
+  // '
+  KEYCODE_SLASH: 76,
+  // /
+  KEYCODE_AT: 77,
+  // @
+  KEYCODE_NUM: 78,
+  KEYCODE_HEADSETHOOK: 79,
+  KEYCODE_FOCUS: 80,
+  KEYCODE_PLUS: 81,
+  MENU: 82,
+  // KEYCODE_MENU
+  KEYCODE_NOTIFICATION: 83,
+  KEYCODE_SEARCH: 84,
+  KEYCODE_MEDIA_PLAY_PAUSE: 85,
+  KEYCODE_MEDIA_STOP: 86,
+  KEYCODE_MEDIA_NEXT: 87,
+  KEYCODE_MEDIA_PREVIOUS: 88,
+  KEYCODE_MEDIA_REWIND: 89,
+  KEYCODE_MEDIA_FAST_FORWARD: 90,
+  KEYCODE_MUTE: 91,
+  KEYCODE_PAGE_UP: 92,
+  KEYCODE_PAGE_DOWN: 93,
+  KEYCODE_PICTSYMBOLS: 94,
+  KEYCODE_SWITCH_CHARSET: 95,
+  KEYCODE_BUTTON_A: 96,
+  KEYCODE_BUTTON_B: 97,
+  KEYCODE_BUTTON_C: 98,
+  KEYCODE_BUTTON_X: 99,
+  KEYCODE_BUTTON_Y: 100,
+  KEYCODE_BUTTON_Z: 101,
+  KEYCODE_BUTTON_L1: 102,
+  KEYCODE_BUTTON_R1: 103,
+  KEYCODE_BUTTON_L2: 104,
+  KEYCODE_BUTTON_R2: 105,
+  KEYCODE_BUTTON_THUMBL: 106,
+  KEYCODE_BUTTON_THUMBR: 107,
+  KEYCODE_BUTTON_START: 108,
+  KEYCODE_BUTTON_SELECT: 109,
+  KEYCODE_BUTTON_MODE: 110,
+  KEYCODE_ESCAPE: 111,
+  FORWARD_DEL: 112,
+  // KEYCODE_FORWARD_DEL (Delete key)
+  KEYCODE_CTRL_LEFT: 113,
+  KEYCODE_CTRL_RIGHT: 114,
+  KEYCODE_CAPS_LOCK: 115,
+  KEYCODE_SCROLL_LOCK: 116,
+  KEYCODE_META_LEFT: 117,
+  KEYCODE_META_RIGHT: 118,
+  KEYCODE_FUNCTION: 119,
+  KEYCODE_SYSRQ: 120,
+  KEYCODE_BREAK: 121,
+  KEYCODE_MOVE_HOME: 122,
+  KEYCODE_MOVE_END: 123,
+  KEYCODE_INSERT: 124,
+  KEYCODE_FORWARD: 125,
+  KEYCODE_MEDIA_PLAY: 126,
+  KEYCODE_MEDIA_PAUSE: 127,
+  KEYCODE_MEDIA_CLOSE: 128,
+  KEYCODE_MEDIA_EJECT: 129,
+  KEYCODE_MEDIA_RECORD: 130,
+  KEYCODE_F1: 131,
+  KEYCODE_F2: 132,
+  KEYCODE_F3: 133,
+  KEYCODE_F4: 134,
+  KEYCODE_F5: 135,
+  KEYCODE_F6: 136,
+  KEYCODE_F7: 137,
+  KEYCODE_F8: 138,
+  KEYCODE_F9: 139,
+  KEYCODE_F10: 140,
+  KEYCODE_F11: 141,
+  KEYCODE_F12: 142,
+  KEYCODE_NUM_LOCK: 143,
+  KEYCODE_NUMPAD_0: 144,
+  KEYCODE_NUMPAD_1: 145,
+  KEYCODE_NUMPAD_2: 146,
+  KEYCODE_NUMPAD_3: 147,
+  KEYCODE_NUMPAD_4: 148,
+  KEYCODE_NUMPAD_5: 149,
+  KEYCODE_NUMPAD_6: 150,
+  KEYCODE_NUMPAD_7: 151,
+  KEYCODE_NUMPAD_8: 152,
+  KEYCODE_NUMPAD_9: 153,
+  KEYCODE_NUMPAD_DIVIDE: 154,
+  KEYCODE_NUMPAD_MULTIPLY: 155,
+  KEYCODE_NUMPAD_SUBTRACT: 156,
+  KEYCODE_NUMPAD_ADD: 157,
+  KEYCODE_NUMPAD_DOT: 158,
+  KEYCODE_NUMPAD_COMMA: 159,
+  KEYCODE_NUMPAD_ENTER: 160,
+  KEYCODE_NUMPAD_EQUALS: 161,
+  KEYCODE_NUMPAD_LEFT_PAREN: 162,
+  KEYCODE_NUMPAD_RIGHT_PAREN: 163,
+  KEYCODE_VOLUME_MUTE: 164,
+  KEYCODE_INFO: 165,
+  KEYCODE_CHANNEL_UP: 166,
+  KEYCODE_CHANNEL_DOWN: 167,
+  KEYCODE_ZOOM_IN: 168,
+  KEYCODE_ZOOM_OUT: 169,
+  KEYCODE_TV: 170,
+  KEYCODE_WINDOW: 171,
+  KEYCODE_GUIDE: 172,
+  KEYCODE_DVR: 173,
+  KEYCODE_BOOKMARK: 174,
+  KEYCODE_CAPTIONS: 175,
+  KEYCODE_SETTINGS: 176,
+  KEYCODE_TV_POWER: 177,
+  KEYCODE_TV_INPUT: 178,
+  KEYCODE_STB_POWER: 179,
+  KEYCODE_STB_INPUT: 180,
+  KEYCODE_AVR_POWER: 181,
+  KEYCODE_AVR_INPUT: 182,
+  KEYCODE_PROG_RED: 183,
+  KEYCODE_PROG_GREEN: 184,
+  KEYCODE_PROG_YELLOW: 185,
+  KEYCODE_PROG_BLUE: 186,
+  KEYCODE_APP_SWITCH: 187,
+  KEYCODE_LANGUAGE_SWITCH: 204,
+  KEYCODE_ASSIST: 219,
+  KEYCODE_BRIGHTNESS_DOWN: 220,
+  KEYCODE_BRIGHTNESS_UP: 221,
+  KEYCODE_SLEEP: 223,
+  KEYCODE_WAKEUP: 224,
+  KEYCODE_SOFT_SLEEP: 276
+}, qt = {
+  KeyA: i.KEYCODE_A,
+  KeyB: i.KEYCODE_B,
+  KeyC: i.KEYCODE_C,
+  KeyD: i.KEYCODE_D,
+  KeyE: i.KEYCODE_E,
+  KeyF: i.KEYCODE_F,
+  KeyG: i.KEYCODE_G,
+  KeyH: i.KEYCODE_H,
+  KeyI: i.KEYCODE_I,
+  KeyJ: i.KEYCODE_J,
+  KeyK: i.KEYCODE_K,
+  KeyL: i.KEYCODE_L,
+  KeyM: i.KEYCODE_M,
+  KeyN: i.KEYCODE_N,
+  KeyO: i.KEYCODE_O,
+  KeyP: i.KEYCODE_P,
+  KeyQ: i.KEYCODE_Q,
+  KeyR: i.KEYCODE_R,
+  KeyS: i.KEYCODE_S,
+  KeyT: i.KEYCODE_T,
+  KeyU: i.KEYCODE_U,
+  KeyV: i.KEYCODE_V,
+  KeyW: i.KEYCODE_W,
+  KeyX: i.KEYCODE_X,
+  KeyY: i.KEYCODE_Y,
+  KeyZ: i.KEYCODE_Z,
+  Digit0: i.KEYCODE_0,
+  Digit1: i.KEYCODE_1,
+  Digit2: i.KEYCODE_2,
+  Digit3: i.KEYCODE_3,
+  Digit4: i.KEYCODE_4,
+  Digit5: i.KEYCODE_5,
+  Digit6: i.KEYCODE_6,
+  Digit7: i.KEYCODE_7,
+  Digit8: i.KEYCODE_8,
+  Digit9: i.KEYCODE_9,
+  Backquote: i.KEYCODE_GRAVE,
+  Minus: i.KEYCODE_MINUS,
+  Equal: i.KEYCODE_EQUALS,
+  BracketLeft: i.KEYCODE_LEFT_BRACKET,
+  BracketRight: i.KEYCODE_RIGHT_BRACKET,
+  Backslash: i.KEYCODE_BACKSLASH,
+  Semicolon: i.KEYCODE_SEMICOLON,
+  Quote: i.KEYCODE_APOSTROPHE,
+  Comma: i.KEYCODE_COMMA,
+  Period: i.KEYCODE_PERIOD,
+  Slash: i.KEYCODE_SLASH,
+  Space: i.KEYCODE_SPACE,
+  Tab: i.KEYCODE_TAB,
+  Escape: i.KEYCODE_ESCAPE,
+  ArrowUp: i.DPAD_UP,
+  ArrowDown: i.DPAD_DOWN,
+  ArrowLeft: i.DPAD_LEFT,
+  ArrowRight: i.DPAD_RIGHT,
+  Enter: i.ENTER,
+  Backspace: i.DEL,
+  Delete: i.FORWARD_DEL,
+  Home: i.KEYCODE_MOVE_HOME,
+  End: i.KEYCODE_MOVE_END,
+  PageUp: i.KEYCODE_PAGE_UP,
+  PageDown: i.KEYCODE_PAGE_DOWN,
+  Insert: i.KEYCODE_INSERT,
+  F1: i.KEYCODE_F1,
+  F2: i.KEYCODE_F2,
+  F3: i.KEYCODE_F3,
+  F4: i.KEYCODE_F4,
+  F5: i.KEYCODE_F5,
+  F6: i.KEYCODE_F6,
+  F7: i.KEYCODE_F7,
+  F8: i.KEYCODE_F8,
+  F9: i.KEYCODE_F9,
+  F10: i.KEYCODE_F10,
+  F11: i.KEYCODE_F11,
+  F12: i.KEYCODE_F12,
+  ShiftLeft: i.KEYCODE_SHIFT_LEFT,
+  ShiftRight: i.KEYCODE_SHIFT_RIGHT,
+  ControlLeft: i.KEYCODE_CTRL_LEFT,
+  ControlRight: i.KEYCODE_CTRL_RIGHT,
+  AltLeft: i.KEYCODE_ALT_LEFT,
+  AltRight: i.KEYCODE_ALT_RIGHT,
+  MetaLeft: i.KEYCODE_META_LEFT,
+  MetaRight: i.KEYCODE_META_RIGHT,
+  // Windows/Command key
+  ContextMenu: i.MENU,
+  // Often the Menu key
+  // Numpad mappings
+  Numpad0: i.KEYCODE_NUMPAD_0,
+  Numpad1: i.KEYCODE_NUMPAD_1,
+  Numpad2: i.KEYCODE_NUMPAD_2,
+  Numpad3: i.KEYCODE_NUMPAD_3,
+  Numpad4: i.KEYCODE_NUMPAD_4,
+  Numpad5: i.KEYCODE_NUMPAD_5,
+  Numpad6: i.KEYCODE_NUMPAD_6,
+  Numpad7: i.KEYCODE_NUMPAD_7,
+  Numpad8: i.KEYCODE_NUMPAD_8,
+  Numpad9: i.KEYCODE_NUMPAD_9,
+  NumpadDivide: i.KEYCODE_NUMPAD_DIVIDE,
+  NumpadMultiply: i.KEYCODE_NUMPAD_MULTIPLY,
+  NumpadSubtract: i.KEYCODE_NUMPAD_SUBTRACT,
+  NumpadAdd: i.KEYCODE_NUMPAD_ADD,
+  NumpadDecimal: i.KEYCODE_NUMPAD_DOT,
+  NumpadComma: i.KEYCODE_NUMPAD_COMMA,
+  // Some numpads have comma
+  NumpadEnter: i.KEYCODE_NUMPAD_ENTER,
+  NumpadEqual: i.KEYCODE_NUMPAD_EQUALS
+};
+function $t(t, e, n, s, E, d, c = 1, h = 0, C = 0) {
+  const p = new ArrayBuffer(32), K = new DataView(p);
+  let w = 0;
+  K.setUint8(w, Je.INJECT_TOUCH_EVENT), w += 1;
+  const U = t === He.ACTION_POINTER_DOWN ? He.ACTION_DOWN : t === He.ACTION_POINTER_UP ? He.ACTION_UP : t;
+  return K.setUint8(w, U), w += 1, K.setBigInt64(w, BigInt(e), !0), w += 8, K.setInt32(w, Math.round(E), !0), w += 4, K.setInt32(w, Math.round(d), !0), w += 4, K.setUint16(w, n, !0), w += 2, K.setUint16(w, s, !0), w += 2, K.setInt16(w, Math.round(c * 65535), !0), w += 2, K.setInt32(w, h, !0), w += 4, K.setInt32(w, C, !0), p;
+}
+function Rn(t, e, n, s, E, d, c) {
+  const h = new ArrayBuffer(24), C = new DataView(h);
+  let p = 0;
+  return C.setUint8(p, Je.INJECT_TWO_FINGER_TOUCH_EVENT), p += 1, C.setUint8(p, t), p += 1, C.setInt32(p, Math.round(s), !0), p += 4, C.setInt32(p, Math.round(E), !0), p += 4, C.setInt32(p, Math.round(d), !0), p += 4, C.setInt32(p, Math.round(c), !0), p += 4, C.setUint16(p, e, !0), p += 2, C.setUint16(p, n, !0), p += 2, C.setUint16(p, 0, !0), h;
+}
+function Vt(t, e = !0) {
+  const s = new TextEncoder().encode(t), E = new ArrayBuffer(14 + s.length), d = new DataView(E);
+  let c = 0;
+  return d.setUint8(c, Je.SET_CLIPBOARD), c += 1, d.setBigInt64(c, BigInt(0), !1), c += 8, d.setUint8(c, e ? 1 : 0), c += 1, d.setUint32(c, s.length, !1), c += 4, new Uint8Array(E, c).set(s), E;
+}
+function nt(t, e, n = 0, s = 0) {
+  const E = new ArrayBuffer(14), d = new DataView(E);
+  let c = 0;
+  return d.setUint8(c, Je.INJECT_KEYCODE), c += 1, d.setUint8(c, t), c += 1, d.setInt32(c, e, !0), c += 4, d.setInt32(c, n, !0), c += 4, d.setInt32(c, s, !0), E;
+}
+const In = { width: 164.6, height: 117.8, depth: 5.2 };
+function kn(t, e, n) {
+  return t = Math.max(0, Math.min(1, t)), e = Math.max(0, Math.min(1, e)), n === 1 ? { x: e, y: 1 - t } : n === 2 ? { x: 1 - t, y: 1 - e } : n === 3 ? { x: 1 - e, y: t } : { x: t, y: e };
+}
+function Ht(t) {
+  return Number.isFinite(t) && t >= 0 && t <= 180;
+}
+function Un(t, e) {
+  return { x: Math.max(0, Math.min(1, t)), y: Math.max(0, Math.min(1, 1 - e)) };
+}
+function Pn(t, e, n) {
+  return e && (t || !n) ? "touch" : t ? "ignore" : "orbit";
+}
+function Gt(t, e, n, s) {
+  if (!Number.isInteger(t) || t < 0 || t > 3 || !Number.isInteger(e) || e < 1 || e > 255 || !Number.isFinite(n) || !Number.isFinite(s) || n < 0 || n > 1 || s < 0 || s > 1)
+    throw new RangeError("Invalid display touch coordinates");
+  const E = new ArrayBuffer(12), d = new DataView(E);
+  return d.setUint8(0, 19), d.setUint8(1, t), d.setUint8(2, e), d.setFloat32(4, n, !0), d.setFloat32(8, s, !0), E;
+}
+class Ln {
+  constructor(e, n) {
+    this.send = e, this.failed = n;
+  }
+  send;
+  failed;
+  latest;
+  running = !1;
+  stopped = !1;
+  set(e) {
+    this.stopped || !Ht(e) || (this.latest = e, this.flush());
+  }
+  stop() {
+    this.stopped = !0, this.latest = void 0;
+  }
+  async flush() {
+    if (!(this.running || this.stopped)) {
+      this.running = !0;
+      try {
+        for (; this.latest !== void 0 && !this.stopped; ) {
+          const e = this.latest;
+          this.latest = void 0, await this.send(e);
+        }
+      } catch (e) {
+        this.latest = void 0, this.stopped || this.failed(e);
+      } finally {
+        this.running = !1;
+      }
+    }
+  }
+}
+const Fn = {
+  side: "Sleep/Wake",
+  volumeUp: "Volume Up",
+  volumeDown: "Volume Down"
+};
+class Bn {
+  constructor(e, n) {
+    this.send = e, this.failed = n;
+  }
+  send;
+  failed;
+  held;
+  tail = Promise.resolve();
+  timeout;
+  press(e) {
+    this.held || (this.held = e, this.enqueue(e, !0), this.timeout = setTimeout(() => this.release(), 1e4));
+  }
+  release() {
+    if (!this.held) return;
+    clearTimeout(this.timeout);
+    const e = this.held;
+    this.held = void 0, this.enqueue(e, !1);
+  }
+  enqueue(e, n) {
+    this.tail = this.tail.then(() => this.send(e, n)).catch(this.failed);
+  }
+}
+const rt = "Accessibility unavailable on this device.", Ge = 500, Kt = (t, e) => Math.abs(t.x - e.x) < 0.5 && Math.abs(t.y - e.y) < 0.5 && Math.abs(t.width - e.width) < 0.5 && Math.abs(t.height - e.height) < 0.5, Jt = (t) => Math.max(0, t.width) * Math.max(0, t.height), jt = (t) => {
+  const e = t.find((n) => n.frame && n.frame.width > 0 && n.frame.height > 0);
+  return e?.frame ? ((Math.abs(e.frame.x) > 0.5 || Math.abs(e.frame.y) > 0.5) && console.warn(
+    `[ax-tree] iOS root frame is not anchored at (0,0): (${e.frame.x},${e.frame.y}). Element positions may be slightly off from the rendered video.`
+  ), { x: 0, y: 0, width: e.frame.width, height: e.frame.height }) : { x: 0, y: 0, width: 1, height: 1 };
+}, Xt = (t) => {
+  const e = {};
+  return typeof t.AXUniqueId == "string" && t.AXUniqueId.length > 0 && (e.AXUniqueId = t.AXUniqueId), typeof t.AXLabel == "string" && t.AXLabel.length > 0 && (e.AXLabel = t.AXLabel), typeof t.type == "string" && t.type.length > 0 && (e.className = t.type), e;
+}, Qt = (t) => {
+  const e = {};
+  for (const [n, s] of Object.entries(t))
+    n !== "children" && (e[n] = s);
+  return e;
+};
+function zt(t) {
+  const e = Array.isArray(t) ? t : [t], n = jt(e), s = [], E = (d, c) => {
+    if (s.length >= Ge) return;
+    const h = d.frame;
+    if (h && h.width > 0 && h.height > 0 && !Kt(h, n)) {
+      const p = d.role_description || d.role || "", K = (typeof d.AXLabel == "string" ? d.AXLabel : "") || (typeof d.title == "string" ? d.title : "") || "";
+      s.push({
+        id: typeof d.AXUniqueId == "string" && d.AXUniqueId.length > 0 ? d.AXUniqueId : c,
+        path: c,
+        label: K,
+        value: typeof d.AXValue == "string" ? d.AXValue : "",
+        role: p,
+        type: typeof d.type == "string" ? d.type : "",
+        enabled: d.enabled !== !1,
+        focused: d.focused === !0,
+        frame: { x: h.x, y: h.y, width: h.width, height: h.height },
+        selectors: Xt(d),
+        raw: Qt(d)
+      });
+    }
+    const C = Array.isArray(d.children) ? d.children : [];
+    for (let p = 0; p < C.length && s.length < Ge; p++)
+      E(C[p], `${c}.${p}`);
+  };
+  for (let d = 0; d < e.length && s.length < Ge; d++)
+    E(e[d], String(d));
+  return {
+    platform: "ios",
+    screen: { width: n.width, height: n.height },
+    elements: s,
+    capturedAt: Date.now()
+  };
+}
+const Zt = (t) => {
+  let e = { x: 0, y: 0, width: 1, height: 1 }, n = 0;
+  for (const s of t) {
+    const E = s.parsedBounds;
+    if (!E) continue;
+    const d = E.right - E.left, c = E.bottom - E.top, h = Math.max(0, d) * Math.max(0, c);
+    h > n && (n = h, e = { x: 0, y: 0, width: d, height: c });
+  }
+  return e;
+}, en = (t) => {
+  const e = {};
+  return typeof t.resourceId == "string" && t.resourceId.length > 0 && (e.resourceId = t.resourceId), typeof t.contentDesc == "string" && t.contentDesc.length > 0 && (e.contentDesc = t.contentDesc), typeof t.text == "string" && t.text.length > 0 && (e.text = t.text), typeof t.className == "string" && t.className.length > 0 && (e.className = t.className), e;
+};
+function tn(t) {
+  const e = Zt(t), n = [];
+  for (let s = 0; s < t.length && n.length < Ge; s++) {
+    const E = t[s], d = E.parsedBounds;
+    if (!d) continue;
+    const c = Math.max(0, d.right - d.left), h = Math.max(0, d.bottom - d.top);
+    if (c <= 0 || h <= 0) continue;
+    const C = { x: d.left, y: d.top, width: c, height: h };
+    if (Kt(C, { x: 0, y: 0, width: e.width, height: e.height })) continue;
+    const p = E.contentDesc || E.text || "", K = E.className || "";
+    n.push({
+      id: E.resourceId && E.resourceId.length > 0 ? E.resourceId : E.contentDesc && E.contentDesc.length > 0 ? `cd:${E.contentDesc}` : String(s),
+      path: String(s),
+      label: p,
+      value: typeof E.text == "string" ? E.text : "",
+      role: K,
+      type: K,
+      enabled: E.enabled !== !1,
+      focused: E.focused === !0,
+      frame: C,
+      selectors: en(E),
+      raw: { ...E }
+    });
+  }
+  return {
+    platform: "android",
+    screen: { width: e.width, height: e.height },
+    elements: n,
+    capturedAt: Date.now()
+  };
+}
+function xn(t, e) {
+  const n = Math.max(0, t.x), s = Math.max(0, t.y), E = Math.min(e.width, t.x + t.width), d = Math.min(e.height, t.y + t.height), c = Math.max(0, E - n), h = Math.max(0, d - s);
+  return c > 0 && h > 0 ? { x: n, y: s, width: c, height: h } : null;
+}
+function nn(t, e) {
+  if (t === e) return !0;
+  if (t.id !== e.id || t.path !== e.path || t.label !== e.label || t.value !== e.value || t.role !== e.role || t.type !== e.type || t.enabled !== e.enabled || t.focused !== e.focused) return !1;
+  const n = t.frame, s = e.frame;
+  return n.x === s.x && n.y === s.y && n.width === s.width && n.height === s.height;
+}
+function rn(t, e) {
+  if (t === e) return !0;
+  if (!t || !e || t.platform !== e.platform || t.screen.width !== e.screen.width || t.screen.height !== e.screen.height || t.elements.length !== e.elements.length) return !1;
+  for (let n = 0; n < t.elements.length; n++)
+    if (!nn(t.elements[n], e.elements[n])) return !1;
+  return !0;
+}
+function Wn(t, e, n) {
+  let s = null, E = 1 / 0;
+  for (const d of t.elements) {
+    const c = d.frame;
+    if (e < c.x || n < c.y || e > c.x + c.width || n > c.y + c.height) continue;
+    const h = Jt(c);
+    h < E && (E = h, s = d);
+  }
+  return s;
+}
+function qn(t, e) {
+  if (e === "ios") {
+    if (t.selectors.AXUniqueId)
+      return `client.tapElement({ AXUniqueId: ${JSON.stringify(t.selectors.AXUniqueId)} })`;
+    if (t.selectors.AXLabel) {
+      const n = t.selectors.className ? `, type: ${JSON.stringify(t.selectors.className)}` : "";
+      return `client.tapElement({ AXLabel: ${JSON.stringify(t.selectors.AXLabel)}${n} })`;
+    }
+    return null;
+  }
+  return t.selectors.resourceId ? `client.tap({ selector: { resourceId: ${JSON.stringify(t.selectors.resourceId)} } })` : t.selectors.contentDesc ? `client.tap({ selector: { contentDesc: ${JSON.stringify(t.selectors.contentDesc)} } })` : t.selectors.text ? `client.tap({ selector: { text: ${JSON.stringify(t.selectors.text)} } })` : null;
+}
+function on(t) {
+  const e = t.role || t.type || "";
+  if (!e) return "element";
+  let n = e.replace(/^AX/, "");
+  return n.includes(".") && (n = n.split(".").pop()), n === "GenericElement" ? "Element" : (n = n.replace(/([a-z])([A-Z])/g, "$1 $2"), n);
+}
+const Dt = 80;
+function $n(t) {
+  const e = on(t), n = t.label || t.value || "";
+  if (!n) return e;
+  const s = n.length > Dt ? n.slice(0, Dt).trimEnd() + "…" : n;
+  return `${e} · ${s}`;
+}
+const an = 500, sn = 2e3, gt = 5e3, cn = 8e3, ln = 1200, dn = 250, un = () => `ax-rc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+class En {
+  platform;
+  send;
+  onSnapshot;
+  onStatusChange;
+  baseIntervalMs;
+  maxBackoffMs;
+  androidElementTreeOptions;
+  pending = /* @__PURE__ */ new Map();
+  running = !1;
+  timer;
+  currentInterval;
+  lastSnapshot = null;
+  // Single-flight: only one outstanding request at a time. Avoids piling
+  // identical requests on a slow server.
+  inflight = !1;
+  // Rate-limit floor for bumpActivity so high-frequency input (drags,
+  // typing) doesn't trigger a request storm.
+  lastBumpAtMs = 0;
+  // Wall-clock timestamp until which we're in "activity boost" mode and
+  // schedule fetches at ACTIVITY_BOOST_INTERVAL_MS instead of the normal
+  // backed-off interval. Set by bumpActivity().
+  boostUntilMs = 0;
+  // Coarse-grained current status; deduplicated before emission so
+  // identical-to-current transitions are no-ops.
+  status = "idle";
+  constructor(e) {
+    this.platform = e.platform, this.send = e.send, this.onSnapshot = e.onSnapshot, this.onStatusChange = e.onStatusChange, this.baseIntervalMs = e.baseIntervalMs ?? an, this.maxBackoffMs = e.maxBackoffMs ?? sn, this.androidElementTreeOptions = e.androidElementTreeOptions, this.currentInterval = this.baseIntervalMs;
+  }
+  start() {
+    this.running || (this.running = !0, this.currentInterval = this.baseIntervalMs, this.boostUntilMs = 0, this.setStatus("starting"), this.runOnce());
+  }
+  stop() {
+    this.running && (this.running = !1, this.timer !== void 0 && (window.clearTimeout(this.timer), this.timer = void 0), this.failAllPending("Inspector stopped"), this.lastSnapshot = null, this.setStatus("idle"), this.onSnapshot(null));
+  }
+  getStatus() {
+    return this.status;
+  }
+  setStatus(e, n) {
+    if (this.status !== e && (this.status = e, !!this.onStatusChange))
+      try {
+        this.onStatusChange(e, n);
+      } catch (s) {
+        console.error("[AxFetcher] onStatusChange threw:", s);
+      }
+  }
+  // Called after any user-driven action that's likely to change the UI
+  // (taps, scrolls, key events, openUrl, app termination, orientation
+  // change, etc.). Has two effects:
+  //
+  //   1. Resets the polling interval to base and triggers an immediate
+  //      fetch (rate-limited so drags / rapid typing don't request-storm).
+  //   2. Enters a brief "boost" window during which scheduleNext() uses a
+  //      shorter interval (ACTIVITY_BOOST_INTERVAL_MS), so we capture the
+  //      mid- and post-animation tree without waiting for the next
+  //      back-off cycle.
+  bumpActivity() {
+    if (!this.running) return;
+    const e = Date.now();
+    this.boostUntilMs = e + ln;
+    const n = Math.max(150, Math.floor(this.baseIntervalMs / 2));
+    if (e - this.lastBumpAtMs < n) {
+      this.currentInterval = this.baseIntervalMs;
+      return;
+    }
+    this.lastBumpAtMs = e, this.currentInterval = this.baseIntervalMs, this.timer !== void 0 && (window.clearTimeout(this.timer), this.timer = void 0), this.inflight || this.runOnce();
+  }
+  // Fire a one-shot fetch independent of the poll loop. Useful for the
+  // imperative refresh() ref method customers may call.
+  //
+  // Goes through the same change-detect path as the regular poll loop —
+  // identical-to-last-snapshot responses do NOT re-emit via onSnapshot, so
+  // a customer calling refresh() in a tight loop doesn't see a stream of
+  // duplicate snapshots. The returned promise still resolves with the
+  // (possibly identical) snapshot for the caller's own use.
+  async refresh() {
+    const e = await this.requestOnce();
+    return this.running && this.deliver(e), e;
+  }
+  // Returns the latest snapshot delivered to onSnapshot. May be stale.
+  getLatest() {
+    return this.lastSnapshot;
+  }
+  // Called by RemoteControl's ws.onmessage when it sees a message type we own.
+  // Returns true when the message was a response we were waiting for.
+  handleMessage(e) {
+    if (!e || typeof e.id != "string") return !1;
+    const n = e.id;
+    if (!this.pending.get(n)) return !1;
+    if (this.platform === "ios") {
+      if (e.type !== "elementTreeResult") return !1;
+      const h = typeof e.error == "string" ? e.error : null;
+      if (h)
+        return this.settleReject(n, new Error(h)), !0;
+      const C = typeof e.json == "string" ? e.json : "";
+      try {
+        const p = JSON.parse(C), K = zt(p);
+        this.settleResolve(n, K);
+      } catch (p) {
+        this.settleReject(n, p instanceof Error ? p : new Error(String(p)));
+      }
+      return !0;
+    }
+    if (e.type !== "getElementTreeResult") return !1;
+    const E = e.error;
+    if (E && typeof E == "object") {
+      const h = typeof E.message == "string" ? E.message : "getElementTree failed";
+      return this.settleReject(n, new Error(h)), !0;
+    }
+    const d = e.payload, c = Array.isArray(d?.nodes) ? d.nodes : [];
+    try {
+      const h = tn(c);
+      this.settleResolve(n, h);
+    } catch (h) {
+      this.settleReject(n, h instanceof Error ? h : new Error(String(h)));
+    }
+    return !0;
+  }
+  buildRequest(e) {
+    return this.platform === "ios" ? { type: "elementTree", id: e } : { type: "getElementTree", id: e, ...this.androidElementTreeOptions };
+  }
+  async requestOnce() {
+    const e = un();
+    return new Promise((n, s) => {
+      const E = window.setTimeout(
+        () => {
+          this.pending.delete(e), s(new Error("elementTree request timed out"));
+        },
+        cn + (this.androidElementTreeOptions?.waitForIdleTimeoutMs ?? 0)
+      );
+      this.pending.set(e, { resolve: n, reject: s, timer: E }), this.send(this.buildRequest(e)) || (window.clearTimeout(E), this.pending.delete(e), s(new Error("elementTree send failed (WebSocket not open)")));
+    });
+  }
+  async runOnce() {
+    if (this.running && !this.inflight) {
+      this.inflight = !0;
+      try {
+        const e = await this.requestOnce();
+        if (!this.running) return;
+        this.deliver(e);
+      } catch (e) {
+        if (!this.running) return;
+        const n = e instanceof Error ? e.message : String(e), s = /unavailable|not (yet )?running|failed|timeout/i.test(n);
+        this.currentInterval = s ? gt : Math.min(this.currentInterval * 2, this.maxBackoffMs), this.setStatus(s ? "unavailable" : "error", n);
+      } finally {
+        this.inflight = !1, this.scheduleNext();
+      }
+    }
+  }
+  deliver(e) {
+    const n = this.lastSnapshot;
+    if (rn(n, e)) {
+      this.currentInterval = Math.min(this.currentInterval * 2, this.maxBackoffMs), this.lastSnapshot = e, e.errors?.includes(rt) || this.setStatus("ready");
+      return;
+    }
+    this.lastSnapshot = e, this.currentInterval = this.baseIntervalMs, e.errors?.includes(rt) ? (this.currentInterval = gt, this.setStatus("unavailable", rt)) : this.setStatus("ready"), this.onSnapshot(e);
+  }
+  scheduleNext() {
+    if (!this.running) return;
+    this.timer !== void 0 && window.clearTimeout(this.timer);
+    const e = Date.now() < this.boostUntilMs ? Math.min(dn, this.currentInterval) : this.currentInterval;
+    this.timer = window.setTimeout(() => {
+      this.timer = void 0, this.runOnce();
+    }, e);
+  }
+  settleResolve(e, n) {
+    const s = this.pending.get(e);
+    s && (window.clearTimeout(s.timer), this.pending.delete(e), s.resolve(n));
+  }
+  settleReject(e, n) {
+    const s = this.pending.get(e);
+    s && (window.clearTimeout(s.timer), this.pending.delete(e), s.reject(n));
+  }
+  failAllPending(e) {
+    for (const [n, s] of this.pending.entries())
+      window.clearTimeout(s.timer), s.reject(new Error(e)), this.pending.delete(n);
+  }
+}
+function Tt(t, e) {
+  if (e != null && (!Number.isFinite(e) || e < 0 || e > 4e3)) {
+    console.warn("RemoteControl: jitterBufferTargetMs must be a finite number between 0 and 4000.");
+    return;
+  }
+  if (!("jitterBufferTarget" in t)) return;
+  const n = e ?? null;
+  try {
+    t.jitterBufferTarget !== n && (t.jitterBufferTarget = n);
+  } catch (s) {
+    console.warn("RemoteControl: could not set the jitter buffer target.", s);
+  }
+}
+const At = `(function(){"use strict";let e,t;self.onmessage=async({data:s})=>{s.type==="start"?(e=new AbortController,t=s.readable.pipeTo(s.writable,{signal:e.signal}).catch(o=>{e?.signal.aborted||self.postMessage({type:"error",message:String(o)})})):s.type==="stop"&&(e?.abort(),await t,self.postMessage({type:"stopped"}),self.close())}})();
+`, St = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", At], { type: "text/javascript;charset=utf-8" });
+function fn(t) {
+  let e;
+  try {
+    if (e = St && (self.URL || self.webkitURL).createObjectURL(St), !e) throw "";
+    const n = new Worker(e, {
+      name: t?.name
+    });
+    return n.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(e);
+    }), n;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(At),
+      {
+        name: t?.name
+      }
+    );
+  }
+}
+function hn(t, e, n) {
+  const { MediaStreamTrackProcessor: s, MediaStreamTrackGenerator: E } = globalThis, d = e.getVideoTracks()[0];
+  let c, h, C, p, K = !1;
+  const w = () => {
+    K || (K = !0, c?.stop(), h?.stop(), C && (C.postMessage({ type: "stop" }), p = setTimeout(() => C?.terminate(), 1e3)));
+  }, U = (b) => {
+    t.srcObject = b, t.play().catch(() => {
+    });
+  }, T = (b) => {
+    K || (w(), n(b), U(e));
+  };
+  try {
+    if (d && s && E) {
+      c = d.clone();
+      const b = new s({ track: c, maxBufferSize: 1 }), $ = new E({ kind: "video" });
+      h = $, C = new fn(), C.onmessage = ({ data: F }) => {
+        F.type === "error" ? T(new Error(F.message)) : F.type === "stopped" && (clearTimeout(p), C?.terminate());
+      }, C.onerror = (F) => T(new Error(F.message)), C.postMessage({ type: "start", readable: b.readable, writable: $.writable }, [
+        b.readable,
+        $.writable
+      ]), U(new MediaStream(e.getTracks().map((F) => F === d ? $ : F)));
+    } else
+      U(e);
+  } catch (b) {
+    T(b);
+  }
+  return w;
+}
+function Ne(t) {
+  return typeof t == "number" && Number.isFinite(t);
+}
+function ge(t, e) {
+  if (!(!Ne(t) || !Ne(e) || t < e || e < 0))
+    return t - e;
+}
+class mn {
+  previous = /* @__PURE__ */ new Map();
+  reset() {
+    this.previous.clear();
+  }
+  read(e, n, s) {
+    const E = { timestamp: 0, video: [], audio: [] };
+    s == null ? E.requestedTargetMs = null : Ne(s) && s >= 0 && s <= 4e3 && (E.requestedTargetMs = s);
+    const d = /* @__PURE__ */ new Map();
+    return e.forEach((c) => {
+      if (c.type !== "inbound-rtp" || !Ne(c.timestamp)) return;
+      const h = c.kind ?? c.mediaType;
+      if (h !== "video" && h !== "audio") return;
+      const C = n.filter((Y) => Y.kind === h), p = c.trackIdentifier ? C.find((Y) => Y.trackId === c.trackIdentifier) : c.mid != null ? C.find((Y) => Y.mid === c.mid) : C.length === 1 ? C[0] : void 0;
+      if (!p) return;
+      const K = this.previous.get(c.id), U = K?.trackId === p.trackId && K.stats.ssrc === c.ssrc ? K.stats : void 0, T = U ? c.timestamp - U.timestamp : void 0, b = {
+        id: c.id,
+        trackId: p.trackId,
+        timestamp: c.timestamp
+      };
+      if (T !== void 0 && T > 0) {
+        b.intervalMs = T;
+        const Y = ge(c.jitterBufferEmittedCount, U?.jitterBufferEmittedCount), P = ge(c.jitterBufferDelay, U?.jitterBufferDelay);
+        Y !== void 0 && Y > 0 && P !== void 0 && (b.bufferDelayMs = P / Y * 1e3);
+        const V = ge(c.bytesReceived, U?.bytesReceived);
+        V !== void 0 && (b.bitrateBps = V * 8e3 / T);
+      }
+      if (h === "video") {
+        const Y = { ...b, display: p.display ?? "primary" };
+        if (b.intervalMs !== void 0) {
+          const P = ge(c.framesDecoded, U?.framesDecoded);
+          P !== void 0 && (Y.fps = P * 1e3 / b.intervalMs), Y.droppedFrames = ge(c.framesDropped, U?.framesDropped), Y.freezes = ge(c.freezeCount, U?.freezeCount);
+        }
+        E.video.push(Y);
+      } else E.audio.push(b);
+      E.timestamp = Math.max(E.timestamp, c.timestamp), d.set(
+        c.id,
+        U && c.timestamp <= U.timestamp ? K : { stats: c, trackId: p.trackId }
+      );
+      const $ = c.transportId ? e.get(c.transportId) : void 0, F = $?.selectedCandidatePairId ? e.get($.selectedCandidatePairId) : void 0;
+      F?.state === "succeeded" && Ne(F.currentRoundTripTime) && F.currentRoundTripTime >= 0 && (E.rttMs = F.currentRoundTripTime * 1e3);
+    }), this.previous = d, E.video.length || E.audio.length ? E : null;
+  }
+}
+const it = /* @__PURE__ */ new WeakSet();
+function pn(t, e, n) {
+  const { peer: s, displays: E } = t, d = new mn();
+  let c, h = !1, C = !1, p = !1, K = 0, w = !1, U = !1;
+  const T = () => !h && !document.hidden && s.connectionState === "connected", b = (P) => {
+    if (!(!P && !w)) {
+      w = P !== null;
+      try {
+        e()?.(P);
+      } catch (V) {
+        console.error('[RemoteControl] customer callback "onPlaybackStats" threw:', V);
+      }
+    }
+  }, $ = () => {
+    C = !1, K++, clearTimeout(c), d.reset(), b(null);
+  }, F = async () => {
+    if (p || !T()) return;
+    if (it.has(s)) {
+      c = setTimeout(() => {
+        F();
+      }, 2e3);
+      return;
+    }
+    p = !0, it.add(s);
+    const P = K;
+    try {
+      const V = await s.getStats();
+      if (P !== K || !T()) return;
+      const B = s.getTransceivers().filter(
+        (J) => (J.currentDirection === "recvonly" || J.currentDirection === "sendrecv") && J.receiver.track.readyState !== "ended"
+      ).map((J) => ({
+        trackId: J.receiver.track.id,
+        kind: J.receiver.track.kind,
+        mid: J.mid,
+        display: E.get(J.receiver)
+      }));
+      b(d.read(V, B, n())), U = !1;
+    } catch (V) {
+      if (P !== K || !T()) return;
+      U || console.warn("[RemoteControl] could not read playback stats:", V), U = !0, d.reset(), b(null);
+    } finally {
+      p = !1, it.delete(s), C && T() && (c = setTimeout(
+        () => {
+          F();
+        },
+        P === K ? 2e3 : 0
+      ));
+    }
+  }, Y = () => {
+    if (!T()) {
+      $();
+      return;
+    }
+    C || (C = !0, F());
+  };
+  return document.addEventListener("visibilitychange", Y), s.addEventListener("connectionstatechange", Y), Y(), () => {
+    h = !0, document.removeEventListener("visibilitychange", Y), s.removeEventListener("connectionstatechange", Y), $();
+  };
+}
+function Cn(t, e) {
+  const n = t.createDataChannel("latency-trace-v1", {
+    ordered: !0,
+    negotiated: !0,
+    id: 2
+  });
+  let s = !1, E = !1, d = 0;
+  return n.onmessage = (c) => {
+    if (E) return;
+    let h;
+    try {
+      h = JSON.parse(c.data);
+    } catch (C) {
+      console.warn("Invalid latency trace message", C);
+      return;
+    }
+    h && typeof h == "object" && !Array.isArray(h) && e(h);
+  }, n.onclose = () => {
+    E = !0, s = !1;
+  }, {
+    accept(c) {
+      s = !E && c === 1;
+    },
+    wrap(c) {
+      if (!s || c.byteLength !== 32) return c;
+      const h = new DataView(c);
+      if (h.getUint8(0) !== 2 || h.getUint8(1) > 2) return c;
+      const C = new ArrayBuffer(38), p = new DataView(C);
+      return p.setUint8(0, 240), p.setUint8(1, 1), p.setUint32(2, ++d, !0), new Uint8Array(C, 6).set(new Uint8Array(c)), C;
+    },
+    close() {
+      E = !0, s = !1, n.onmessage = null, n.onclose = null, n.close();
+    }
+  };
+}
+class On {
+  generation = 0;
+  tail = Promise.resolve();
+  get currentGeneration() {
+    return this.generation;
+  }
+  enqueue(e) {
+    const n = ++this.generation;
+    return this.append(n, e);
+  }
+  /**
+   * Queues related work without superseding an already queued request.
+   *
+   * The operation retains the generation current at enqueue time and becomes
+   * stale if a later camera request increments it before this work starts.
+   */
+  enqueueCurrent(e) {
+    return this.append(this.generation, e);
+  }
+  append(e, n) {
+    const s = {
+      generation: e,
+      isCurrent: () => e === this.generation
+    }, E = this.tail.then(() => n(s));
+    return this.tail = E.catch(() => {
+    }), E;
+  }
+  invalidate() {
+    ++this.generation;
+  }
+}
+function _n(t) {
+  if (!t || typeof t != "object") return null;
+  const e = t;
+  if (e.type !== "cameraRequest" || typeof e.active != "boolean") return null;
+  const n = { active: e.active };
+  return (e.facingMode === "user" || e.facingMode === "environment") && (n.facingMode = e.facingMode), n;
+}
+function Dn(t) {
+  const e = {
+    frameRate: { ideal: 30, max: 30 }
+  };
+  return t?.facingMode && (e.facingMode = { ideal: t.facingMode }), e;
+}
+function gn(t, e) {
+  return !t || t.facingMode !== e.facingMode;
+}
+function Tn(t) {
+  const e = t.getSettings();
+  return {
+    width: e.width,
+    height: e.height,
+    frameRate: e.frameRate,
+    deviceId: e.deviceId,
+    label: t.label || void 0,
+    facingMode: e.facingMode
+  };
+}
+function Sn(t) {
+  return {
+    type: "cameraResult",
+    granted: !0,
+    camera: Tn(t)
+  };
+}
+const ce = (...t) => {
+  window.debugRemoteControl && console.log(...t);
+}, S = (...t) => {
+  window.debugRemoteControl && console.warn(...t);
+}, L = (t, e, ...n) => {
+  if (e)
+    try {
+      e(...n);
+    } catch (s) {
+      console.error(`[RemoteControl] customer callback "${t}" threw:`, s);
+    }
+}, yn = (t) => t.includes("/android_") ? "android" : "ios", yt = (t, e) => {
+  const n = new URL(t);
+  return n.searchParams.set("token", e), n.toString();
+}, ot = 3, vn = 1e3, Kn = 15e3, An = 3e3, Mn = 4e3;
+function vt() {
+  const t = crypto.getRandomValues(new Uint8Array(16));
+  t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128;
+  const e = Array.from(t, (n) => n.toString(16).padStart(2, "0")).join("");
+  return `${e.slice(0, 8)}-${e.slice(8, 12)}-${e.slice(12, 16)}-${e.slice(16, 20)}-${e.slice(20)}`;
+}
+function Vn(t) {
+  let e = { ...t };
+  const { url: n, token: s, deviceModel: E } = e, d = e.sessionId ?? vt(), c = e.platform ?? yn(n ?? "");
+  let h = {
+    connection: "idle",
+    videoReady: !1,
+    controlReady: !1,
+    duo: !1,
+    duoState: null
+  };
+  const C = (r) => {
+    h = { ...h, ...r }, L("onStateChange", e.onStateChange, h);
+  }, p = (r) => C({ videoReady: r }), K = (r) => C({ duoState: r }), w = (r) => C({ duoError: r }), U = (r) => C({ duo: r }), T = (r) => ce(r);
+  let b = null, $;
+  const F = () => {
+    $?.(), $ = b && e.onPlaybackStats ? pn(
+      b,
+      () => e.onPlaybackStats,
+      () => e.jitterBufferTargetMs
+    ) : void 0;
+  }, Y = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Set(), V = /* @__PURE__ */ new Set(), B = /* @__PURE__ */ new Map();
+  let J = !1;
+  const Re = /* @__PURE__ */ new Map(), at = (r, u, a) => {
+    u.stop?.(), u.stop = hn(r, a, (l) => S("Video playback fallback:", l));
+  }, Mt = () => {
+    Re.clear();
+    for (const [r, u] of Y)
+      u.clear?.(), u.stop?.(), u.stop = void 0, r.srcObject = null;
+  };
+  let Ee = !1, Te = !1, Ie = 0, D = null, N = null, x = null, ke = null, fe, Se, ye, Ue, he, le = 0, Pe = 0, ne = !1, de = null, z = null, ue;
+  const je = new On();
+  let ve = null, Le = null, Xe = e.microphoneEnabled ?? !1, Qe = !1, Ke = null, te = null, Fe = 0, st = Promise.resolve(), me = null, Ae = !1, re = /* @__PURE__ */ new Map(), ee = /* @__PURE__ */ new Map(), ae = /* @__PURE__ */ new Map(), ie = /* @__PURE__ */ new Map(), q = null, Me = null, ct = 0;
+  const Be = (r) => {
+    if (r === null && Me === null) return;
+    Me = r;
+    const u = ++ct;
+    queueMicrotask(() => {
+      u === ct && L("onAxSnapshotChange", e.onAxSnapshotChange, r);
+    });
+  };
+  let pe = null, Ce = /* @__PURE__ */ new Map();
+  const wt = (r, u) => new Promise((a, l) => {
+    const y = D;
+    if (!y || y.readyState !== WebSocket.OPEN) {
+      l(new Error("Simulator disconnected"));
+      return;
+    }
+    const m = vt(), O = setTimeout(() => {
+      Ce.delete(m), l(new Error("Device control timed out"));
+    }, 5e3);
+    Ce.set(m, { resolve: a, reject: l, timer: O }), y.send(JSON.stringify({ type: r, id: m, ...u }));
+  }), Oe = (r) => {
+    pe !== r && (pe = r, C({ connection: r }), L("onConnectionStateChange", e.onConnectionStateChange, r));
+  }, se = (r) => {
+    !x || x.readyState !== "open" || (x.send(ke?.wrap(r) ?? r), q?.bumpActivity());
+  }, Yt = () => {
+    D && D.readyState === WebSocket.OPEN && D.send(
+      JSON.stringify({
+        type: "keepAlive",
+        sessionId: d
+      })
+    );
+  }, lt = () => {
+    fe && window.clearInterval(fe), fe = window.setInterval(Yt, 1e4);
+  }, we = () => {
+    fe && (window.clearInterval(fe), fe = void 0);
+  }, xe = () => {
+    Se && (window.clearTimeout(Se), Se = void 0);
+  }, We = () => {
+    ye && (window.clearTimeout(ye), ye = void 0);
+  }, Ye = () => {
+    Ue && (window.clearInterval(Ue), Ue = void 0);
+  }, be = () => {
+    he !== void 0 && (window.clearTimeout(he), he = void 0);
+  }, bt = () => {
+    Ae || (Ae = !0, Ye(), p(!0), Oe("connected"));
+  }, H = (r) => {
+    for (const u of r.getTracks())
+      try {
+        u.stop();
+      } catch (a) {
+        S("track.stop() failed:", a);
+      }
+  }, Nt = () => {
+    const r = z;
+    r && (z = null, H(r));
+  }, dt = (r) => {
+    const u = st.then(r).catch((a) => {
+      S("microphone operation failed:", a);
+    });
+    return st = u, u;
+  }, ze = () => Xe || Qe, ut = (r) => {
+    const u = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    me = u, r.send(JSON.stringify({ type: "microphoneStart", id: u }));
+  }, Ze = () => dt(() => Rt()), Rt = async () => {
+    const r = Fe, u = () => r === Fe && ze(), a = (f) => {
+      L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+        active: !1,
+        error: f
+      });
+    };
+    if (!u()) return;
+    const l = D, y = Ke;
+    if (!l || l.readyState !== WebSocket.OPEN || !y || te) return;
+    if (!navigator.mediaDevices || typeof navigator.mediaDevices.getUserMedia != "function") {
+      console.warn(
+        "[RemoteControl] navigator.mediaDevices.getUserMedia unavailable. getUserMedia requires a secure context (https or http://localhost)."
+      ), a("Microphone capture requires a secure context (https)");
+      return;
+    }
+    let m = null;
+    try {
+      m = await navigator.mediaDevices.getUserMedia({ audio: !0, video: !1 });
+    } catch (f) {
+      console.warn("[RemoteControl] microphone getUserMedia denied/failed:", f);
+    }
+    if (!u()) {
+      m && H(m);
+      return;
+    }
+    if (!m) {
+      a("Microphone permission denied or no device available");
+      return;
+    }
+    const O = m.getAudioTracks()[0] ?? null;
+    if (!O) {
+      H(m), a("Captured stream has no audio track");
+      return;
+    }
+    try {
+      await y.replaceTrack(O);
+    } catch (f) {
+      S("replaceTrack(audioTrack) failed:", f), H(m), a("Failed to attach the microphone track to the connection");
+      return;
+    }
+    if (!u()) {
+      try {
+        await y.replaceTrack(null);
+      } catch (f) {
+        S("replaceTrack(null) on stale mic attach failed:", f);
+      }
+      H(m);
+      return;
+    }
+    te = m, O.onended = () => {
+      te === m && qe("microphone capture ended by the browser");
+    }, ut(l), L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+      active: !0,
+      label: O.label || void 0
+    });
+  }, qe = (r) => (++Fe, me = null, dt(async () => {
+    const u = Ke, a = te;
+    if (te = null, u && a)
+      try {
+        await u.replaceTrack(null);
+      } catch (y) {
+        S("replaceTrack(null) on mic detach failed:", y);
+      }
+    a && H(a);
+    const l = D;
+    if (a && l && l.readyState === WebSocket.OPEN) {
+      const y = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      l.send(JSON.stringify({ type: "microphoneStop", id: y }));
+    }
+    (a || r) && L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+      active: !1,
+      ...r !== void 0 && { error: r }
+    });
+  })), Et = (r, u) => {
+    let a;
+    try {
+      a = Sn(u), console.info(
+        `[RemoteControl] camera capture: ${a.camera?.width}x${a.camera?.height} @ ${a.camera?.frameRate ?? "?"}fps` + (a.camera?.label ? ` — ${a.camera.label}` : "")
+      );
+    } catch (l) {
+      S("getSettings() on outbound camera track failed:", l), a = {
+        type: "cameraResult",
+        granted: !0,
+        camera: {
+          label: u.label || void 0
+        }
+      };
+    }
+    r.send(JSON.stringify(a)), L("onCameraDemandChange", e.onCameraDemandChange, !0, !0, a.camera);
+  }, It = (r) => {
+    if (!r) return;
+    const u = r.indexOf("/"), l = (u >= 0 ? r.slice(u + 1) : r).toUpperCase();
+    return l === "HEVC" ? "H265" : l;
+  }, kt = async () => {
+    const r = de, u = e.onCameraStats;
+    if (!r || !u) return;
+    let a;
+    try {
+      a = await r.getStats();
+    } catch {
+      return;
+    }
+    let l, y, m;
+    if (a.forEach((R) => {
+      R.type === "outbound-rtp" && R.kind === "video" ? l = R : R.type === "remote-inbound-rtp" && R.kind === "video" && (m = R);
+    }), l?.codecId) {
+      const R = a.get(l.codecId);
+      R && (y = R.mimeType);
+    }
+    if (!l) return;
+    const O = l.timestamp ?? Date.now(), f = Le;
+    let j, k, X;
+    if (f && O > f.timestamp) {
+      const R = (O - f.timestamp) / 1e3;
+      if (typeof l.framesEncoded == "number" && typeof f.framesEncoded == "number" && (j = Math.max(0, (l.framesEncoded - f.framesEncoded) / R)), typeof l.bytesSent == "number" && typeof f.bytesSent == "number" && (k = Math.max(0, (l.bytesSent - f.bytesSent) * 8 / R)), typeof l.packetsSent == "number" && typeof f.packetsSent == "number" && m && typeof m.packetsLost == "number" && typeof f.packetsLost == "number") {
+        const v = l.packetsSent - f.packetsSent, Ve = m.packetsLost - f.packetsLost;
+        v > 0 && (X = Math.max(0, Math.min(100, Ve / v * 100)));
+      }
+    }
+    Le = {
+      timestamp: O,
+      framesEncoded: l.framesEncoded,
+      bytesSent: l.bytesSent,
+      packetsSent: l.packetsSent,
+      packetsLost: m?.packetsLost
+    };
+    const M = {
+      codec: It(y),
+      encoderImplementation: l.encoderImplementation,
+      hardwareAccelerated: typeof l.powerEfficientEncoder == "boolean" ? l.powerEfficientEncoder : void 0,
+      framesPerSecond: j,
+      framesEncoded: l.framesEncoded,
+      bitrateBps: k,
+      width: l.frameWidth,
+      height: l.frameHeight,
+      qualityLimitationReason: l.qualityLimitationReason,
+      rttMs: typeof m?.roundTripTime == "number" ? m.roundTripTime * 1e3 : void 0,
+      packetsLostPct: X
+    };
+    L("onCameraStats", e.onCameraStats, M);
+  }, ft = () => {
+    ve === null && (Le = null, ve = setInterval(() => {
+      kt();
+    }, 1e3));
+  }, $e = () => {
+    ve !== null && (clearInterval(ve), ve = null), Le = null, L("onCameraStats", e.onCameraStats, null);
+  }, Ut = (r, u, a, l) => je.enqueue(async ({ isCurrent: y }) => {
+    const m = () => y() && l() && D === u && de === a;
+    if (!m()) return;
+    if (!r.active) {
+      const M = z;
+      try {
+        await a.replaceTrack(null);
+      } catch (R) {
+        S("replaceTrack(null) on camera detach failed:", R);
+      }
+      if (z === M && (z = null, ue = void 0, M && H(M)), $e(), !m()) return;
+      L("onCameraDemandChange", e.onCameraDemandChange, !1);
+      return;
+    }
+    L("onCameraDemandChange", e.onCameraDemandChange, !0);
+    const O = z, f = O?.getVideoTracks()[0], j = ue;
+    if (f?.readyState === "live" && j && !gn(j, r)) {
+      ue = r, Et(u, f), ft();
+      return;
+    }
+    if (O) {
+      try {
+        await a.replaceTrack(null);
+      } catch (M) {
+        S("replaceTrack(null) before camera switch failed:", M);
+      }
+      if (z === O && (z = null, ue = void 0, H(O)), $e(), !m()) return;
+    }
+    if (!navigator.mediaDevices || typeof navigator.mediaDevices.getUserMedia != "function") {
+      if (console.warn(
+        "[RemoteControl] navigator.mediaDevices.getUserMedia unavailable. getUserMedia requires a secure context (https or http://localhost). Replying cameraResult granted=false so limulator falls back to black frames."
+      ), !m()) return;
+      u.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", e.onCameraDemandChange, !0, !1);
+      return;
+    }
+    let k = null;
+    try {
+      k = await navigator.mediaDevices.getUserMedia({
+        video: Dn(r),
+        audio: !1
+      });
+    } catch (M) {
+      console.warn("[RemoteControl] getUserMedia denied/failed:", M);
+    }
+    if (!m()) {
+      k && H(k);
+      return;
+    }
+    if (!k) {
+      u.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", e.onCameraDemandChange, !0, !1);
+      return;
+    }
+    const X = k.getVideoTracks()[0] ?? null;
+    if (!X) {
+      if (H(k), !m()) return;
+      u.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", e.onCameraDemandChange, !0, !1);
+      return;
+    }
+    try {
+      X.contentHint = "motion";
+    } catch {
+    }
+    try {
+      await a.replaceTrack(X);
+    } catch (M) {
+      if (S("replaceTrack(videoTrack) failed:", M), H(k), !m()) return;
+      u.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", e.onCameraDemandChange, !0, !1);
+      return;
+    }
+    if (!m()) {
+      try {
+        await a.replaceTrack(null);
+      } catch (M) {
+        S("replaceTrack(null) for stale camera attach failed:", M);
+      }
+      H(k);
+      return;
+    }
+    try {
+      const M = a.getParameters();
+      (!M.encodings || M.encodings.length === 0) && (M.encodings = [{}]), M.encodings[0].maxBitrate = 8e6, M.encodings[0].maxFramerate = 30, M.degradationPreference = "maintain-framerate", await a.setParameters(M);
+    } catch (M) {
+      S("setParameters on outbound camera failed:", M);
+    }
+    if (!m()) {
+      try {
+        await a.replaceTrack(null);
+      } catch (M) {
+        S("replaceTrack(null) for stale camera finalize failed:", M);
+      }
+      H(k);
+      return;
+    }
+    z = k, ue = r, X.onended = () => {
+      z === k && je.enqueueCurrent(async ({ isCurrent: M }) => {
+        if (!(!M() || z !== k || !l() || D !== u || de !== a)) {
+          try {
+            await a.replaceTrack(null);
+          } catch (R) {
+            S("replaceTrack(null) after camera ended failed:", R);
+          }
+          !M() || z !== k || !l() || D !== u || de !== a || (z = null, ue = void 0, H(k), $e(), u.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", e.onCameraDemandChange, !0, !1));
+        }
+      }).catch((M) => S("camera ended cleanup failed:", M));
+    }, m() && (Et(u, X), ft());
+  }), _e = () => {
+    for (const r of V) r();
+    V.clear();
+    for (const r of B.values()) clearTimeout(r);
+    B.clear();
+    for (const r of ee.values())
+      r(new Error("Simulator disconnected"));
+    for (const r of ie.values())
+      r(new Error("Simulator disconnected"));
+    ee.clear(), re.clear(), ie.clear(), ae.clear(), $?.(), $ = void 0, Mt(), b = null;
+    for (const r of Ce.values())
+      clearTimeout(r.timer), r.reject(new Error("Simulator disconnected"));
+    Ce.clear(), K(null), C({ controlReady: !1, videoReady: !1 }), We(), be(), Ye(), q && (q.stop(), q = null), Me !== null && Be(null), je.invalidate(), $e(), Nt(), ue = void 0, de = null, ++Fe, Qe = !1, me = null, te && (H(te), te = null, L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+      active: !1
+    })), Ke = null, D && (D.onopen = null, D.onmessage = null, D.onerror = null, D.onclose = null, D.close(), D = null), ke?.close(), ke = null, N && (N.onconnectionstatechange = null, N.oniceconnectionstatechange = null, N.ontrack = null, N.onicecandidate = null, N.close(), N = null), x && (x.onopen = null, x.onclose = null, x.onerror = null, x.close(), x = null);
+  }, ht = () => {
+    document.hidden ? we() : lt();
+  }, Pt = async () => {
+    if (e.transport) return e.transport.isTerminated?.() ?? !1;
+    if (typeof navigator < "u" && navigator.onLine === !1)
+      return !1;
+    let r;
+    try {
+      const l = new URL(n);
+      l.protocol = l.protocol === "wss:" ? "https:" : l.protocol === "ws:" ? "http:" : l.protocol, r = yt(l.toString(), s);
+    } catch {
+      return !1;
+    }
+    const u = new AbortController(), a = window.setTimeout(() => u.abort(), Mn);
+    try {
+      return (await fetch(r, { method: "GET", cache: "no-store", signal: u.signal })).status === 404;
+    } catch {
+      return !1;
+    } finally {
+      window.clearTimeout(a);
+    }
+  }, Lt = () => {
+    Ee || (Ee = !0, le += 1, xe(), We(), be(), _e(), T("Instance terminated"), we(), Oe("terminated"), L("onTerminated", e.onTerminated));
+  }, Ft = () => {
+    if (Ee || Te) return;
+    Te = !0;
+    const r = Ie;
+    Pt().catch(() => !1).then((u) => {
+      r === Ie && (Te = !1, u && Lt());
+    });
+  }, De = (r, u) => {
+    if (Ee || u !== le)
+      return;
+    if (Ft(), ne) {
+      if (!e.autoReconnect) {
+        T(`Connection failed after it was established: ${r}`), we(), Oe("failed"), _e();
+        return;
+      }
+      T(`Reconnecting after established session dropped: ${r}`), ne = !1, Pe = -1;
+    }
+    xe();
+    const a = Pe + 1;
+    if (a >= ot) {
+      T(`Connection failed after ${ot} attempts: ${r}`), we(), Oe("failed"), _e();
+      return;
+    }
+    T(`Retrying connection (${a + 1}/${ot})`), Oe("reconnecting"), _e(), Se = window.setTimeout(() => {
+      Se = void 0, u === le && mt(a);
+    }, vn);
+  }, mt = async (r = 0) => {
+    const { openUrl: u, axPollIntervalMs: a, axMaxBackoffMs: l, androidElementTreeOptions: y } = e;
+    if (Ee) return;
+    const m = le + 1;
+    le = m, Pe = r, ne = !1, r === 0 && pe !== "reconnecting" && Oe("connecting"), xe(), We(), Ye(), Ae = !1, p(!1), _e();
+    const O = () => m === le;
+    ye = window.setTimeout(() => {
+      ye = void 0, !(!O() || ne) && De("Connection did not succeed within 15 seconds", m);
+    }, Kn);
+    try {
+      const f = e.transport ? await e.transport.connect() : new WebSocket(yt(n, s));
+      if (!O()) {
+        f.close();
+        return;
+      }
+      if (D = f, await new Promise((_, o) => {
+        let I = !1;
+        const W = () => A(() => o(new Error("Connection stopped")));
+        V.add(W);
+        const g = window.setTimeout(
+          () => A(() => o(new Error("WebSocket connection timeout"))),
+          3e4
+        ), A = (Z) => {
+          I || (I = !0, V.delete(W), window.clearTimeout(g), Z());
+        };
+        f.onopen = () => {
+          !O() || D !== f || A(_);
+        }, f.onerror = (Z) => {
+          !O() || D !== f || (T("WebSocket error: " + Z), A(() => o(new Error("WebSocket connection failed"))));
+        }, f.onclose = () => {
+          !O() || D !== f || (T("WebSocket closed"), A(() => o(new Error("WebSocket closed before connection was established"))));
+        }, f.readyState === WebSocket.OPEN ? A(_) : f.readyState !== WebSocket.CONNECTING && A(() => o(new Error("WebSocket is closed")));
+      }), !O() || D !== f)
+        return;
+      f.onerror = (_) => {
+        !O() || D !== f || T("WebSocket error: " + _);
+      }, f.onclose = () => {
+        !O() || D !== f || T("WebSocket closed");
+      };
+      const j = new Promise((_, o) => {
+        let I = !1;
+        const W = () => g(() => o(new Error("Connection stopped")));
+        V.add(W);
+        const g = (G) => {
+          I || (I = !0, V.delete(W), window.clearTimeout(A), f.removeEventListener("message", Z), G());
+        }, A = window.setTimeout(
+          () => g(() => o(new Error("RTCConfiguration timeout"))),
+          3e4
+        ), Z = (G) => {
+          if (!(!O() || D !== f))
+            try {
+              const Q = JSON.parse(G.data);
+              if (Q.type === "signalingError" && Q.requestType === "requestRtcConfiguration" && Q.sessionId === d) {
+                const Wt = typeof Q.error == "string" ? Q.error : "Unable to load streaming configuration";
+                g(() => o(new Error(Wt)));
+              } else Q.type === "rtcConfiguration" && g(
+                () => _({
+                  rtcConfiguration: Q.rtcConfiguration,
+                  cameraSupported: Q.cameraSupported === !0,
+                  foldSupported: Q.foldSupported === !0
+                })
+              );
+            } catch (Q) {
+              console.error("Error handling RTC configuration:", Q), g(() => o(Q));
+            }
+        };
+        f.addEventListener("message", Z), f.send(
+          JSON.stringify({
+            type: "requestRtcConfiguration",
+            sessionId: d
+          })
+        );
+      }), {
+        rtcConfiguration: k,
+        cameraSupported: X,
+        foldSupported: M
+      } = await j;
+      if (!O() || D !== f)
+        return;
+      const R = E === "iphone-duo" || M;
+      U(R);
+      const v = new RTCPeerConnection({ ...k, iceTransportPolicy: "relay" });
+      N = v;
+      const Ve = { peer: v, displays: /* @__PURE__ */ new Map() };
+      b = Ve, F(), v.addTransceiver("audio", { direction: "recvonly" });
+      const Bt = v.addTransceiver("video", { direction: "recvonly" }), xt = R ? v.addTransceiver("video", { direction: "recvonly" }) : null, _t = c === "ios" || X, et = _t ? v.addTransceiver("video", {
+        direction: "sendonly"
+      }) : null;
+      if (de = et?.sender ?? null, Ke = (_t ? v.addTransceiver("audio", {
+        direction: "sendonly"
+      }) : null)?.sender ?? null, RTCRtpReceiver.getCapabilities) {
+        const _ = RTCRtpReceiver.getCapabilities("video");
+        if (_ && _.codecs) {
+          const I = _.codecs.sort((W, g) => {
+            const A = (Z) => {
+              const G = Z.mimeType.toLowerCase();
+              return G.includes("vp9") ? 1 : G.includes("h265") || G.includes("hevc") ? 2 : G.includes("h264") || G.includes("avc") ? 3 : 4;
+            };
+            return A(W) - A(g);
+          });
+          Bt.setCodecPreferences(I), xt?.setCodecPreferences(I), ce("Set codec preferences:", I.map((W) => W.mimeType).join(", "));
+        }
+      }
+      if (et && RTCRtpSender.getCapabilities) {
+        const _ = RTCRtpSender.getCapabilities("video");
+        if (_ && _.codecs) {
+          const o = /* @__PURE__ */ new Set(["42e01f", "42e028", "640c1f"]), I = (g) => {
+            const A = g.mimeType.toLowerCase(), G = (g.sdpFmtpLine || "").toLowerCase().match(/profile-level-id=([0-9a-f]{6})/), Q = G ? G[1] : "";
+            return A === "video/h265" || A === "video/hevc" ? 1 : A === "video/h264" && o.has(Q) ? 2 : A === "video/h264" ? 3 : A === "video/vp9" ? 4 : A === "video/vp8" ? 5 : A === "video/rtx" || A === "video/red" || A === "video/ulpfec" ? 0 : 6;
+          }, W = [..._.codecs].sort((g, A) => I(g) - I(A));
+          try {
+            et.setCodecPreferences(W), ce(
+              "Outbound camera codec preferences:",
+              W.map((g) => `${g.mimeType}${g.sdpFmtpLine ? `[${g.sdpFmtpLine}]` : ""}`).join(", ")
+            );
+          } catch (g) {
+            S("Failed to set outbound camera codec preferences:", g);
+          }
+        }
+      }
+      const oe = v.createDataChannel("control", {
+        ordered: !0,
+        negotiated: !0,
+        id: 1
+      });
+      x = oe;
+      const tt = !R && e.onTrace ? Cn(v, (_) => {
+        O() && N === v && L("onTrace", e.onTrace, _);
+      }) : null;
+      if (ke = tt, oe.onopen = () => {
+        if (!O() || x !== oe || D !== f)
+          return;
+        ne = !0, C({ controlReady: !0 }), We(), T("Control channel opened"), R && f.send(JSON.stringify({ type: "getFoldState", id: "duo-capabilities" })), q || (q = new En({
+          platform: c,
+          baseIntervalMs: a,
+          maxBackoffMs: l,
+          androidElementTreeOptions: y,
+          send: (o) => {
+            if (!D || D.readyState !== WebSocket.OPEN) return !1;
+            try {
+              return D.send(JSON.stringify(o)), !0;
+            } catch {
+              return !1;
+            }
+          },
+          onSnapshot: Be,
+          onStatusChange: (o, I) => {
+            L("onAxStatusChange", e.onAxStatusChange, o, I);
+          }
+        }), (e.inspectMode === !0 || e.inspectMode === "hover-only") && q.start());
+        const _ = () => {
+          !O() || Ae || x !== oe || D !== f || f.readyState !== WebSocket.OPEN || f.send(JSON.stringify({ type: "requestFrame", sessionId: d }));
+        };
+        if (_(), Ye(), Ue = window.setInterval(() => {
+          if (!O() || Ae || x !== oe || D !== f || f.readyState !== WebSocket.OPEN) {
+            Ye();
+            return;
+          }
+          _();
+        }, 250), u) {
+          try {
+            const o = decodeURIComponent(u);
+            T("Opening URL"), f.send(
+              JSON.stringify({
+                type: "openUrl",
+                url: o,
+                sessionId: d
+              })
+            );
+          } catch (o) {
+            console.error({ error: o }, "Error decoding URL, falling back to the original URL"), f.send(
+              JSON.stringify({
+                type: "openUrl",
+                url: u,
+                sessionId: d
+              })
+            );
+          }
+          q?.bumpActivity();
+        }
+      }, oe.onclose = () => {
+        !O() || x !== oe || (C({ controlReady: !1 }), T("Control channel closed"));
+      }, oe.onerror = (_) => {
+        !O() || x !== oe || (console.error("Control channel error:", _), T("Control channel error: " + _));
+      }, v.onconnectionstatechange = () => {
+        !O() || N !== v || (T("Connection state: " + v.connectionState), v.connectionState === "failed" && ne && De("WebRTC connection entered failed state", m));
+      }, v.oniceconnectionstatechange = () => {
+        if (!O() || N !== v)
+          return;
+        const _ = v.iceConnectionState;
+        if (T("ICE state: " + _), _ === "connected" || _ === "completed") {
+          be(), ze() && !te && Ze();
+          return;
+        }
+        if (_ === "failed") {
+          be(), ne && De("ICE connection entered failed state", m);
+          return;
+        }
+        _ === "disconnected" && ne && e.autoReconnect && he === void 0 && (he = window.setTimeout(() => {
+          he = void 0, !(!O() || N !== v) && v.iceConnectionState === "disconnected" && De("ICE stayed disconnected past grace period", m);
+        }, An));
+      }, v.ontrack = (_) => {
+        if (!O() || N !== v)
+          return;
+        Tt(_.receiver, e.jitterBufferTargetMs);
+        const o = _.track.id === "duo-inner" || _.streams.some((I) => I.id === "duo-inner");
+        if (_.track.kind === "video" && Ve.displays.set(_.receiver, o ? "inner" : "primary"), T("Received remote track: " + _.track.kind), _.track.kind === "video") {
+          const I = o ? "inner" : "primary", W = R ? new MediaStream([_.track]) : _.streams[0] ?? new MediaStream([_.track]);
+          Re.set(I, W);
+          for (const [g, A] of Y)
+            A.display === I && at(g, A, W);
+        }
+      }, v.onicecandidate = (_) => {
+        if (!(!O() || N !== v || D !== f))
+          if (_.candidate && f.readyState === WebSocket.OPEN) {
+            const o = {
+              type: "candidate",
+              candidate: _.candidate.candidate,
+              sdpMid: _.candidate.sdpMid,
+              sdpMLineIndex: _.candidate.sdpMLineIndex,
+              sessionId: d
+            };
+            f.send(JSON.stringify(o)), T("Sent ICE candidate");
+          } else
+            T("ICE candidate gathering completed");
+      }, f.onmessage = async (_) => {
+        if (!O() || D !== f)
+          return;
+        let o;
+        try {
+          o = JSON.parse(_.data);
+        } catch (I) {
+          S("Error parsing message:", I);
+          return;
+        }
+        if (!q?.handleMessage(o))
+          switch (T("Received: " + o.type), o.type) {
+            case "performActionsResult":
+            case "foldStateResult":
+            case "foldStateChanged": {
+              if (!R) break;
+              o.state ? (K(o.state), w(void 0)) : o.id === "duo-capabilities" && w(o.error || "This instance does not support native iPhone Duo displays.");
+              const g = Ce.get(o.id);
+              g && (clearTimeout(g.timer), Ce.delete(o.id), o.error ? g.reject(new Error(o.error)) : g.resolve());
+              break;
+            }
+            case "signalingError": {
+              if (o.requestType !== "offer" || o.sessionId !== d)
+                break;
+              const g = typeof o.error == "string" ? o.error : "Unable to establish the streaming connection";
+              T("Error: " + g), De(g, m);
+              break;
+            }
+            case "answer":
+              if (!N || N !== v) {
+                T("No peer connection, skipping answer");
+                break;
+              }
+              if (tt?.accept(o.latencyTraceVersion), await v.setRemoteDescription(
+                new RTCSessionDescription({
+                  type: "answer",
+                  sdp: o.sdp
+                })
+              ), !O() || N !== v)
+                return;
+              T("Set remote description");
+              break;
+            case "candidate":
+              if (!N || N !== v) {
+                T("No peer connection, skipping candidate");
+                break;
+              }
+              if (await v.addIceCandidate(
+                new RTCIceCandidate({
+                  candidate: o.candidate,
+                  sdpMid: o.sdpMid,
+                  sdpMLineIndex: o.sdpMLineIndex
+                })
+              ), !O() || N !== v)
+                return;
+              T("Added ICE candidate");
+              break;
+            case "screenshot":
+            case "screenshotResult": {
+              if (typeof o.id != "string") {
+                S("Received invalid screenshot success message:", o);
+                break;
+              }
+              const g = wn(o);
+              if (g) {
+                const G = ee.get(o.id);
+                if (typeof G != "function") {
+                  S(`Received screenshot error for unknown or handled id: ${o.id}`);
+                  break;
+                }
+                S(`Received screenshot error for id ${o.id}: ${g}`), G(new Error(g)), re.delete(o.id), ee.delete(o.id), clearTimeout(B.get(o.id)), B.delete(o.id);
+                break;
+              }
+              const A = Yn(o);
+              if (!A) {
+                S("Received screenshot message without image data:", o);
+                break;
+              }
+              const Z = re.get(o.id);
+              if (typeof Z != "function") {
+                S(`Received screenshot data for unknown or handled id: ${o.id}`);
+                break;
+              }
+              ce(`Received screenshot data for id ${o.id}`), Z(A), re.delete(o.id), ee.delete(o.id), clearTimeout(B.get(o.id)), B.delete(o.id);
+              break;
+            }
+            case "screenshotError":
+              if (typeof o.id != "string" || typeof o.message != "string") {
+                S("Received invalid screenshot error message:", o);
+                break;
+              }
+              const I = ee.get(o.id);
+              if (typeof I != "function") {
+                S(`Received screenshot error for unknown or handled id: ${o.id}`);
+                break;
+              }
+              S(`Received screenshot error for id ${o.id}: ${o.message}`), I(new Error(o.message)), re.delete(o.id), ee.delete(o.id), clearTimeout(B.get(o.id)), B.delete(o.id);
+              break;
+            case "cameraRequest": {
+              const g = de;
+              if (!g)
+                break;
+              const A = _n(o);
+              if (!A) {
+                S("Received invalid cameraRequest:", o);
+                break;
+              }
+              console.info("[RemoteControl] cameraRequest received:", A.active, A.facingMode), await Ut(A, f, g, O);
+              break;
+            }
+            case "microphoneRequest": {
+              if (!Ke)
+                break;
+              const g = o.active === !0;
+              if (Qe = g, console.info("[RemoteControl] microphoneRequest received, active=", g), !g) {
+                Xe || await qe();
+                break;
+              }
+              if (te) {
+                ut(f);
+                break;
+              }
+              await Ze();
+              break;
+            }
+            case "microphoneStartResult": {
+              if (me === null || o.id !== me)
+                break;
+              me = null, typeof o.error == "string" && (console.warn("[RemoteControl] microphoneStart rejected by host:", o.error), qe(o.error));
+              break;
+            }
+            case "terminateAppResult":
+              if (typeof o.id != "string") {
+                S("Received invalid terminateApp result message:", o);
+                break;
+              }
+              if (typeof o.error == "string") {
+                const g = ie.get(o.id);
+                if (typeof g != "function") {
+                  S(`Received terminateApp error for unknown or handled id: ${o.id}`);
+                  break;
+                }
+                S(`Received terminateApp error for id ${o.id}: ${o.error}`), g(new Error(o.error)), ae.delete(o.id), ie.delete(o.id), clearTimeout(B.get(o.id)), B.delete(o.id);
+                break;
+              }
+              const W = ae.get(o.id);
+              if (typeof W != "function") {
+                S(`Received terminateApp result for unknown or handled id: ${o.id}`);
+                break;
+              }
+              ce(`Received terminateApp success for id ${o.id}`), W(), ae.delete(o.id), ie.delete(o.id), clearTimeout(B.get(o.id)), B.delete(o.id);
+              break;
+            default:
+              S(`Received unhandled message type: ${o.type}`, o);
+              break;
+          }
+      }, N === v) {
+        const _ = await v.createOffer({
+          offerToReceiveVideo: !0,
+          offerToReceiveAudio: !1
+        });
+        if (!O() || N !== v || (await v.setLocalDescription(_), !O() || N !== v))
+          return;
+        O() && D === f && f.readyState === WebSocket.OPEN && f.send(
+          JSON.stringify({
+            type: "offer",
+            ...R ? { displayStreams: !0 } : {},
+            ...tt ? { latencyTraceVersion: 1 } : {},
+            sdp: _.sdp,
+            sessionId: d
+          })
+        ), T("Sent offer");
+      }
+    } catch (f) {
+      if (!O() || f instanceof Error && f.message === "Connection stopped")
+        return;
+      const j = f instanceof Error ? f.message : String(f);
+      T("Error: " + j), De(j, m);
+    }
+  }, pt = () => {
+    if (J) throw new Error("Device stream is disposed");
+    Ie++, Te = !1, Be(null), pe !== "reconnecting" && (pe = null), document.addEventListener("visibilitychange", ht), document.hidden || lt(), Ee = !1, mt(0);
+  }, Ct = () => {
+    Ie++, Te = !1, we(), document.removeEventListener("visibilitychange", ht), le += 1, Pe = 0, ne = !1, xe(), be(), _e(), pe = null, C({ connection: "idle", videoReady: !1, controlReady: !1 }), T("Stopped");
+  }, Ot = (r, u = "primary") => {
+    if (J) throw new Error("Device stream is disposed");
+    if (Y.has(r)) throw new Error("Video element is already attached");
+    const a = { display: u };
+    Y.set(r, a);
+    const l = () => {
+      u === "primary" && Re.has(u) && bt();
+    };
+    r.addEventListener("loadeddata", l);
+    const y = Re.get(u);
+    y && at(r, a, y);
+    let m = !1;
+    const O = () => {
+      m || (m = !0, P.delete(O), r.removeEventListener("loadeddata", l), a.stop?.(), Y.delete(r), r.srcObject = null);
+    };
+    return P.add(O), O;
+  };
+  return {
+    start: pt,
+    stop: Ct,
+    attachVideo: Ot,
+    attachFrameSink: (r, u = "primary") => {
+      const a = document.createElement("video");
+      a.muted = !0, a.playsInline = !0, a.autoplay = !0;
+      const l = Ot(a, u);
+      let y = !1, m = 0, O = 0;
+      const f = () => {
+        a.cancelVideoFrameCallback?.(m), cancelAnimationFrame(O);
+      }, j = () => {
+        y || !a.srcObject || (a.readyState >= 2 && a.videoWidth > 0 && L(
+          "present",
+          (...M) => r.present(...M),
+          a,
+          a.videoWidth,
+          a.videoHeight,
+          u
+        ), !(y || !a.srcObject) && (a.requestVideoFrameCallback ? m = a.requestVideoFrameCallback(j) : O = requestAnimationFrame(j)));
+      }, k = () => {
+        f(), j();
+      };
+      Y.get(a).clear = f, a.addEventListener("loadeddata", k);
+      const X = () => {
+        y || (y = !0, P.delete(X), f(), a.removeEventListener("loadeddata", k), l(), a.remove());
+      };
+      return P.delete(l), P.add(X), a.readyState >= 2 && k(), X;
+    },
+    dispose: () => {
+      if (!J) {
+        J = !0, Ct();
+        for (const r of P) r();
+        P.clear();
+      }
+    },
+    getState: () => h,
+    updateOptions: (r) => {
+      if (J) throw new Error("Device stream is disposed");
+      const u = e;
+      if (e = { ...e, ...r }, u.jitterBufferTargetMs !== e.jitterBufferTargetMs)
+        for (const a of N?.getTransceivers() ?? [])
+          (a.currentDirection === "recvonly" || a.currentDirection === "sendrecv") && Tt(a.receiver, e.jitterBufferTargetMs);
+      !!u.onPlaybackStats != !!e.onPlaybackStats && F(), !!u.microphoneEnabled != !!e.microphoneEnabled && (Xe = e.microphoneEnabled ?? !1, ze() ? Ze() : qe()), !!u.inspectMode != !!e.inspectMode && (e.inspectMode ? q?.start() : (q?.stop(), Me !== null && Be(null)));
+    },
+    sendControl: se,
+    sendTouch: (r, u, a, l, y, m = 0) => se(
+      $t(
+        r === "begin" ? 0 : r === "end" ? 1 : 2,
+        m,
+        l,
+        y,
+        u,
+        a,
+        r === "end" ? 0 : 1
+      )
+    ),
+    sendText: (r) => se(Vt(r)),
+    sendDisplayTouch: (r, u, a, l) => se(Gt(r, u, a, l)),
+    sendDuoControl: wt,
+    pressButton: (r) => {
+      const u = { home: 3, back: 4, recents: 187, power: 26 }[r];
+      se(nt(0, u, 0, 0)), se(nt(1, u, 0, 0));
+    },
+    rotate: () => se(new Uint8Array([11]).buffer),
+    bumpActivity: () => q?.bumpActivity(),
+    getAxStatus: () => q?.getStatus() ?? "idle",
+    openUrl: (r) => {
+      if (!D || D.readyState !== WebSocket.OPEN) {
+        S("WebSocket not open, cannot send open_url command.");
+        return;
+      }
+      try {
+        const u = decodeURIComponent(r);
+        T("Opening URL"), D.send(
+          JSON.stringify({
+            type: "openUrl",
+            url: u,
+            sessionId: d
+          })
+        );
+      } catch (u) {
+        S("Error decoding or sending URL :", { error: u, url: r }), D.send(
+          JSON.stringify({
+            type: "openUrl",
+            url: r,
+            sessionId: d
+          })
+        );
+      }
+      q?.bumpActivity();
+    },
+    sendKeyEvent: (r) => {
+      if (!x || x.readyState !== "open") {
+        S("Data channel not ready for imperative key command:", x?.readyState);
+        return;
+      }
+      const u = qt[r.code];
+      if (!u) {
+        S(`Unknown event.code for imperative command: ${r.code}`);
+        return;
+      }
+      let a = i.META_NONE;
+      r.shiftKey && (a |= i.META_SHIFT_ON), r.altKey && (a |= i.META_ALT_ON), r.ctrlKey && (a |= i.META_CTRL_ON), r.metaKey && (a |= i.META_META_ON);
+      const l = r.type === "keydown" ? i.ACTION_DOWN : i.ACTION_UP;
+      ce(
+        `Sending Imperative Key Command: code=${r.code}, keycode=${u}, action=${l}, meta=${a}`
+      );
+      const y = nt(
+        l,
+        u,
+        0,
+        // repeat count, typically 0 for single presses
+        a
+      );
+      y && se(y);
+    },
+    screenshot: (r) => new Promise((u, a) => {
+      if (!D || D.readyState !== WebSocket.OPEN)
+        return S("WebSocket not open, cannot send screenshot command."), a(new Error("WebSocket is not connected or connection is not open."));
+      const l = `ui-ss-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`, y = {
+        type: r ? "screenshotDisplay" : "screenshot",
+        ...r ? { display: r } : {},
+        id: l
+      };
+      re.set(l, u), ee.set(l, a), ce("Sending screenshot request:", y);
+      try {
+        D.send(JSON.stringify(y));
+      } catch (m) {
+        S("Failed to send screenshot request immediately:", m), re.delete(l), ee.delete(l), a(m);
+        return;
+      }
+      B.set(
+        l,
+        setTimeout(() => {
+          B.delete(l), re.has(l) && (S(`Screenshot request timed out for id ${l}`), ee.get(l)?.(new Error("Screenshot request timed out")), re.delete(l), ee.delete(l));
+        }, 3e4)
+      );
+    }),
+    terminateApp: (r) => new Promise((u, a) => {
+      if (!D || D.readyState !== WebSocket.OPEN)
+        return S("WebSocket not open, cannot send terminateApp command."), a(new Error("WebSocket is not connected or connection is not open."));
+      const l = `ui-term-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`, y = {
+        type: "terminateApp",
+        id: l,
+        bundleId: r
+      };
+      ae.set(l, u), ie.set(l, a), ce("Sending terminateApp request:", y);
+      try {
+        D.send(JSON.stringify(y));
+      } catch (m) {
+        S("Failed to send terminateApp request immediately:", m), ae.delete(l), ie.delete(l), a(m);
+        return;
+      }
+      q?.bumpActivity(), B.set(
+        l,
+        setTimeout(() => {
+          B.delete(l), ae.has(l) && (S(`terminateApp request timed out for id ${l}`), ie.get(l)?.(new Error("terminateApp request timed out")), ae.delete(l), ie.delete(l));
+        }, 3e4)
+      );
+    }),
+    reconnect: () => pt(),
+    refreshAxTree: async () => {
+      const r = q;
+      if (!r)
+        throw new Error("Inspect mode is not active");
+      return r.refresh();
+    },
+    getAxSnapshot: () => Me
+  };
+}
+const wn = (t) => typeof t.message == "string" ? t.message : typeof t.error == "string" ? t.error : null, Yn = (t) => typeof t.dataUri == "string" ? { dataUri: t.dataUri } : typeof t.base64 == "string" ? t.base64.startsWith("data:") ? { dataUri: t.base64 } : { dataUri: `data:${t.base64.startsWith("/9j/") ? "image/jpeg" : "image/png"};base64,${t.base64}` } : null;
+export {
+  rt as A,
+  Gt as B,
+  Je as C,
+  In as D,
+  Ln as H,
+  Wn as a,
+  qn as b,
+  $n as c,
+  nn as d,
+  rn as e,
+  xn as f,
+  zt as g,
+  on as h,
+  yn as i,
+  Vn as j,
+  ce as k,
+  S as l,
+  Vt as m,
+  tn as n,
+  nt as o,
+  i as p,
+  $t as q,
+  qt as r,
+  L as s,
+  He as t,
+  Rn as u,
+  Bn as v,
+  Fn as w,
+  kn as x,
+  Pn as y,
+  Un as z
+};