@pickleball/expo-sdk 0.1.1 → 1.0.0

package/dist/chunk-KFQGP6VL.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-LCWGNGEN.cjs

@@ -0,0 +1,265 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;// src/match/remote/deduplicator.ts
+var BTHomeRemoteDeduplicator = (_class = class {
+  __init() {this.devices = /* @__PURE__ */ new Map()}
+  
+  constructor(options = {}) {;_class.prototype.__init.call(this);
+    this.fingerprintWindowMs = _nullishCoalesce(options.fingerprintWindowMs, () => ( 300));
+  }
+  get trackedDeviceCount() {
+    return this.devices.size;
+  }
+  accept(deviceId, key, now = Date.now()) {
+    const previous = this.devices.get(deviceId);
+    if (key.packetId !== void 0) {
+      if (_optionalChain([previous, 'optionalAccess', _ => _.packetId]) === key.packetId) return false;
+      this.devices.set(deviceId, { packetId: key.packetId });
+      return true;
+    }
+    if (_optionalChain([previous, 'optionalAccess', _2 => _2.fingerprint]) === key.fingerprint && previous.fingerprintSeenAt !== void 0 && now - previous.fingerprintSeenAt <= this.fingerprintWindowMs) {
+      return false;
+    }
+    this.devices.set(deviceId, { fingerprint: key.fingerprint, fingerprintSeenAt: now });
+    return true;
+  }
+  forget(deviceId) {
+    this.devices.delete(deviceId);
+  }
+  clear() {
+    this.devices.clear();
+  }
+}, _class);
+
+// src/match/remote/encoding.ts
+function decodeBase64Bytes(value) {
+  if (typeof globalThis.atob !== "function") {
+    throw new Error("Base64 decoding is unavailable in this runtime");
+  }
+  const binary = globalThis.atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+// src/match/remote/hid-gesture.ts
+var HidVolumeGestureRecognizer = (_class2 = class {
+  constructor(options) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
+    this.options = options;
+  }
+  __init2() {this.count = 0}
+  __init3() {this.resolved = false}
+  __init4() {this.lastTimestamp = null}
+  __init5() {this.timer = null}
+  push(event) {
+    if (this.options.direction !== "any" && event.direction !== this.options.direction) return;
+    if (this.lastTimestamp !== null && event.timestamp - this.lastTimestamp > this.options.settleMs) {
+      this.finishBurst();
+    }
+    this.lastTimestamp = event.timestamp;
+    this.clearTimer();
+    if (!this.resolved) {
+      this.count += 1;
+      if (event.longPress || this.count >= this.options.holdEventCount) {
+        this.resolved = true;
+        this.options.onGesture("hold");
+      }
+    }
+    this.timer = setTimeout(() => this.finishBurst(), this.options.settleMs);
+  }
+  dispose() {
+    this.clearTimer();
+    this.reset();
+  }
+  finishBurst() {
+    this.clearTimer();
+    if (!this.resolved && this.count > 0) {
+      this.options.onGesture(
+        this.count === 1 ? "single" : this.count === 2 ? "double" : this.count === 3 ? "triple" : "quadruple"
+      );
+    }
+    this.reset();
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  reset() {
+    this.count = 0;
+    this.resolved = false;
+    this.lastTimestamp = null;
+  }
+}, _class2);
+
+// src/match/remote/types.ts
+var BTHOME_SERVICE_UUID = "FCD2";
+var DEFAULT_REMOTE_ACTION_MAPPING = {
+  volumeUp: "left",
+  volumeDown: "right",
+  longPress: "undo"
+};
+var RemoteError = (_class3 = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);_class3.prototype.__init6.call(this);;
+    this.code = code;
+  }
+  __init6() {this.name = "RemoteError"}
+}, _class3);
+
+// src/match/remote/parser.ts
+var BTHomeRemoteParseError = (_class4 = class extends Error {
+  constructor(code, message) {
+    super(message);_class4.prototype.__init7.call(this);;
+    this.code = code;
+  }
+  __init7() {this.name = "BTHomeRemoteParseError"}
+}, _class4);
+var OBJECT_LENGTHS = Object.freeze({
+  0: 1,
+  1: 1,
+  2: 2,
+  3: 2,
+  4: 3,
+  5: 3,
+  6: 2,
+  7: 2,
+  8: 2,
+  9: 1,
+  10: 3,
+  11: 3,
+  12: 2,
+  13: 2,
+  14: 2,
+  15: 1,
+  16: 1,
+  17: 1,
+  18: 2,
+  19: 2,
+  20: 2,
+  21: 1,
+  22: 1,
+  23: 1,
+  24: 1,
+  25: 1,
+  26: 1,
+  27: 1,
+  28: 1,
+  29: 1,
+  30: 1,
+  31: 1,
+  32: 1,
+  33: 1,
+  34: 1,
+  35: 1,
+  36: 1,
+  37: 1,
+  38: 1,
+  39: 1,
+  40: 1,
+  41: 1,
+  42: 1,
+  43: 1,
+  44: 1,
+  45: 1,
+  46: 1,
+  47: 1,
+  58: 1,
+  60: 2,
+  61: 2,
+  62: 4,
+  63: 2,
+  64: 1,
+  65: 1,
+  66: 1,
+  67: 1,
+  68: 2,
+  69: 2,
+  70: 4,
+  71: 4,
+  72: 4,
+  73: 2,
+  74: 2,
+  75: 2,
+  76: 4,
+  77: 4,
+  78: 4,
+  79: 4
+});
+function isBTHomeUuid(uuid) {
+  const normalized = uuid.toLowerCase().replaceAll("-", "");
+  return normalized === "fcd2" || normalized === "0000fcd200001000800000805f9b34fb";
+}
+function fingerprint(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function mapButtonEvent(value) {
+  if (value === 1) return "single";
+  if (value === 2) return "double";
+  if (value === 4 || value === 128) return "long";
+  if (value === 0 || value === 3 || value === 5 || value === 6) return null;
+  return void 0;
+}
+function parseBTHomeV2Advertisement(input) {
+  if (!isBTHomeUuid(input.serviceUuid)) {
+    throw new BTHomeRemoteParseError("wrong_uuid", `Expected ${BTHOME_SERVICE_UUID} service data`);
+  }
+  if (input.serviceData.length < 1) {
+    throw new BTHomeRemoteParseError("truncated", "BTHome device-info byte is missing");
+  }
+  const info = input.serviceData[0];
+  const version = info >> 5 & 7;
+  if (version !== 2) {
+    throw new BTHomeRemoteParseError("unsupported_version", `Unsupported BTHome version ${version}`);
+  }
+  if ((info & 1) !== 0) {
+    throw new BTHomeRemoteParseError("encrypted", "Encrypted BTHome advertisements are unsupported");
+  }
+  let offset = 1;
+  let objectIndex = 0;
+  let packetId;
+  let button;
+  while (offset < input.serviceData.length) {
+    const objectId = input.serviceData[offset++];
+    const length = OBJECT_LENGTHS[objectId];
+    if (length === void 0) {
+      throw new BTHomeRemoteParseError("unknown_object", `Unknown BTHome object 0x${objectId.toString(16)}`);
+    }
+    if (offset + length > input.serviceData.length) {
+      throw new BTHomeRemoteParseError("truncated", `BTHome object 0x${objectId.toString(16)} is truncated`);
+    }
+    if (objectId === 0 && packetId === void 0) packetId = input.serviceData[offset];
+    if (objectId === 58 && !button) {
+      const rawEvent = input.serviceData[offset];
+      const action = mapButtonEvent(rawEvent);
+      if (action === void 0) {
+        throw new BTHomeRemoteParseError("invalid_button_event", `Reserved button event 0x${rawEvent.toString(16)}`);
+      }
+      if (action) button = { action, objectIndex, rawEvent };
+    }
+    offset += length;
+    objectIndex += 1;
+  }
+  if (!button) {
+    throw new BTHomeRemoteParseError("no_button", "No actionable BTHome button event was found");
+  }
+  return {
+    deviceId: input.deviceId,
+    version: 2,
+    encrypted: false,
+    triggerBased: (info & 4) !== 0,
+    packetId,
+    button,
+    fingerprint: fingerprint(input.serviceData)
+  };
+}
+
+
+
+
+
+
+
+
+
+
+exports.BTHomeRemoteDeduplicator = BTHomeRemoteDeduplicator; exports.decodeBase64Bytes = decodeBase64Bytes; exports.HidVolumeGestureRecognizer = HidVolumeGestureRecognizer; exports.BTHOME_SERVICE_UUID = BTHOME_SERVICE_UUID; exports.DEFAULT_REMOTE_ACTION_MAPPING = DEFAULT_REMOTE_ACTION_MAPPING; exports.RemoteError = RemoteError; exports.BTHomeRemoteParseError = BTHomeRemoteParseError; exports.parseBTHomeV2Advertisement = parseBTHomeV2Advertisement;

package/dist/chunk-TBUEXRFQ.cjs

@@ -0,0 +1,318 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkIUIRVKJIcjs = require('./chunk-IUIRVKJI.cjs');
+
+
+var _chunk7OX2DSKIcjs = require('./chunk-7OX2DSKI.cjs');
+
+// src/resume-policy.ts
+function classifyResumeStatus(status) {
+  if (status === 404 || status === 409 || status === 410) return "gone";
+  if (status >= 200 && status < 300) return "ok";
+  return "retry";
+}
+var RESUME_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
+function resumeRetryDelayMs(attempt) {
+  const index = Math.min(Math.max(attempt, 0), RESUME_RETRY_DELAYS_MS.length - 1);
+  return RESUME_RETRY_DELAYS_MS[index];
+}
+function resumeBlocksArm(input) {
+  if (input.engineSessionId !== null) return false;
+  return input.adoptableSessionId !== null || input.serverSessionId !== null;
+}
+function resumeExternalSessionId(sessionId) {
+  return `resume-${sessionId}`;
+}
+function resumeGrantMatches(externalSessionId, grantSessionId) {
+  return externalSessionId === resumeExternalSessionId(grantSessionId);
+}
+
+// src/auto-resume.tsx
+var _react = require('react');
+function useLatest(value) {
+  const ref = _react.useRef.call(void 0, value);
+  ref.current = value;
+  return ref;
+}
+function PickleballAutoResume(props) {
+  const {
+    provider,
+    resumeInput,
+    enabled = true,
+    sessionIdHint = null,
+    retryDelayMs = resumeRetryDelayMs,
+    onAttempt
+  } = props;
+  const live = _chunkIUIRVKJIcjs.useLivestream.call(void 0, );
+  const { engine } = _chunkIUIRVKJIcjs.useLivestreamHost.call(void 0, );
+  const goneRef = _react.useRef.call(void 0, null);
+  const attemptRef = _react.useRef.call(void 0, 0);
+  const [retryTick, setRetryTick] = _react.useState.call(void 0, 0);
+  const { state, sessionId, adoptableSessionId } = live;
+  const resumeId = _nullishCoalesce(adoptableSessionId, () => ( sessionIdHint));
+  const liveRef = useLatest(live);
+  const onAttemptRef = useLatest(onAttempt);
+  const resumeInputRef = useLatest(resumeInput);
+  const retryDelayRef = useLatest(retryDelayMs);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) return;
+    if (!resumeId || sessionId !== null || state !== "preview") return;
+    if (goneRef.current === resumeId) return;
+    let cancelled = false;
+    let timer;
+    const scheduleRetry = () => {
+      const delay = retryDelayRef.current(attemptRef.current);
+      attemptRef.current += 1;
+      timer = setTimeout(() => {
+        if (!cancelled) setRetryTick((tick) => tick + 1);
+      }, delay);
+    };
+    void (async () => {
+      const result = await provider.resume(resumeId);
+      if (cancelled) return;
+      _optionalChain([onAttemptRef, 'access', _ => _.current, 'optionalCall', _2 => _2(resumeId, result.kind)]);
+      if (result.kind === "gone") {
+        goneRef.current = resumeId;
+        attemptRef.current = 0;
+        void engine.abandonAdoptableSession(resumeId).catch(() => void 0);
+        return;
+      }
+      if (result.kind === "retry") {
+        scheduleRetry();
+        return;
+      }
+      attemptRef.current = 0;
+      provider.adoptResumeGrant(result.grant);
+      const resumeInput2 = resumeInputRef.current;
+      await liveRef.current.start(
+        {
+          externalSessionId: resumeExternalSessionId(resumeId),
+          title: _nullishCoalesce(_optionalChain([resumeInput2, 'access', _3 => _3.titleFor, 'optionalCall', _4 => _4(resumeId)]), () => ( "Phi\xEAn \u0111ang kh\xF4i ph\u1EE5c")),
+          consentVersion: resumeInput2.consentVersion,
+          visibility: _nullishCoalesce(resumeInput2.visibility, () => ( "public")),
+          ...resumeInput2.metadata ? { metadata: resumeInput2.metadata } : {}
+        },
+        // Trạng thái lấy từ chính phản hồi refresh, KHÔNG đoán: gán cứng "live" là
+        // camera tự lên sóng khi chủ nó chỉ đang trực sân (18/08/2026).
+        { autoPublish: result.live }
+      ).catch(() => {
+        _optionalChain([onAttemptRef, 'access', _5 => _5.current, 'optionalCall', _6 => _6(resumeId, "start_failed")]);
+        if (!cancelled) scheduleRetry();
+      });
+    })();
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [enabled, provider, resumeId, sessionId, state, retryTick, engine, liveRef, onAttemptRef, resumeInputRef, retryDelayRef]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || state !== "error" || sessionId === null) return;
+    const timer = setTimeout(() => {
+      _optionalChain([onAttemptRef, 'access', _7 => _7.current, 'optionalCall', _8 => _8(sessionId, "publish_retry")]);
+      void liveRef.current.retry().catch(() => void 0);
+    }, retryDelayRef.current(attemptRef.current++));
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, liveRef, onAttemptRef, retryDelayRef]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || state !== "error" || sessionId !== null || !adoptableSessionId) return;
+    const timer = setTimeout(() => {
+      _optionalChain([onAttemptRef, 'access', _9 => _9.current, 'optionalCall', _10 => _10(adoptableSessionId, "reprepare")]);
+      void liveRef.current.prepare().catch(() => void 0);
+    }, 2e3);
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, adoptableSessionId, liveRef, onAttemptRef]);
+  _react.useEffect.call(void 0, () => {
+    if (state === "live" || state === "standby") attemptRef.current = 0;
+  }, [state]);
+  return null;
+}
+function PickleballAutoPrepare(props) {
+  const { enabled = true, captureOrientation } = props;
+  const live = _chunkIUIRVKJIcjs.useLivestream.call(void 0, );
+  const { state } = live;
+  const liveRef = useLatest(live);
+  const orientedRef = _react.useRef.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled || !captureOrientation || orientedRef.current) return;
+    orientedRef.current = true;
+    void liveRef.current.setCaptureOrientation(captureOrientation).catch(() => void 0);
+  }, [enabled, captureOrientation, liveRef]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) return;
+    if (state !== "idle" && state !== "ended") return;
+    void liveRef.current.prepare().catch(() => void 0);
+  }, [enabled, state, liveRef]);
+  return null;
+}
+function useStandbySession(options) {
+  const { input, enabled = true, resumeSessionId = null } = options;
+  const live = _chunkIUIRVKJIcjs.useLivestream.call(void 0, );
+  const { state, sessionId, adoptableSessionId } = live;
+  const liveRef = useLatest(live);
+  const armedForRef = _react.useRef.call(void 0, null);
+  const inputRef = useLatest(input);
+  const externalSessionId = input.externalSessionId;
+  const armed = sessionId !== null && armedForRef.current === externalSessionId;
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) return;
+    if (state !== "preview" || sessionId !== null) return;
+    if (armedForRef.current === externalSessionId) return;
+    if (resumeBlocksArm({
+      adoptableSessionId,
+      serverSessionId: resumeSessionId,
+      engineSessionId: sessionId
+    })) {
+      return;
+    }
+    armedForRef.current = externalSessionId;
+    void liveRef.current.start(inputRef.current, { autoPublish: false }).catch(() => {
+      armedForRef.current = null;
+    });
+  }, [enabled, state, sessionId, adoptableSessionId, resumeSessionId, externalSessionId, liveRef, inputRef]);
+  return { armed };
+}
+
+// src/camera-settings.ts
+
+var CAMERA_SETTINGS_STORAGE_KEY = "@pickleball/expo-sdk/camera-settings";
+var DEFAULT_CAMERA_SETTINGS = Object.freeze({
+  resolution: 720,
+  fps: 30,
+  antiFlicker: "50hz",
+  cameraId: null
+});
+function parseCameraSettings(raw, defaults = DEFAULT_CAMERA_SETTINGS) {
+  if (!raw) return { ...defaults };
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") return { ...defaults };
+    return {
+      resolution: parsed.resolution === 1080 ? 1080 : parsed.resolution === 720 ? 720 : defaults.resolution,
+      fps: parsed.fps === 24 || parsed.fps === 30 || parsed.fps === 60 ? parsed.fps : defaults.fps,
+      antiFlicker: parsed.antiFlicker === "auto" || parsed.antiFlicker === "60hz" || parsed.antiFlicker === "50hz" ? parsed.antiFlicker : defaults.antiFlicker,
+      cameraId: typeof parsed.cameraId === "string" ? parsed.cameraId : null
+    };
+  } catch (e) {
+    return { ...defaults };
+  }
+}
+function createCameraSettingsStore(options = {}) {
+  const storage = _nullishCoalesce(options.storage, () => ( _chunkIUIRVKJIcjs.createDefaultStorage.call(void 0, )));
+  const key = _nullishCoalesce(options.key, () => ( CAMERA_SETTINGS_STORAGE_KEY));
+  const defaults = { ...DEFAULT_CAMERA_SETTINGS, ...options.defaults };
+  let settings = { ...defaults };
+  let restored = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    key,
+    get: () => settings,
+    set(patch) {
+      settings = { ...settings, ...patch };
+      void storage.setItem(key, JSON.stringify(settings)).catch(() => void 0);
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async restore() {
+      const raw = await storage.getItem(key).catch(() => null);
+      settings = parseCameraSettings(raw, defaults);
+      restored = true;
+      emit();
+    },
+    isRestored: () => restored
+  };
+}
+function useCameraSettings(store) {
+  return _react.useSyncExternalStore.call(void 0, store.subscribe, store.get, store.get);
+}
+function cameraSettingsKey(settings) {
+  return `${settings.resolution}:${settings.fps}:${_nullishCoalesce(settings.cameraId, () => ( "default"))}`;
+}
+function rtmpRoomFactoryFor(settings) {
+  return _chunkIUIRVKJIcjs.createRtmpRoomFactory.call(void 0, {
+    frameRate: settings.fps,
+    ...settings.cameraId ? { cameraId: settings.cameraId } : {}
+  });
+}
+
+// src/camera-controls.ts
+function nativeModule() {
+  try {
+    const loaded = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/rtmp-native");
+    const candidate = _nullishCoalesce(_optionalChain([loaded, 'optionalAccess', _11 => _11.default]), () => ( loaded));
+    return candidate && typeof candidate === "object" ? candidate : null;
+  } catch (e2) {
+    return null;
+  }
+}
+async function callOptional(name, invoke, fallback) {
+  const native = nativeModule();
+  if (!native || typeof native[name] !== "function") return fallback;
+  try {
+    const result = await invoke(native);
+    return result === void 0 ? fallback : result;
+  } catch (e3) {
+    return fallback;
+  }
+}
+function getCameraCapabilities() {
+  return callOptional("getCameraCapabilities", (n) => _optionalChain([n, 'access', _12 => _12.getCameraCapabilities, 'optionalCall', _13 => _13()]), null);
+}
+function setZoom(factor) {
+  return callOptional("setZoom", (n) => _optionalChain([n, 'access', _14 => _14.setZoom, 'optionalCall', _15 => _15(factor)]), void 0);
+}
+function setExposureBias(ev) {
+  return callOptional("setExposureBias", (n) => _optionalChain([n, 'access', _16 => _16.setExposureBias, 'optionalCall', _17 => _17(ev)]), void 0);
+}
+function setFocusLocked(locked) {
+  return callOptional("setFocusLocked", (n) => _optionalChain([n, 'access', _18 => _18.setFocusLocked, 'optionalCall', _19 => _19(locked)]), void 0);
+}
+function setExposureLocked(locked) {
+  return callOptional("setExposureLocked", (n) => _optionalChain([n, 'access', _20 => _20.setExposureLocked, 'optionalCall', _21 => _21(locked)]), void 0);
+}
+function setTorch(enabled) {
+  return callOptional("setTorch", (n) => _optionalChain([n, 'access', _22 => _22.setTorch, 'optionalCall', _23 => _23(enabled)]), void 0);
+}
+function applyAntiFlicker(mode) {
+  return callOptional("setAntiFlicker", (n) => _optionalChain([n, 'access', _24 => _24.setAntiFlicker, 'optionalCall', _25 => _25(mode)]), void 0);
+}
+function requestNativePermissions() {
+  return callOptional("requestPermissions", (n) => _optionalChain([n, 'access', _26 => _26.requestPermissions, 'optionalCall', _27 => _27()]), null);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.classifyResumeStatus = classifyResumeStatus; exports.RESUME_RETRY_DELAYS_MS = RESUME_RETRY_DELAYS_MS; exports.resumeRetryDelayMs = resumeRetryDelayMs; exports.resumeBlocksArm = resumeBlocksArm; exports.resumeExternalSessionId = resumeExternalSessionId; exports.resumeGrantMatches = resumeGrantMatches; exports.PickleballAutoResume = PickleballAutoResume; exports.PickleballAutoPrepare = PickleballAutoPrepare; exports.useStandbySession = useStandbySession; exports.CAMERA_SETTINGS_STORAGE_KEY = CAMERA_SETTINGS_STORAGE_KEY; exports.DEFAULT_CAMERA_SETTINGS = DEFAULT_CAMERA_SETTINGS; exports.parseCameraSettings = parseCameraSettings; exports.createCameraSettingsStore = createCameraSettingsStore; exports.useCameraSettings = useCameraSettings; exports.cameraSettingsKey = cameraSettingsKey; exports.rtmpRoomFactoryFor = rtmpRoomFactoryFor; exports.getCameraCapabilities = getCameraCapabilities; exports.setZoom = setZoom; exports.setExposureBias = setExposureBias; exports.setFocusLocked = setFocusLocked; exports.setExposureLocked = setExposureLocked; exports.setTorch = setTorch; exports.applyAntiFlicker = applyAntiFlicker; exports.requestNativePermissions = requestNativePermissions;