@limrun/ui 0.20.0 → 0.20.1

package/dist/core-BqXmROsc.mjs

@@ -0,0 +1,2162 @@
+const Xe = {
+  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
+}, Je = {
+  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
+}, o = {
+  // 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
+}, Vt = {
+  KeyA: o.KEYCODE_A,
+  KeyB: o.KEYCODE_B,
+  KeyC: o.KEYCODE_C,
+  KeyD: o.KEYCODE_D,
+  KeyE: o.KEYCODE_E,
+  KeyF: o.KEYCODE_F,
+  KeyG: o.KEYCODE_G,
+  KeyH: o.KEYCODE_H,
+  KeyI: o.KEYCODE_I,
+  KeyJ: o.KEYCODE_J,
+  KeyK: o.KEYCODE_K,
+  KeyL: o.KEYCODE_L,
+  KeyM: o.KEYCODE_M,
+  KeyN: o.KEYCODE_N,
+  KeyO: o.KEYCODE_O,
+  KeyP: o.KEYCODE_P,
+  KeyQ: o.KEYCODE_Q,
+  KeyR: o.KEYCODE_R,
+  KeyS: o.KEYCODE_S,
+  KeyT: o.KEYCODE_T,
+  KeyU: o.KEYCODE_U,
+  KeyV: o.KEYCODE_V,
+  KeyW: o.KEYCODE_W,
+  KeyX: o.KEYCODE_X,
+  KeyY: o.KEYCODE_Y,
+  KeyZ: o.KEYCODE_Z,
+  Digit0: o.KEYCODE_0,
+  Digit1: o.KEYCODE_1,
+  Digit2: o.KEYCODE_2,
+  Digit3: o.KEYCODE_3,
+  Digit4: o.KEYCODE_4,
+  Digit5: o.KEYCODE_5,
+  Digit6: o.KEYCODE_6,
+  Digit7: o.KEYCODE_7,
+  Digit8: o.KEYCODE_8,
+  Digit9: o.KEYCODE_9,
+  Backquote: o.KEYCODE_GRAVE,
+  Minus: o.KEYCODE_MINUS,
+  Equal: o.KEYCODE_EQUALS,
+  BracketLeft: o.KEYCODE_LEFT_BRACKET,
+  BracketRight: o.KEYCODE_RIGHT_BRACKET,
+  Backslash: o.KEYCODE_BACKSLASH,
+  Semicolon: o.KEYCODE_SEMICOLON,
+  Quote: o.KEYCODE_APOSTROPHE,
+  Comma: o.KEYCODE_COMMA,
+  Period: o.KEYCODE_PERIOD,
+  Slash: o.KEYCODE_SLASH,
+  Space: o.KEYCODE_SPACE,
+  Tab: o.KEYCODE_TAB,
+  Escape: o.KEYCODE_ESCAPE,
+  ArrowUp: o.DPAD_UP,
+  ArrowDown: o.DPAD_DOWN,
+  ArrowLeft: o.DPAD_LEFT,
+  ArrowRight: o.DPAD_RIGHT,
+  Enter: o.ENTER,
+  Backspace: o.DEL,
+  Delete: o.FORWARD_DEL,
+  Home: o.KEYCODE_MOVE_HOME,
+  End: o.KEYCODE_MOVE_END,
+  PageUp: o.KEYCODE_PAGE_UP,
+  PageDown: o.KEYCODE_PAGE_DOWN,
+  Insert: o.KEYCODE_INSERT,
+  F1: o.KEYCODE_F1,
+  F2: o.KEYCODE_F2,
+  F3: o.KEYCODE_F3,
+  F4: o.KEYCODE_F4,
+  F5: o.KEYCODE_F5,
+  F6: o.KEYCODE_F6,
+  F7: o.KEYCODE_F7,
+  F8: o.KEYCODE_F8,
+  F9: o.KEYCODE_F9,
+  F10: o.KEYCODE_F10,
+  F11: o.KEYCODE_F11,
+  F12: o.KEYCODE_F12,
+  ShiftLeft: o.KEYCODE_SHIFT_LEFT,
+  ShiftRight: o.KEYCODE_SHIFT_RIGHT,
+  ControlLeft: o.KEYCODE_CTRL_LEFT,
+  ControlRight: o.KEYCODE_CTRL_RIGHT,
+  AltLeft: o.KEYCODE_ALT_LEFT,
+  AltRight: o.KEYCODE_ALT_RIGHT,
+  MetaLeft: o.KEYCODE_META_LEFT,
+  MetaRight: o.KEYCODE_META_RIGHT,
+  // Windows/Command key
+  ContextMenu: o.MENU,
+  // Often the Menu key
+  // Numpad mappings
+  Numpad0: o.KEYCODE_NUMPAD_0,
+  Numpad1: o.KEYCODE_NUMPAD_1,
+  Numpad2: o.KEYCODE_NUMPAD_2,
+  Numpad3: o.KEYCODE_NUMPAD_3,
+  Numpad4: o.KEYCODE_NUMPAD_4,
+  Numpad5: o.KEYCODE_NUMPAD_5,
+  Numpad6: o.KEYCODE_NUMPAD_6,
+  Numpad7: o.KEYCODE_NUMPAD_7,
+  Numpad8: o.KEYCODE_NUMPAD_8,
+  Numpad9: o.KEYCODE_NUMPAD_9,
+  NumpadDivide: o.KEYCODE_NUMPAD_DIVIDE,
+  NumpadMultiply: o.KEYCODE_NUMPAD_MULTIPLY,
+  NumpadSubtract: o.KEYCODE_NUMPAD_SUBTRACT,
+  NumpadAdd: o.KEYCODE_NUMPAD_ADD,
+  NumpadDecimal: o.KEYCODE_NUMPAD_DOT,
+  NumpadComma: o.KEYCODE_NUMPAD_COMMA,
+  // Some numpads have comma
+  NumpadEnter: o.KEYCODE_NUMPAD_ENTER,
+  NumpadEqual: o.KEYCODE_NUMPAD_EQUALS
+};
+function Ht(t, e, r, c, E, d, l = 1, h = 0, O = 0) {
+  const C = new ArrayBuffer(32), A = new DataView(C);
+  let M = 0;
+  A.setUint8(M, Xe.INJECT_TOUCH_EVENT), M += 1;
+  const U = t === Je.ACTION_POINTER_DOWN ? Je.ACTION_DOWN : t === Je.ACTION_POINTER_UP ? Je.ACTION_UP : t;
+  return A.setUint8(M, U), M += 1, A.setBigInt64(M, BigInt(e), !0), M += 8, A.setInt32(M, Math.round(E), !0), M += 4, A.setInt32(M, Math.round(d), !0), M += 4, A.setUint16(M, r, !0), M += 2, A.setUint16(M, c, !0), M += 2, A.setInt16(M, Math.round(l * 65535), !0), M += 2, A.setInt32(M, h, !0), M += 4, A.setInt32(M, O, !0), C;
+}
+function kn(t, e, r, c, E, d, l) {
+  const h = new ArrayBuffer(24), O = new DataView(h);
+  let C = 0;
+  return O.setUint8(C, Xe.INJECT_TWO_FINGER_TOUCH_EVENT), C += 1, O.setUint8(C, t), C += 1, O.setInt32(C, Math.round(c), !0), C += 4, O.setInt32(C, Math.round(E), !0), C += 4, O.setInt32(C, Math.round(d), !0), C += 4, O.setInt32(C, Math.round(l), !0), C += 4, O.setUint16(C, e, !0), C += 2, O.setUint16(C, r, !0), C += 2, O.setUint16(C, 0, !0), h;
+}
+function Gt(t, e = !0) {
+  const c = new TextEncoder().encode(t), E = new ArrayBuffer(14 + c.length), d = new DataView(E);
+  let l = 0;
+  return d.setUint8(l, Xe.SET_CLIPBOARD), l += 1, d.setBigInt64(l, BigInt(0), !1), l += 8, d.setUint8(l, e ? 1 : 0), l += 1, d.setUint32(l, c.length, !1), l += 4, new Uint8Array(E, l).set(c), E;
+}
+function it(t, e, r = 0, c = 0) {
+  const E = new ArrayBuffer(14), d = new DataView(E);
+  let l = 0;
+  return d.setUint8(l, Xe.INJECT_KEYCODE), l += 1, d.setUint8(l, t), l += 1, d.setInt32(l, e, !0), l += 4, d.setInt32(l, r, !0), l += 4, d.setInt32(l, c, !0), E;
+}
+const Un = { width: 164.6, height: 117.8, depth: 5.2 };
+function Pn(t, e, r) {
+  return t = Math.max(0, Math.min(1, t)), e = Math.max(0, Math.min(1, e)), r === 1 ? { x: e, y: 1 - t } : r === 2 ? { x: 1 - t, y: 1 - e } : r === 3 ? { x: 1 - e, y: t } : { x: t, y: e };
+}
+function Jt(t) {
+  return Number.isFinite(t) && t >= 0 && t <= 180;
+}
+function Ln(t, e) {
+  return { x: Math.max(0, Math.min(1, t)), y: Math.max(0, Math.min(1, 1 - e)) };
+}
+function Fn(t, e, r) {
+  return e && (t || !r) ? "touch" : t ? "ignore" : "orbit";
+}
+function jt(t, e, r, c) {
+  if (!Number.isInteger(t) || t < 0 || t > 3 || !Number.isInteger(e) || e < 1 || e > 255 || !Number.isFinite(r) || !Number.isFinite(c) || r < 0 || r > 1 || c < 0 || c > 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, r, !0), d.setFloat32(8, c, !0), E;
+}
+class Bn {
+  constructor(e, r) {
+    this.send = e, this.failed = r;
+  }
+  send;
+  failed;
+  latest;
+  running = !1;
+  stopped = !1;
+  set(e) {
+    this.stopped || !Jt(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 xn = {
+  side: "Sleep/Wake",
+  volumeUp: "Volume Up",
+  volumeDown: "Volume Down"
+};
+class Wn {
+  constructor(e, r) {
+    this.send = e, this.failed = r;
+  }
+  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, r) {
+    this.tail = this.tail.then(() => this.send(e, r)).catch(this.failed);
+  }
+}
+const ot = "Accessibility unavailable on this device.", je = 500, Mt = (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, Xt = (t) => Math.max(0, t.width) * Math.max(0, t.height), Qt = (t) => {
+  const e = t.find((r) => r.frame && r.frame.width > 0 && r.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 };
+}, zt = (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;
+}, Zt = (t) => {
+  const e = {};
+  for (const [r, c] of Object.entries(t))
+    r !== "children" && (e[r] = c);
+  return e;
+};
+function en(t) {
+  const e = Array.isArray(t) ? t : [t], r = Qt(e), c = [], E = (d, l) => {
+    if (c.length >= je) return;
+    const h = d.frame;
+    if (h && h.width > 0 && h.height > 0 && !Mt(h, r)) {
+      const C = d.role_description || d.role || "", A = (typeof d.AXLabel == "string" ? d.AXLabel : "") || (typeof d.title == "string" ? d.title : "") || "";
+      c.push({
+        id: typeof d.AXUniqueId == "string" && d.AXUniqueId.length > 0 ? d.AXUniqueId : l,
+        path: l,
+        label: A,
+        value: typeof d.AXValue == "string" ? d.AXValue : "",
+        role: C,
+        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: zt(d),
+        raw: Zt(d)
+      });
+    }
+    const O = Array.isArray(d.children) ? d.children : [];
+    for (let C = 0; C < O.length && c.length < je; C++)
+      E(O[C], `${l}.${C}`);
+  };
+  for (let d = 0; d < e.length && c.length < je; d++)
+    E(e[d], String(d));
+  return {
+    platform: "ios",
+    screen: { width: r.width, height: r.height },
+    elements: c,
+    capturedAt: Date.now()
+  };
+}
+const tn = (t) => {
+  let e = { x: 0, y: 0, width: 1, height: 1 }, r = 0;
+  for (const c of t) {
+    const E = c.parsedBounds;
+    if (!E) continue;
+    const d = E.right - E.left, l = E.bottom - E.top, h = Math.max(0, d) * Math.max(0, l);
+    h > r && (r = h, e = { x: 0, y: 0, width: d, height: l });
+  }
+  return e;
+}, nn = (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 rn(t) {
+  const e = tn(t), r = [];
+  for (let c = 0; c < t.length && r.length < je; c++) {
+    const E = t[c], d = E.parsedBounds;
+    if (!d) continue;
+    const l = Math.max(0, d.right - d.left), h = Math.max(0, d.bottom - d.top);
+    if (l <= 0 || h <= 0) continue;
+    const O = { x: d.left, y: d.top, width: l, height: h };
+    if (Mt(O, { x: 0, y: 0, width: e.width, height: e.height })) continue;
+    const C = E.contentDesc || E.text || "", A = E.className || "";
+    r.push({
+      id: E.resourceId && E.resourceId.length > 0 ? E.resourceId : E.contentDesc && E.contentDesc.length > 0 ? `cd:${E.contentDesc}` : String(c),
+      path: String(c),
+      label: C,
+      value: typeof E.text == "string" ? E.text : "",
+      role: A,
+      type: A,
+      enabled: E.enabled !== !1,
+      focused: E.focused === !0,
+      frame: O,
+      selectors: nn(E),
+      raw: { ...E }
+    });
+  }
+  return {
+    platform: "android",
+    screen: { width: e.width, height: e.height },
+    elements: r,
+    capturedAt: Date.now()
+  };
+}
+function qn(t, e) {
+  const r = Math.max(0, t.x), c = Math.max(0, t.y), E = Math.min(e.width, t.x + t.width), d = Math.min(e.height, t.y + t.height), l = Math.max(0, E - r), h = Math.max(0, d - c);
+  return l > 0 && h > 0 ? { x: r, y: c, width: l, height: h } : null;
+}
+function on(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 r = t.frame, c = e.frame;
+  return r.x === c.x && r.y === c.y && r.width === c.width && r.height === c.height;
+}
+function an(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 r = 0; r < t.elements.length; r++)
+    if (!on(t.elements[r], e.elements[r])) return !1;
+  return !0;
+}
+function $n(t, e, r) {
+  let c = null, E = 1 / 0;
+  for (const d of t.elements) {
+    const l = d.frame;
+    if (e < l.x || r < l.y || e > l.x + l.width || r > l.y + l.height) continue;
+    const h = Xt(l);
+    h < E && (E = h, c = d);
+  }
+  return c;
+}
+function Vn(t, e) {
+  if (e === "ios") {
+    if (t.selectors.AXUniqueId)
+      return `client.tapElement({ AXUniqueId: ${JSON.stringify(t.selectors.AXUniqueId)} })`;
+    if (t.selectors.AXLabel) {
+      const r = t.selectors.className ? `, type: ${JSON.stringify(t.selectors.className)}` : "";
+      return `client.tapElement({ AXLabel: ${JSON.stringify(t.selectors.AXLabel)}${r} })`;
+    }
+    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 sn(t) {
+  const e = t.role || t.type || "";
+  if (!e) return "element";
+  let r = e.replace(/^AX/, "");
+  return r.includes(".") && (r = r.split(".").pop()), r === "GenericElement" ? "Element" : (r = r.replace(/([a-z])([A-Z])/g, "$1 $2"), r);
+}
+const St = 80;
+function Hn(t) {
+  const e = sn(t), r = t.label || t.value || "";
+  if (!r) return e;
+  const c = r.length > St ? r.slice(0, St).trimEnd() + "…" : r;
+  return `${e} · ${c}`;
+}
+const cn = 500, ln = 2e3, yt = 5e3, dn = 8e3, un = 1200, fn = 250, En = () => `ax-rc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+class hn {
+  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 ?? cn, this.maxBackoffMs = e.maxBackoffMs ?? ln, 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, r) {
+    if (this.status !== e && (this.status = e, !!this.onStatusChange))
+      try {
+        this.onStatusChange(e, r);
+      } catch (c) {
+        console.error("[AxFetcher] onStatusChange threw:", c);
+      }
+  }
+  // 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 + un;
+    const r = Math.max(150, Math.floor(this.baseIntervalMs / 2));
+    if (e - this.lastBumpAtMs < r) {
+      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 r = e.id;
+    if (!this.pending.get(r)) 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(r, new Error(h)), !0;
+      const O = typeof e.json == "string" ? e.json : "";
+      try {
+        const C = JSON.parse(O), A = en(C);
+        this.settleResolve(r, A);
+      } catch (C) {
+        this.settleReject(r, C instanceof Error ? C : new Error(String(C)));
+      }
+      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(r, new Error(h)), !0;
+    }
+    const d = e.payload, l = Array.isArray(d?.nodes) ? d.nodes : [];
+    try {
+      const h = rn(l);
+      this.settleResolve(r, h);
+    } catch (h) {
+      this.settleReject(r, 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 = En();
+    return new Promise((r, c) => {
+      const E = window.setTimeout(
+        () => {
+          this.pending.delete(e), c(new Error("elementTree request timed out"));
+        },
+        dn + (this.androidElementTreeOptions?.waitForIdleTimeoutMs ?? 0)
+      );
+      this.pending.set(e, { resolve: r, reject: c, timer: E }), this.send(this.buildRequest(e)) || (window.clearTimeout(E), this.pending.delete(e), c(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 r = e instanceof Error ? e.message : String(e), c = /unavailable|not (yet )?running|failed|timeout/i.test(r);
+        this.currentInterval = c ? yt : Math.min(this.currentInterval * 2, this.maxBackoffMs), this.setStatus(c ? "unavailable" : "error", r);
+      } finally {
+        this.inflight = !1, this.scheduleNext();
+      }
+    }
+  }
+  deliver(e) {
+    const r = this.lastSnapshot;
+    if (an(r, e)) {
+      this.currentInterval = Math.min(this.currentInterval * 2, this.maxBackoffMs), this.lastSnapshot = e, e.errors?.includes(ot) || this.setStatus("ready");
+      return;
+    }
+    this.lastSnapshot = e, this.currentInterval = this.baseIntervalMs, e.errors?.includes(ot) ? (this.currentInterval = yt, this.setStatus("unavailable", ot)) : 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(fn, this.currentInterval) : this.currentInterval;
+    this.timer = window.setTimeout(() => {
+      this.timer = void 0, this.runOnce();
+    }, e);
+  }
+  settleResolve(e, r) {
+    const c = this.pending.get(e);
+    c && (window.clearTimeout(c.timer), this.pending.delete(e), c.resolve(r));
+  }
+  settleReject(e, r) {
+    const c = this.pending.get(e);
+    c && (window.clearTimeout(c.timer), this.pending.delete(e), c.reject(r));
+  }
+  failAllPending(e) {
+    for (const [r, c] of this.pending.entries())
+      window.clearTimeout(c.timer), c.reject(new Error(e)), this.pending.delete(r);
+  }
+}
+function vt(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 r = e ?? null;
+  try {
+    t.jitterBufferTarget !== r && (t.jitterBufferTarget = r);
+  } catch (c) {
+    console.warn("RemoteControl: could not set the jitter buffer target.", c);
+  }
+}
+const Yt = `(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())}})();
+`, At = typeof self < "u" && self.Blob && new Blob(["(self.URL || self.webkitURL).revokeObjectURL(self.location.href);", Yt], { type: "text/javascript;charset=utf-8" });
+function mn(t) {
+  let e;
+  try {
+    if (e = At && (self.URL || self.webkitURL).createObjectURL(At), !e) throw "";
+    const r = new Worker(e, {
+      name: t?.name
+    });
+    return r.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(e);
+    }), r;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Yt),
+      {
+        name: t?.name
+      }
+    );
+  }
+}
+function pn(t, e, r) {
+  const { MediaStreamTrackProcessor: c, MediaStreamTrackGenerator: E } = globalThis, d = e.getVideoTracks()[0];
+  let l, h, O, C, A = !1;
+  const M = () => {
+    A || (A = !0, l?.stop(), h?.stop(), O && (O.postMessage({ type: "stop" }), C = setTimeout(() => O?.terminate(), 1e3)));
+  }, U = (b) => {
+    t.srcObject = b, t.play().catch(() => {
+    });
+  }, T = (b) => {
+    A || (M(), r(b), U(e));
+  };
+  try {
+    if (d && c && E) {
+      l = d.clone();
+      const b = new c({ track: l, maxBufferSize: 1 }), V = new E({ kind: "video" });
+      h = V, O = new mn(), O.onmessage = ({ data: F }) => {
+        F.type === "error" ? T(new Error(F.message)) : F.type === "stopped" && (clearTimeout(C), O?.terminate());
+      }, O.onerror = (F) => T(new Error(F.message)), O.postMessage({ type: "start", readable: b.readable, writable: V.writable }, [
+        b.readable,
+        V.writable
+      ]), U(new MediaStream(e.getTracks().map((F) => F === d ? V : F)));
+    } else
+      U(e);
+  } catch (b) {
+    T(b);
+  }
+  return M;
+}
+function ke(t) {
+  return typeof t == "number" && Number.isFinite(t);
+}
+function Te(t, e) {
+  if (!(!ke(t) || !ke(e) || t < e || e < 0))
+    return t - e;
+}
+class Cn {
+  previous = /* @__PURE__ */ new Map();
+  reset() {
+    this.previous.clear();
+  }
+  read(e, r, c) {
+    const E = { timestamp: 0, video: [], audio: [] };
+    c == null ? E.requestedTargetMs = null : ke(c) && c >= 0 && c <= 4e3 && (E.requestedTargetMs = c);
+    const d = /* @__PURE__ */ new Map();
+    return e.forEach((l) => {
+      if (l.type !== "inbound-rtp" || !ke(l.timestamp)) return;
+      const h = l.kind ?? l.mediaType;
+      if (h !== "video" && h !== "audio") return;
+      const O = r.filter((Y) => Y.kind === h), C = l.trackIdentifier ? O.find((Y) => Y.trackId === l.trackIdentifier) : l.mid != null ? O.find((Y) => Y.mid === l.mid) : O.length === 1 ? O[0] : void 0;
+      if (!C) return;
+      const A = this.previous.get(l.id), U = A?.trackId === C.trackId && A.stats.ssrc === l.ssrc ? A.stats : void 0, T = U ? l.timestamp - U.timestamp : void 0, b = {
+        id: l.id,
+        trackId: C.trackId,
+        timestamp: l.timestamp
+      };
+      if (T !== void 0 && T > 0) {
+        b.intervalMs = T;
+        const Y = Te(l.jitterBufferEmittedCount, U?.jitterBufferEmittedCount), P = Te(l.jitterBufferDelay, U?.jitterBufferDelay);
+        Y !== void 0 && Y > 0 && P !== void 0 && (b.bufferDelayMs = P / Y * 1e3);
+        const H = Te(l.bytesReceived, U?.bytesReceived);
+        H !== void 0 && (b.bitrateBps = H * 8e3 / T);
+      }
+      if (h === "video") {
+        const Y = { ...b, display: C.display ?? "primary" };
+        if (b.intervalMs !== void 0) {
+          const P = Te(l.framesDecoded, U?.framesDecoded);
+          P !== void 0 && (Y.fps = P * 1e3 / b.intervalMs), Y.droppedFrames = Te(l.framesDropped, U?.framesDropped), Y.freezes = Te(l.freezeCount, U?.freezeCount);
+        }
+        E.video.push(Y);
+      } else E.audio.push(b);
+      E.timestamp = Math.max(E.timestamp, l.timestamp), d.set(
+        l.id,
+        U && l.timestamp <= U.timestamp ? A : { stats: l, trackId: C.trackId }
+      );
+      const V = l.transportId ? e.get(l.transportId) : void 0, F = V?.selectedCandidatePairId ? e.get(V.selectedCandidatePairId) : void 0;
+      F?.state === "succeeded" && ke(F.currentRoundTripTime) && F.currentRoundTripTime >= 0 && (E.rttMs = F.currentRoundTripTime * 1e3);
+    }), this.previous = d, E.video.length || E.audio.length ? E : null;
+  }
+}
+const at = /* @__PURE__ */ new WeakSet();
+function On(t, e, r) {
+  const { peer: c, displays: E } = t, d = new Cn();
+  let l, h = !1, O = !1, C = !1, A = 0, M = !1, U = !1;
+  const T = () => !h && !document.hidden && c.connectionState === "connected", b = (P) => {
+    if (!(!P && !M)) {
+      M = P !== null;
+      try {
+        e()?.(P);
+      } catch (H) {
+        console.error('[RemoteControl] customer callback "onPlaybackStats" threw:', H);
+      }
+    }
+  }, V = () => {
+    O = !1, A++, clearTimeout(l), d.reset(), b(null);
+  }, F = async () => {
+    if (C || !T()) return;
+    if (at.has(c)) {
+      l = setTimeout(() => {
+        F();
+      }, 2e3);
+      return;
+    }
+    C = !0, at.add(c);
+    const P = A;
+    try {
+      const H = await c.getStats();
+      if (P !== A || !T()) return;
+      const B = c.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(H, B, r())), U = !1;
+    } catch (H) {
+      if (P !== A || !T()) return;
+      U || console.warn("[RemoteControl] could not read playback stats:", H), U = !0, d.reset(), b(null);
+    } finally {
+      C = !1, at.delete(c), O && T() && (l = setTimeout(
+        () => {
+          F();
+        },
+        P === A ? 2e3 : 0
+      ));
+    }
+  }, Y = () => {
+    if (!T()) {
+      V();
+      return;
+    }
+    O || (O = !0, F());
+  };
+  return document.addEventListener("visibilitychange", Y), c.addEventListener("connectionstatechange", Y), Y(), () => {
+    h = !0, document.removeEventListener("visibilitychange", Y), c.removeEventListener("connectionstatechange", Y), V();
+  };
+}
+function Dn(t, e) {
+  const r = t.createDataChannel("latency-trace-v1", {
+    ordered: !0,
+    negotiated: !0,
+    id: 2
+  });
+  let c = !1, E = !1, d = 0;
+  return r.onmessage = (l) => {
+    if (E) return;
+    let h;
+    try {
+      h = JSON.parse(l.data);
+    } catch (O) {
+      console.warn("Invalid latency trace message", O);
+      return;
+    }
+    h && typeof h == "object" && !Array.isArray(h) && e(h);
+  }, r.onclose = () => {
+    E = !0, c = !1;
+  }, {
+    accept(l) {
+      c = !E && l === 1;
+    },
+    wrap(l) {
+      if (!c || l.byteLength !== 32) return l;
+      const h = new DataView(l);
+      if (h.getUint8(0) !== 2 || h.getUint8(1) > 2) return l;
+      const O = new ArrayBuffer(38), C = new DataView(O);
+      return C.setUint8(0, 240), C.setUint8(1, 1), C.setUint32(2, ++d, !0), new Uint8Array(O, 6).set(new Uint8Array(l)), O;
+    },
+    close() {
+      E = !0, c = !1, r.onmessage = null, r.onclose = null, r.close();
+    }
+  };
+}
+class _n {
+  generation = 0;
+  tail = Promise.resolve();
+  get currentGeneration() {
+    return this.generation;
+  }
+  enqueue(e) {
+    const r = ++this.generation;
+    return this.append(r, 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, r) {
+    const c = {
+      generation: e,
+      isCurrent: () => e === this.generation
+    }, E = this.tail.then(() => r(c));
+    return this.tail = E.catch(() => {
+    }), E;
+  }
+  invalidate() {
+    ++this.generation;
+  }
+}
+function gn(t) {
+  if (!t || typeof t != "object") return null;
+  const e = t;
+  if (e.type !== "cameraRequest" || typeof e.active != "boolean") return null;
+  const r = { active: e.active };
+  return (e.facingMode === "user" || e.facingMode === "environment") && (r.facingMode = e.facingMode), r;
+}
+function Tn(t) {
+  const e = {
+    frameRate: { ideal: 30, max: 30 }
+  };
+  return t?.facingMode && (e.facingMode = { ideal: t.facingMode }), e;
+}
+function Sn(t, e) {
+  return !t || t.facingMode !== e.facingMode;
+}
+function yn(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 vn(t) {
+  return {
+    type: "cameraResult",
+    granted: !0,
+    camera: yn(t)
+  };
+}
+const ce = (...t) => {
+  window.debugRemoteControl && console.log(...t);
+}, y = (...t) => {
+  window.debugRemoteControl && console.warn(...t);
+}, L = (t, e, ...r) => {
+  if (e)
+    try {
+      e(...r);
+    } catch (c) {
+      console.error(`[RemoteControl] customer callback "${t}" threw:`, c);
+    }
+}, An = (t) => t.includes("/android_") ? "android" : "ios", Kt = (t, e) => {
+  const r = new URL(t);
+  return r.searchParams.set("token", e), r.toString();
+}, st = 3, Kn = 1e3, wn = 15e3, Mn = 3e3, Yn = 4e3;
+function wt() {
+  const t = crypto.getRandomValues(new Uint8Array(16));
+  t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128;
+  const e = Array.from(t, (r) => r.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 Gn(t) {
+  let e = { ...t };
+  const { url: r, token: c, deviceModel: E } = e, d = e.sessionId ?? wt(), l = e.platform ?? An(r ?? "");
+  let h = {
+    connection: "idle",
+    videoReady: !1,
+    controlReady: !1,
+    duo: !1,
+    duoState: null
+  };
+  const O = (n) => {
+    h = { ...h, ...n }, L("onStateChange", e.onStateChange, h);
+  }, C = (n) => O({ videoReady: n }), A = (n) => O({ duoState: n }), M = (n) => O({ duoError: n }), U = (n) => O({ duo: n }), T = (n) => ce(n);
+  let b = null, V;
+  const F = () => {
+    V?.(), V = b && e.onPlaybackStats ? On(
+      b,
+      () => e.onPlaybackStats,
+      () => e.jitterBufferTargetMs
+    ) : void 0;
+  }, Y = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Set(), H = /* @__PURE__ */ new Set(), B = /* @__PURE__ */ new Map();
+  let j = !1;
+  const Se = /* @__PURE__ */ new Map(), ct = (n, u, a) => {
+    u.stop?.(), u.stop = pn(n, a, (s) => y("Video playback fallback:", s));
+  }, bt = () => {
+    Se.clear();
+    for (const [n, u] of Y)
+      u.clear?.(), u.stop?.(), u.stop = void 0, n.srcObject = null;
+  };
+  let Ee = !1, ye = !1, Ue = 0, _ = null, R = null, x = null, Pe = null, he, ve, Ae, Le, me, le = 0, Fe = 0, ne = !1, de = null, z = null, ue;
+  const Qe = new _n();
+  let Ke = null, Be = null, ze = e.microphoneEnabled ?? !1, Ze = !1, we = null, te = null, xe = 0, lt = Promise.resolve(), pe = null, Me = !1, re = /* @__PURE__ */ new Map(), ee = /* @__PURE__ */ new Map(), ae = /* @__PURE__ */ new Map(), ie = /* @__PURE__ */ new Map(), q = null, Ye = null, dt = 0;
+  const We = (n) => {
+    if (n === null && Ye === null) return;
+    Ye = n;
+    const u = ++dt;
+    queueMicrotask(() => {
+      u === dt && L("onAxSnapshotChange", e.onAxSnapshotChange, n);
+    });
+  };
+  let Ce = null, fe = /* @__PURE__ */ new Map();
+  const be = (n, u) => new Promise((a, s) => {
+    const S = _;
+    if (!S || S.readyState !== WebSocket.OPEN) {
+      s(new Error("Simulator disconnected"));
+      return;
+    }
+    const m = wt(), p = setTimeout(() => {
+      fe.delete(m), s(new Error("Device control timed out"));
+    }, 5e3);
+    fe.set(m, { resolve: a, reject: s, timer: p });
+    try {
+      S.send(JSON.stringify({ type: n, id: m, ...u })), q?.bumpActivity();
+    } catch (f) {
+      clearTimeout(p), fe.delete(m), s(f);
+    }
+  });
+  let Oe;
+  const ut = () => {
+    if (Oe) return Oe;
+    const n = be("getFoldState", {}).then(() => {
+      if (!h.duoState) throw new Error("This instance does not support native iPhone Duo displays.");
+    }).finally(() => {
+      Oe === n && (Oe = void 0);
+    });
+    return Oe = n, n;
+  }, De = (n) => {
+    Ce !== n && (Ce = n, O({ connection: n }), L("onConnectionStateChange", e.onConnectionStateChange, n));
+  }, se = (n) => {
+    !x || x.readyState !== "open" || (x.send(Pe?.wrap(n) ?? n), q?.bumpActivity());
+  }, Rt = () => {
+    _ && _.readyState === WebSocket.OPEN && _.send(
+      JSON.stringify({
+        type: "keepAlive",
+        sessionId: d
+      })
+    );
+  }, ft = () => {
+    he && window.clearInterval(he), he = window.setInterval(Rt, 1e4);
+  }, Re = () => {
+    he && (window.clearInterval(he), he = void 0);
+  }, qe = () => {
+    ve && (window.clearTimeout(ve), ve = void 0);
+  }, $e = () => {
+    Ae && (window.clearTimeout(Ae), Ae = void 0);
+  }, Ne = () => {
+    Le && (window.clearInterval(Le), Le = void 0);
+  }, Ie = () => {
+    me !== void 0 && (window.clearTimeout(me), me = void 0);
+  }, Nt = () => {
+    Me || (Me = !0, Ne(), C(!0), De("connected"));
+  }, G = (n) => {
+    for (const u of n.getTracks())
+      try {
+        u.stop();
+      } catch (a) {
+        y("track.stop() failed:", a);
+      }
+  }, It = () => {
+    const n = z;
+    n && (z = null, G(n));
+  }, Et = (n) => {
+    const u = lt.then(n).catch((a) => {
+      y("microphone operation failed:", a);
+    });
+    return lt = u, u;
+  }, et = () => ze || Ze, ht = (n) => {
+    const u = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    pe = u, n.send(JSON.stringify({ type: "microphoneStart", id: u }));
+  }, tt = () => Et(() => kt()), kt = async () => {
+    const n = xe, u = () => n === xe && et(), a = (f) => {
+      L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+        active: !1,
+        error: f
+      });
+    };
+    if (!u()) return;
+    const s = _, S = we;
+    if (!s || s.readyState !== WebSocket.OPEN || !S || 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 && G(m);
+      return;
+    }
+    if (!m) {
+      a("Microphone permission denied or no device available");
+      return;
+    }
+    const p = m.getAudioTracks()[0] ?? null;
+    if (!p) {
+      G(m), a("Captured stream has no audio track");
+      return;
+    }
+    try {
+      await S.replaceTrack(p);
+    } catch (f) {
+      y("replaceTrack(audioTrack) failed:", f), G(m), a("Failed to attach the microphone track to the connection");
+      return;
+    }
+    if (!u()) {
+      try {
+        await S.replaceTrack(null);
+      } catch (f) {
+        y("replaceTrack(null) on stale mic attach failed:", f);
+      }
+      G(m);
+      return;
+    }
+    te = m, p.onended = () => {
+      te === m && Ve("microphone capture ended by the browser");
+    }, ht(s), L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+      active: !0,
+      label: p.label || void 0
+    });
+  }, Ve = (n) => (++xe, pe = null, Et(async () => {
+    const u = we, a = te;
+    if (te = null, u && a)
+      try {
+        await u.replaceTrack(null);
+      } catch (S) {
+        y("replaceTrack(null) on mic detach failed:", S);
+      }
+    a && G(a);
+    const s = _;
+    if (a && s && s.readyState === WebSocket.OPEN) {
+      const S = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      s.send(JSON.stringify({ type: "microphoneStop", id: S }));
+    }
+    (a || n) && L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+      active: !1,
+      ...n !== void 0 && { error: n }
+    });
+  })), mt = (n, u) => {
+    let a;
+    try {
+      a = vn(u), console.info(
+        `[RemoteControl] camera capture: ${a.camera?.width}x${a.camera?.height} @ ${a.camera?.frameRate ?? "?"}fps` + (a.camera?.label ? ` — ${a.camera.label}` : "")
+      );
+    } catch (s) {
+      y("getSettings() on outbound camera track failed:", s), a = {
+        type: "cameraResult",
+        granted: !0,
+        camera: {
+          label: u.label || void 0
+        }
+      };
+    }
+    n.send(JSON.stringify(a)), L("onCameraDemandChange", e.onCameraDemandChange, !0, !0, a.camera);
+  }, Ut = (n) => {
+    if (!n) return;
+    const u = n.indexOf("/"), s = (u >= 0 ? n.slice(u + 1) : n).toUpperCase();
+    return s === "HEVC" ? "H265" : s;
+  }, Pt = async () => {
+    const n = de, u = e.onCameraStats;
+    if (!n || !u) return;
+    let a;
+    try {
+      a = await n.getStats();
+    } catch {
+      return;
+    }
+    let s, S, m;
+    if (a.forEach((N) => {
+      N.type === "outbound-rtp" && N.kind === "video" ? s = N : N.type === "remote-inbound-rtp" && N.kind === "video" && (m = N);
+    }), s?.codecId) {
+      const N = a.get(s.codecId);
+      N && (S = N.mimeType);
+    }
+    if (!s) return;
+    const p = s.timestamp ?? Date.now(), f = Be;
+    let $, k, X;
+    if (f && p > f.timestamp) {
+      const N = (p - f.timestamp) / 1e3;
+      if (typeof s.framesEncoded == "number" && typeof f.framesEncoded == "number" && ($ = Math.max(0, (s.framesEncoded - f.framesEncoded) / N)), typeof s.bytesSent == "number" && typeof f.bytesSent == "number" && (k = Math.max(0, (s.bytesSent - f.bytesSent) * 8 / N)), typeof s.packetsSent == "number" && typeof f.packetsSent == "number" && m && typeof m.packetsLost == "number" && typeof f.packetsLost == "number") {
+        const v = s.packetsSent - f.packetsSent, Ge = m.packetsLost - f.packetsLost;
+        v > 0 && (X = Math.max(0, Math.min(100, Ge / v * 100)));
+      }
+    }
+    Be = {
+      timestamp: p,
+      framesEncoded: s.framesEncoded,
+      bytesSent: s.bytesSent,
+      packetsSent: s.packetsSent,
+      packetsLost: m?.packetsLost
+    };
+    const w = {
+      codec: Ut(S),
+      encoderImplementation: s.encoderImplementation,
+      hardwareAccelerated: typeof s.powerEfficientEncoder == "boolean" ? s.powerEfficientEncoder : void 0,
+      framesPerSecond: $,
+      framesEncoded: s.framesEncoded,
+      bitrateBps: k,
+      width: s.frameWidth,
+      height: s.frameHeight,
+      qualityLimitationReason: s.qualityLimitationReason,
+      rttMs: typeof m?.roundTripTime == "number" ? m.roundTripTime * 1e3 : void 0,
+      packetsLostPct: X
+    };
+    L("onCameraStats", e.onCameraStats, w);
+  }, pt = () => {
+    Ke === null && (Be = null, Ke = setInterval(() => {
+      Pt();
+    }, 1e3));
+  }, He = () => {
+    Ke !== null && (clearInterval(Ke), Ke = null), Be = null, L("onCameraStats", e.onCameraStats, null);
+  }, Lt = (n, u, a, s) => Qe.enqueue(async ({ isCurrent: S }) => {
+    const m = () => S() && s() && _ === u && de === a;
+    if (!m()) return;
+    if (!n.active) {
+      const w = z;
+      try {
+        await a.replaceTrack(null);
+      } catch (N) {
+        y("replaceTrack(null) on camera detach failed:", N);
+      }
+      if (z === w && (z = null, ue = void 0, w && G(w)), He(), !m()) return;
+      L("onCameraDemandChange", e.onCameraDemandChange, !1);
+      return;
+    }
+    L("onCameraDemandChange", e.onCameraDemandChange, !0);
+    const p = z, f = p?.getVideoTracks()[0], $ = ue;
+    if (f?.readyState === "live" && $ && !Sn($, n)) {
+      ue = n, mt(u, f), pt();
+      return;
+    }
+    if (p) {
+      try {
+        await a.replaceTrack(null);
+      } catch (w) {
+        y("replaceTrack(null) before camera switch failed:", w);
+      }
+      if (z === p && (z = null, ue = void 0, G(p)), He(), !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: Tn(n),
+        audio: !1
+      });
+    } catch (w) {
+      console.warn("[RemoteControl] getUserMedia denied/failed:", w);
+    }
+    if (!m()) {
+      k && G(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 (G(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 (w) {
+      if (y("replaceTrack(videoTrack) failed:", w), G(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 (w) {
+        y("replaceTrack(null) for stale camera attach failed:", w);
+      }
+      G(k);
+      return;
+    }
+    try {
+      const w = a.getParameters();
+      (!w.encodings || w.encodings.length === 0) && (w.encodings = [{}]), w.encodings[0].maxBitrate = 8e6, w.encodings[0].maxFramerate = 30, w.degradationPreference = "maintain-framerate", await a.setParameters(w);
+    } catch (w) {
+      y("setParameters on outbound camera failed:", w);
+    }
+    if (!m()) {
+      try {
+        await a.replaceTrack(null);
+      } catch (w) {
+        y("replaceTrack(null) for stale camera finalize failed:", w);
+      }
+      G(k);
+      return;
+    }
+    z = k, ue = n, X.onended = () => {
+      z === k && Qe.enqueueCurrent(async ({ isCurrent: w }) => {
+        if (!(!w() || z !== k || !s() || _ !== u || de !== a)) {
+          try {
+            await a.replaceTrack(null);
+          } catch (N) {
+            y("replaceTrack(null) after camera ended failed:", N);
+          }
+          !w() || z !== k || !s() || _ !== u || de !== a || (z = null, ue = void 0, G(k), He(), u.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", e.onCameraDemandChange, !0, !1));
+        }
+      }).catch((w) => y("camera ended cleanup failed:", w));
+    }, m() && (mt(u, X), pt());
+  }), _e = () => {
+    for (const n of H) n();
+    H.clear();
+    for (const n of B.values()) clearTimeout(n);
+    B.clear();
+    for (const n of ee.values())
+      n(new Error("Simulator disconnected"));
+    for (const n of ie.values())
+      n(new Error("Simulator disconnected"));
+    ee.clear(), re.clear(), ie.clear(), ae.clear(), V?.(), V = void 0, bt(), b = null;
+    for (const n of fe.values())
+      clearTimeout(n.timer), n.reject(new Error("Simulator disconnected"));
+    fe.clear(), Oe = void 0, A(null), O({ controlReady: !1, videoReady: !1 }), $e(), Ie(), Ne(), q && (q.stop(), q = null), Ye !== null && We(null), Qe.invalidate(), He(), It(), ue = void 0, de = null, ++xe, Ze = !1, pe = null, te && (G(te), te = null, L("onMicrophoneStateChange", e.onMicrophoneStateChange, {
+      active: !1
+    })), we = null, _ && (_.onopen = null, _.onmessage = null, _.onerror = null, _.onclose = null, _.close(), _ = null), Pe?.close(), Pe = null, R && (R.onconnectionstatechange = null, R.oniceconnectionstatechange = null, R.ontrack = null, R.onicecandidate = null, R.close(), R = null), x && (x.onopen = null, x.onclose = null, x.onerror = null, x.close(), x = null);
+  }, Ct = () => {
+    document.hidden ? Re() : ft();
+  }, Ft = async () => {
+    if (e.transport) return e.transport.isTerminated?.() ?? !1;
+    if (typeof navigator < "u" && navigator.onLine === !1)
+      return !1;
+    let n;
+    try {
+      const s = new URL(r);
+      s.protocol = s.protocol === "wss:" ? "https:" : s.protocol === "ws:" ? "http:" : s.protocol, n = Kt(s.toString(), c);
+    } catch {
+      return !1;
+    }
+    const u = new AbortController(), a = window.setTimeout(() => u.abort(), Yn);
+    try {
+      return (await fetch(n, { method: "GET", cache: "no-store", signal: u.signal })).status === 404;
+    } catch {
+      return !1;
+    } finally {
+      window.clearTimeout(a);
+    }
+  }, Bt = () => {
+    Ee || (Ee = !0, le += 1, qe(), $e(), Ie(), _e(), T("Instance terminated"), Re(), De("terminated"), L("onTerminated", e.onTerminated));
+  }, xt = () => {
+    if (Ee || ye) return;
+    ye = !0;
+    const n = Ue;
+    Ft().catch(() => !1).then((u) => {
+      n === Ue && (ye = !1, u && Bt());
+    });
+  }, ge = (n, u) => {
+    if (Ee || u !== le)
+      return;
+    if (xt(), ne) {
+      if (!e.autoReconnect) {
+        T(`Connection failed after it was established: ${n}`), Re(), De("failed"), _e();
+        return;
+      }
+      T(`Reconnecting after established session dropped: ${n}`), ne = !1, Fe = -1;
+    }
+    qe();
+    const a = Fe + 1;
+    if (a >= st) {
+      T(`Connection failed after ${st} attempts: ${n}`), Re(), De("failed"), _e();
+      return;
+    }
+    T(`Retrying connection (${a + 1}/${st})`), De("reconnecting"), _e(), ve = window.setTimeout(() => {
+      ve = void 0, u === le && Ot(a);
+    }, Kn);
+  }, Ot = async (n = 0) => {
+    const { openUrl: u, axPollIntervalMs: a, axMaxBackoffMs: s, androidElementTreeOptions: S } = e;
+    if (Ee) return;
+    const m = le + 1;
+    le = m, Fe = n, ne = !1, n === 0 && Ce !== "reconnecting" && De("connecting"), qe(), $e(), Ne(), Me = !1, C(!1), _e();
+    const p = () => m === le;
+    Ae = window.setTimeout(() => {
+      Ae = void 0, !(!p() || ne) && ge("Connection did not succeed within 15 seconds", m);
+    }, wn);
+    try {
+      const f = e.transport ? await e.transport.connect() : new WebSocket(Kt(r, c));
+      if (!p()) {
+        f.close();
+        return;
+      }
+      if (_ = f, await new Promise((D, i) => {
+        let I = !1;
+        const W = () => K(() => i(new Error("Connection stopped")));
+        H.add(W);
+        const g = window.setTimeout(
+          () => K(() => i(new Error("WebSocket connection timeout"))),
+          3e4
+        ), K = (Z) => {
+          I || (I = !0, H.delete(W), window.clearTimeout(g), Z());
+        };
+        f.onopen = () => {
+          !p() || _ !== f || K(D);
+        }, f.onerror = (Z) => {
+          !p() || _ !== f || (T("WebSocket error: " + Z), K(() => i(new Error("WebSocket connection failed"))));
+        }, f.onclose = () => {
+          !p() || _ !== f || (T("WebSocket closed"), K(() => i(new Error("WebSocket closed before connection was established"))));
+        }, f.readyState === WebSocket.OPEN ? K(D) : f.readyState !== WebSocket.CONNECTING && K(() => i(new Error("WebSocket is closed")));
+      }), !p() || _ !== f)
+        return;
+      f.onerror = (D) => {
+        !p() || _ !== f || T("WebSocket error: " + D);
+      }, f.onclose = () => {
+        !p() || _ !== f || T("WebSocket closed");
+      };
+      const $ = new Promise((D, i) => {
+        let I = !1;
+        const W = () => g(() => i(new Error("Connection stopped")));
+        H.add(W);
+        const g = (J) => {
+          I || (I = !0, H.delete(W), window.clearTimeout(K), f.removeEventListener("message", Z), J());
+        }, K = window.setTimeout(
+          () => g(() => i(new Error("RTCConfiguration timeout"))),
+          3e4
+        ), Z = (J) => {
+          if (!(!p() || _ !== f))
+            try {
+              const Q = JSON.parse(J.data);
+              if (Q.type === "signalingError" && Q.requestType === "requestRtcConfiguration" && Q.sessionId === d) {
+                const $t = typeof Q.error == "string" ? Q.error : "Unable to load streaming configuration";
+                g(() => i(new Error($t)));
+              } else Q.type === "rtcConfiguration" && g(
+                () => D({
+                  rtcConfiguration: Q.rtcConfiguration,
+                  cameraSupported: Q.cameraSupported === !0,
+                  foldSupported: Q.foldSupported === !0
+                })
+              );
+            } catch (Q) {
+              console.error("Error handling RTC configuration:", Q), g(() => i(Q));
+            }
+        };
+        f.addEventListener("message", Z), f.send(
+          JSON.stringify({
+            type: "requestRtcConfiguration",
+            sessionId: d
+          })
+        );
+      }), {
+        rtcConfiguration: k,
+        cameraSupported: X,
+        foldSupported: w
+      } = await $;
+      if (!p() || _ !== f)
+        return;
+      const N = E === "iphone-duo" || w;
+      U(N);
+      const v = new RTCPeerConnection({ ...k, iceTransportPolicy: "relay" });
+      R = v;
+      const Ge = { peer: v, displays: /* @__PURE__ */ new Map() };
+      b = Ge, F(), v.addTransceiver("audio", { direction: "recvonly" });
+      const Wt = v.addTransceiver("video", { direction: "recvonly" }), qt = N ? v.addTransceiver("video", { direction: "recvonly" }) : null, Tt = l === "ios" || X, nt = Tt ? v.addTransceiver("video", {
+        direction: "sendonly"
+      }) : null;
+      if (de = nt?.sender ?? null, we = (Tt ? v.addTransceiver("audio", {
+        direction: "sendonly"
+      }) : null)?.sender ?? null, RTCRtpReceiver.getCapabilities) {
+        const D = RTCRtpReceiver.getCapabilities("video");
+        if (D && D.codecs) {
+          const I = D.codecs.sort((W, g) => {
+            const K = (Z) => {
+              const J = Z.mimeType.toLowerCase();
+              return J.includes("vp9") ? 1 : J.includes("h265") || J.includes("hevc") ? 2 : J.includes("h264") || J.includes("avc") ? 3 : 4;
+            };
+            return K(W) - K(g);
+          });
+          Wt.setCodecPreferences(I), qt?.setCodecPreferences(I), ce("Set codec preferences:", I.map((W) => W.mimeType).join(", "));
+        }
+      }
+      if (nt && RTCRtpSender.getCapabilities) {
+        const D = RTCRtpSender.getCapabilities("video");
+        if (D && D.codecs) {
+          const i = /* @__PURE__ */ new Set(["42e01f", "42e028", "640c1f"]), I = (g) => {
+            const K = g.mimeType.toLowerCase(), J = (g.sdpFmtpLine || "").toLowerCase().match(/profile-level-id=([0-9a-f]{6})/), Q = J ? J[1] : "";
+            return K === "video/h265" || K === "video/hevc" ? 1 : K === "video/h264" && i.has(Q) ? 2 : K === "video/h264" ? 3 : K === "video/vp9" ? 4 : K === "video/vp8" ? 5 : K === "video/rtx" || K === "video/red" || K === "video/ulpfec" ? 0 : 6;
+          }, W = [...D.codecs].sort((g, K) => I(g) - I(K));
+          try {
+            nt.setCodecPreferences(W), ce(
+              "Outbound camera codec preferences:",
+              W.map((g) => `${g.mimeType}${g.sdpFmtpLine ? `[${g.sdpFmtpLine}]` : ""}`).join(", ")
+            );
+          } catch (g) {
+            y("Failed to set outbound camera codec preferences:", g);
+          }
+        }
+      }
+      const oe = v.createDataChannel("control", {
+        ordered: !0,
+        negotiated: !0,
+        id: 1
+      });
+      x = oe;
+      const rt = !N && e.onTrace ? Dn(v, (D) => {
+        p() && R === v && L("onTrace", e.onTrace, D);
+      }) : null;
+      if (Pe = rt, oe.onopen = () => {
+        if (!p() || x !== oe || _ !== f)
+          return;
+        ne = !0, N && ut().catch((i) => {
+          p() && _ === f && f.readyState === WebSocket.OPEN && M(i instanceof Error ? i.message : String(i));
+        }), O({ controlReady: !0 }), $e(), T("Control channel opened"), q || (q = new hn({
+          platform: l,
+          baseIntervalMs: a,
+          maxBackoffMs: s,
+          androidElementTreeOptions: S,
+          send: (i) => {
+            if (!_ || _.readyState !== WebSocket.OPEN) return !1;
+            try {
+              return _.send(JSON.stringify(i)), !0;
+            } catch {
+              return !1;
+            }
+          },
+          onSnapshot: We,
+          onStatusChange: (i, I) => {
+            L("onAxStatusChange", e.onAxStatusChange, i, I);
+          }
+        }), (e.inspectMode === !0 || e.inspectMode === "hover-only") && q.start());
+        const D = () => {
+          !p() || Me || x !== oe || _ !== f || f.readyState !== WebSocket.OPEN || f.send(JSON.stringify({ type: "requestFrame", sessionId: d }));
+        };
+        if (D(), Ne(), Le = window.setInterval(() => {
+          if (!p() || Me || x !== oe || _ !== f || f.readyState !== WebSocket.OPEN) {
+            Ne();
+            return;
+          }
+          D();
+        }, 250), u) {
+          try {
+            const i = decodeURIComponent(u);
+            T("Opening URL"), f.send(
+              JSON.stringify({
+                type: "openUrl",
+                url: i,
+                sessionId: d
+              })
+            );
+          } catch (i) {
+            console.error({ error: i }, "Error decoding URL, falling back to the original URL"), f.send(
+              JSON.stringify({
+                type: "openUrl",
+                url: u,
+                sessionId: d
+              })
+            );
+          }
+          q?.bumpActivity();
+        }
+      }, oe.onclose = () => {
+        !p() || x !== oe || (O({ controlReady: !1 }), T("Control channel closed"));
+      }, oe.onerror = (D) => {
+        !p() || x !== oe || (console.error("Control channel error:", D), T("Control channel error: " + D));
+      }, v.onconnectionstatechange = () => {
+        !p() || R !== v || (T("Connection state: " + v.connectionState), v.connectionState === "failed" && ne && ge("WebRTC connection entered failed state", m));
+      }, v.oniceconnectionstatechange = () => {
+        if (!p() || R !== v)
+          return;
+        const D = v.iceConnectionState;
+        if (T("ICE state: " + D), D === "connected" || D === "completed") {
+          Ie(), et() && !te && tt();
+          return;
+        }
+        if (D === "failed") {
+          Ie(), ne && ge("ICE connection entered failed state", m);
+          return;
+        }
+        D === "disconnected" && ne && e.autoReconnect && me === void 0 && (me = window.setTimeout(() => {
+          me = void 0, !(!p() || R !== v) && v.iceConnectionState === "disconnected" && ge("ICE stayed disconnected past grace period", m);
+        }, Mn));
+      }, v.ontrack = (D) => {
+        if (!p() || R !== v)
+          return;
+        vt(D.receiver, e.jitterBufferTargetMs);
+        const i = D.track.id === "duo-inner" || D.streams.some((I) => I.id === "duo-inner");
+        if (D.track.kind === "video" && Ge.displays.set(D.receiver, i ? "inner" : "primary"), T("Received remote track: " + D.track.kind), D.track.kind === "video") {
+          const I = i ? "inner" : "primary", W = N ? new MediaStream([D.track]) : D.streams[0] ?? new MediaStream([D.track]);
+          Se.set(I, W);
+          for (const [g, K] of Y)
+            K.display === I && ct(g, K, W);
+        }
+      }, v.onicecandidate = (D) => {
+        if (!(!p() || R !== v || _ !== f))
+          if (D.candidate && f.readyState === WebSocket.OPEN) {
+            const i = {
+              type: "candidate",
+              candidate: D.candidate.candidate,
+              sdpMid: D.candidate.sdpMid,
+              sdpMLineIndex: D.candidate.sdpMLineIndex,
+              sessionId: d
+            };
+            f.send(JSON.stringify(i)), T("Sent ICE candidate");
+          } else
+            T("ICE candidate gathering completed");
+      }, f.onmessage = async (D) => {
+        if (!p() || _ !== f)
+          return;
+        let i;
+        try {
+          i = JSON.parse(D.data);
+        } catch (I) {
+          y("Error parsing message:", I);
+          return;
+        }
+        if (!q?.handleMessage(i))
+          switch (T("Received: " + i.type), i.type) {
+            case "performActionsResult":
+            case "foldStateResult":
+            case "foldStateChanged": {
+              N && i.state && (A(i.state), M(void 0));
+              const g = fe.get(i.id);
+              g && (clearTimeout(g.timer), fe.delete(i.id), i.error ? g.reject(new Error(i.error)) : g.resolve());
+              break;
+            }
+            case "signalingError": {
+              if (i.requestType !== "offer" || i.sessionId !== d)
+                break;
+              const g = typeof i.error == "string" ? i.error : "Unable to establish the streaming connection";
+              T("Error: " + g), ge(g, m);
+              break;
+            }
+            case "answer":
+              if (!R || R !== v) {
+                T("No peer connection, skipping answer");
+                break;
+              }
+              if (rt?.accept(i.latencyTraceVersion), await v.setRemoteDescription(
+                new RTCSessionDescription({
+                  type: "answer",
+                  sdp: i.sdp
+                })
+              ), !p() || R !== v)
+                return;
+              T("Set remote description");
+              break;
+            case "candidate":
+              if (!R || R !== v) {
+                T("No peer connection, skipping candidate");
+                break;
+              }
+              if (await v.addIceCandidate(
+                new RTCIceCandidate({
+                  candidate: i.candidate,
+                  sdpMid: i.sdpMid,
+                  sdpMLineIndex: i.sdpMLineIndex
+                })
+              ), !p() || R !== v)
+                return;
+              T("Added ICE candidate");
+              break;
+            case "screenshot":
+            case "screenshotResult": {
+              if (typeof i.id != "string") {
+                y("Received invalid screenshot success message:", i);
+                break;
+              }
+              const g = bn(i);
+              if (g) {
+                const J = ee.get(i.id);
+                if (typeof J != "function") {
+                  y(`Received screenshot error for unknown or handled id: ${i.id}`);
+                  break;
+                }
+                y(`Received screenshot error for id ${i.id}: ${g}`), J(new Error(g)), re.delete(i.id), ee.delete(i.id), clearTimeout(B.get(i.id)), B.delete(i.id);
+                break;
+              }
+              const K = Rn(i);
+              if (!K) {
+                y("Received screenshot message without image data:", i);
+                break;
+              }
+              const Z = re.get(i.id);
+              if (typeof Z != "function") {
+                y(`Received screenshot data for unknown or handled id: ${i.id}`);
+                break;
+              }
+              ce(`Received screenshot data for id ${i.id}`), Z(K), re.delete(i.id), ee.delete(i.id), clearTimeout(B.get(i.id)), B.delete(i.id);
+              break;
+            }
+            case "screenshotError":
+              if (typeof i.id != "string" || typeof i.message != "string") {
+                y("Received invalid screenshot error message:", i);
+                break;
+              }
+              const I = ee.get(i.id);
+              if (typeof I != "function") {
+                y(`Received screenshot error for unknown or handled id: ${i.id}`);
+                break;
+              }
+              y(`Received screenshot error for id ${i.id}: ${i.message}`), I(new Error(i.message)), re.delete(i.id), ee.delete(i.id), clearTimeout(B.get(i.id)), B.delete(i.id);
+              break;
+            case "cameraRequest": {
+              const g = de;
+              if (!g)
+                break;
+              const K = gn(i);
+              if (!K) {
+                y("Received invalid cameraRequest:", i);
+                break;
+              }
+              console.info("[RemoteControl] cameraRequest received:", K.active, K.facingMode), await Lt(K, f, g, p);
+              break;
+            }
+            case "microphoneRequest": {
+              if (!we)
+                break;
+              const g = i.active === !0;
+              if (Ze = g, console.info("[RemoteControl] microphoneRequest received, active=", g), !g) {
+                ze || await Ve();
+                break;
+              }
+              if (te) {
+                ht(f);
+                break;
+              }
+              await tt();
+              break;
+            }
+            case "microphoneStartResult": {
+              if (pe === null || i.id !== pe)
+                break;
+              pe = null, typeof i.error == "string" && (console.warn("[RemoteControl] microphoneStart rejected by host:", i.error), Ve(i.error));
+              break;
+            }
+            case "terminateAppResult":
+              if (typeof i.id != "string") {
+                y("Received invalid terminateApp result message:", i);
+                break;
+              }
+              if (typeof i.error == "string") {
+                const g = ie.get(i.id);
+                if (typeof g != "function") {
+                  y(`Received terminateApp error for unknown or handled id: ${i.id}`);
+                  break;
+                }
+                y(`Received terminateApp error for id ${i.id}: ${i.error}`), g(new Error(i.error)), ae.delete(i.id), ie.delete(i.id), clearTimeout(B.get(i.id)), B.delete(i.id);
+                break;
+              }
+              const W = ae.get(i.id);
+              if (typeof W != "function") {
+                y(`Received terminateApp result for unknown or handled id: ${i.id}`);
+                break;
+              }
+              ce(`Received terminateApp success for id ${i.id}`), W(), ae.delete(i.id), ie.delete(i.id), clearTimeout(B.get(i.id)), B.delete(i.id);
+              break;
+            default:
+              y(`Received unhandled message type: ${i.type}`, i);
+              break;
+          }
+      }, R === v) {
+        const D = await v.createOffer({
+          offerToReceiveVideo: !0,
+          offerToReceiveAudio: !1
+        });
+        if (!p() || R !== v || (await v.setLocalDescription(D), !p() || R !== v))
+          return;
+        p() && _ === f && f.readyState === WebSocket.OPEN && f.send(
+          JSON.stringify({
+            type: "offer",
+            ...N ? { displayStreams: !0 } : {},
+            ...rt ? { latencyTraceVersion: 1 } : {},
+            sdp: D.sdp,
+            sessionId: d
+          })
+        ), T("Sent offer");
+      }
+    } catch (f) {
+      if (!p() || f instanceof Error && f.message === "Connection stopped")
+        return;
+      const $ = f instanceof Error ? f.message : String(f);
+      T("Error: " + $), ge($, m);
+    }
+  }, Dt = () => {
+    if (j) throw new Error("Device stream is disposed");
+    Ue++, ye = !1, We(null), Ce !== "reconnecting" && (Ce = null), document.addEventListener("visibilitychange", Ct), document.hidden || ft(), Ee = !1, Ot(0);
+  }, _t = () => {
+    Ue++, ye = !1, Re(), document.removeEventListener("visibilitychange", Ct), le += 1, Fe = 0, ne = !1, qe(), Ie(), _e(), Ce = null, O({ connection: "idle", videoReady: !1, controlReady: !1 }), T("Stopped");
+  }, gt = (n, u = "primary") => {
+    if (j) throw new Error("Device stream is disposed");
+    if (Y.has(n)) throw new Error("Video element is already attached");
+    const a = { display: u };
+    Y.set(n, a);
+    const s = () => {
+      u === "primary" && Se.has(u) && Nt();
+    };
+    n.addEventListener("loadeddata", s);
+    const S = Se.get(u);
+    S && ct(n, a, S);
+    let m = !1;
+    const p = () => {
+      m || (m = !0, P.delete(p), n.removeEventListener("loadeddata", s), a.stop?.(), Y.delete(n), n.srcObject = null);
+    };
+    return P.add(p), p;
+  };
+  return {
+    start: Dt,
+    stop: _t,
+    attachVideo: gt,
+    attachFrameSink: (n, u = "primary") => {
+      const a = document.createElement("video");
+      a.muted = !0, a.playsInline = !0, a.autoplay = !0;
+      const s = gt(a, u);
+      let S = !1, m = 0, p = 0;
+      const f = () => {
+        a.cancelVideoFrameCallback?.(m), cancelAnimationFrame(p);
+      }, $ = () => {
+        S || !a.srcObject || (a.readyState >= 2 && a.videoWidth > 0 && L(
+          "present",
+          (...w) => n.present(...w),
+          a,
+          a.videoWidth,
+          a.videoHeight,
+          u
+        ), !(S || !a.srcObject) && (a.requestVideoFrameCallback ? m = a.requestVideoFrameCallback($) : p = requestAnimationFrame($)));
+      }, k = () => {
+        f(), $();
+      };
+      Y.get(a).clear = f, a.addEventListener("loadeddata", k);
+      const X = () => {
+        S || (S = !0, P.delete(X), f(), a.removeEventListener("loadeddata", k), s(), a.remove());
+      };
+      return P.delete(s), P.add(X), a.readyState >= 2 && k(), X;
+    },
+    dispose: () => {
+      if (!j) {
+        j = !0, _t();
+        for (const n of P) n();
+        P.clear();
+      }
+    },
+    getState: () => h,
+    updateOptions: (n) => {
+      if (j) throw new Error("Device stream is disposed");
+      const u = e;
+      if (e = { ...e, ...n }, u.jitterBufferTargetMs !== e.jitterBufferTargetMs)
+        for (const a of R?.getTransceivers() ?? [])
+          (a.currentDirection === "recvonly" || a.currentDirection === "sendrecv") && vt(a.receiver, e.jitterBufferTargetMs);
+      !!u.onPlaybackStats != !!e.onPlaybackStats && F(), !!u.microphoneEnabled != !!e.microphoneEnabled && (ze = e.microphoneEnabled ?? !1, et() ? tt() : Ve()), !!u.inspectMode != !!e.inspectMode && (e.inspectMode ? q?.start() : (q?.stop(), Ye !== null && We(null)));
+    },
+    sendControl: se,
+    sendTouch: (n, u, a, s, S, m = 0) => se(
+      Ht(
+        n === "begin" ? 0 : n === "end" ? 1 : 2,
+        m,
+        s,
+        S,
+        u,
+        a,
+        n === "end" ? 0 : 1
+      )
+    ),
+    sendText: (n) => se(Gt(n)),
+    sendDisplayTouch: (n, u, a, s) => se(jt(n, u, a, s)),
+    sendDuoControl: be,
+    pressButton: (n) => {
+      if (l === "ios") {
+        if (!h.controlReady || n === "back") return;
+        const a = n === "power" ? "lock" : "home", s = [
+          { type: "buttonDown", button: a },
+          { type: "buttonUp", button: a }
+        ], S = n === "recents" ? [...s, { type: "wait", durationMs: 100 }, ...s] : s;
+        be("performActions", { actions: S }).catch(
+          (m) => console.warn("[DeviceStream] Button command failed:", m)
+        );
+        return;
+      }
+      const u = { home: 3, back: 4, recents: 187, power: 26 }[n];
+      se(it(0, u, 0, 0)), se(it(1, u, 0, 0));
+    },
+    rotate: () => {
+      if (l === "android") {
+        se(new Uint8Array([11]).buffer);
+        return;
+      }
+      if (!h.controlReady) return;
+      if (h.duo) {
+        (async () => {
+          h.duoState || await ut();
+          const p = h.duoState?.orientation;
+          if (!p) throw new Error("Duo orientation unavailable");
+          const f = ["portrait", "landscape-left", "pud", "landscape-right"], $ = f.indexOf(p);
+          await be("setDuoOrientation", { orientation: f[($ + 1) % f.length] });
+        })().catch((p) => console.warn("[DeviceStream] Rotation command failed:", p));
+        return;
+      }
+      const n = [...Y].find(
+        ([m, p]) => p.display === "primary" && m.videoWidth > 0
+      )?.[0], u = Se.get("primary")?.getVideoTracks()[0]?.getSettings(), a = n?.videoWidth ?? u?.width ?? 0, s = n?.videoHeight ?? u?.height ?? 0, S = a > s ? "Portrait" : "Landscape";
+      be("performActions", { actions: [{ type: "setOrientation", orientation: S }] }).catch(
+        (m) => console.warn("[DeviceStream] Rotation command failed:", m)
+      );
+    },
+    bumpActivity: () => q?.bumpActivity(),
+    getAxStatus: () => q?.getStatus() ?? "idle",
+    openUrl: (n) => {
+      if (!_ || _.readyState !== WebSocket.OPEN) {
+        y("WebSocket not open, cannot send open_url command.");
+        return;
+      }
+      try {
+        const u = decodeURIComponent(n);
+        T("Opening URL"), _.send(
+          JSON.stringify({
+            type: "openUrl",
+            url: u,
+            sessionId: d
+          })
+        );
+      } catch (u) {
+        y("Error decoding or sending URL :", { error: u, url: n }), _.send(
+          JSON.stringify({
+            type: "openUrl",
+            url: n,
+            sessionId: d
+          })
+        );
+      }
+      q?.bumpActivity();
+    },
+    sendKeyEvent: (n) => {
+      if (!x || x.readyState !== "open") {
+        y("Data channel not ready for imperative key command:", x?.readyState);
+        return;
+      }
+      const u = Vt[n.code];
+      if (!u) {
+        y(`Unknown event.code for imperative command: ${n.code}`);
+        return;
+      }
+      let a = o.META_NONE;
+      n.shiftKey && (a |= o.META_SHIFT_ON), n.altKey && (a |= o.META_ALT_ON), n.ctrlKey && (a |= o.META_CTRL_ON), n.metaKey && (a |= o.META_META_ON);
+      const s = n.type === "keydown" ? o.ACTION_DOWN : o.ACTION_UP;
+      ce(
+        `Sending Imperative Key Command: code=${n.code}, keycode=${u}, action=${s}, meta=${a}`
+      );
+      const S = it(
+        s,
+        u,
+        0,
+        // repeat count, typically 0 for single presses
+        a
+      );
+      S && se(S);
+    },
+    screenshot: (n) => new Promise((u, a) => {
+      if (!_ || _.readyState !== WebSocket.OPEN)
+        return y("WebSocket not open, cannot send screenshot command."), a(new Error("WebSocket is not connected or connection is not open."));
+      const s = `ui-ss-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`, S = {
+        type: n ? "screenshotDisplay" : "screenshot",
+        ...n ? { display: n } : {},
+        id: s
+      };
+      re.set(s, u), ee.set(s, a), ce("Sending screenshot request:", S);
+      try {
+        _.send(JSON.stringify(S));
+      } catch (m) {
+        y("Failed to send screenshot request immediately:", m), re.delete(s), ee.delete(s), a(m);
+        return;
+      }
+      B.set(
+        s,
+        setTimeout(() => {
+          B.delete(s), re.has(s) && (y(`Screenshot request timed out for id ${s}`), ee.get(s)?.(new Error("Screenshot request timed out")), re.delete(s), ee.delete(s));
+        }, 3e4)
+      );
+    }),
+    terminateApp: (n) => new Promise((u, a) => {
+      if (!_ || _.readyState !== WebSocket.OPEN)
+        return y("WebSocket not open, cannot send terminateApp command."), a(new Error("WebSocket is not connected or connection is not open."));
+      const s = `ui-term-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`, S = {
+        type: "terminateApp",
+        id: s,
+        bundleId: n
+      };
+      ae.set(s, u), ie.set(s, a), ce("Sending terminateApp request:", S);
+      try {
+        _.send(JSON.stringify(S));
+      } catch (m) {
+        y("Failed to send terminateApp request immediately:", m), ae.delete(s), ie.delete(s), a(m);
+        return;
+      }
+      q?.bumpActivity(), B.set(
+        s,
+        setTimeout(() => {
+          B.delete(s), ae.has(s) && (y(`terminateApp request timed out for id ${s}`), ie.get(s)?.(new Error("terminateApp request timed out")), ae.delete(s), ie.delete(s));
+        }, 3e4)
+      );
+    }),
+    reconnect: () => Dt(),
+    refreshAxTree: async () => {
+      const n = q;
+      if (!n)
+        throw new Error("Inspect mode is not active");
+      return n.refresh();
+    },
+    getAxSnapshot: () => Ye
+  };
+}
+const bn = (t) => typeof t.message == "string" ? t.message : typeof t.error == "string" ? t.error : null, Rn = (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 {
+  ot as A,
+  jt as B,
+  Xe as C,
+  Un as D,
+  Bn as H,
+  $n as a,
+  Vn as b,
+  Hn as c,
+  on as d,
+  an as e,
+  qn as f,
+  en as g,
+  sn as h,
+  An as i,
+  Gn as j,
+  ce as k,
+  y as l,
+  Gt as m,
+  rn as n,
+  it as o,
+  o as p,
+  Ht as q,
+  Vt as r,
+  L as s,
+  Je as t,
+  kn as u,
+  Wn as v,
+  xn as w,
+  Pn as x,
+  Fn as y,
+  Ln as z
+};