@pexip/media-control 17.2.0 → 17.4.0

package/dist/index.mjs

@@ -1,1699 +0,0 @@
-// src/types.ts
-var MediaDeviceKinds = /* @__PURE__ */ ((MediaDeviceKinds2) => {
-  MediaDeviceKinds2["AUDIOINPUT"] = "audioinput";
-  MediaDeviceKinds2["AUDIOOUTPUT"] = "audiooutput";
-  MediaDeviceKinds2["VIDEOINPUT"] = "videoinput";
-  return MediaDeviceKinds2;
-})(MediaDeviceKinds || {});
-var FACING_MODE = ["user", "environment", "left", "right"];
-var MediaDeviceFailure = /* @__PURE__ */ ((MediaDeviceFailure2) => {
-  MediaDeviceFailure2["AbortError"] = "AbortError";
-  MediaDeviceFailure2["AudioAndVideoDeviceNotFoundError"] = "AudioAndVideoDeviceNotFoundError";
-  MediaDeviceFailure2["AudioInputDeviceNotFoundError"] = "AudioInputDeviceNotFoundError";
-  MediaDeviceFailure2["MissingConstraintsError"] = "MissingConstraintsError";
-  MediaDeviceFailure2["NotAllowedError"] = "NotAllowedError";
-  MediaDeviceFailure2["NotFoundError"] = "NotFoundError";
-  MediaDeviceFailure2["NotReadableError"] = "NotReadableError";
-  MediaDeviceFailure2["OverconstrainedError"] = "OverconstrainedError";
-  MediaDeviceFailure2["PermissionDeniedError"] = "PermissionDeniedError";
-  MediaDeviceFailure2["SecurityError"] = "SecurityError";
-  MediaDeviceFailure2["TrackStartError"] = "TrackStartError";
-  MediaDeviceFailure2["TypeError"] = "TypeError";
-  MediaDeviceFailure2["VideoInputDeviceNotFoundError"] = "VideoInputDeviceNotFoundError";
-  MediaDeviceFailure2["NotSupportedError"] = "NotSupportedError";
-  MediaDeviceFailure2["StreamTrackNotFound"] = "StreamTrackNotFound";
-  return MediaDeviceFailure2;
-})(MediaDeviceFailure || {});
-
-// src/typeGuards.ts
-import { hasOwnProperty } from "@pexip/utils";
-var isBoolean = (t) => typeof t === "boolean";
-var isUndefined = (t) => typeof t === "undefined";
-var isNumber = (t) => typeof t === "number" && !Number.isNaN(t);
-var isInteger = (t) => Number.isInteger(t);
-var isFloat = (t) => isNumber(t) && !Number.isInteger(t) && Number.isFinite(t);
-var CONSTRAIN_STRING_KEYS = [
-  "facingMode",
-  "resizeMode",
-  "deviceId",
-  "groupId"
-];
-var EXTENDED_CONSTRAIN_STRING_KEYS = [
-  "videoSegmentation",
-  "videoSegmentationModel",
-  "bgImageUrl",
-  "contentHint"
-];
-var CONSTRAIN_U_LONG_KEYS = [
-  "width",
-  "height",
-  "sampleRate",
-  "sampleSize",
-  "channelCount"
-];
-var EXTENDED_CONSTRAIN_U_LONG_KEYS = [
-  "backgroundBlurAmount",
-  "edgeBlurAmount"
-];
-var CONSTRAIN_DOUBLE_KEYS = [
-  "aspectRatio",
-  "frameRate",
-  "latency"
-];
-var EXTENDED_CONSTRAIN_DOUBLE_KEYS = ["foregroundThreshold"];
-var CONSTRAIN_BOOLEAN_KEYS = [
-  "echoCancellation",
-  "autoGainControl",
-  "noiseSuppression",
-  "pan",
-  "tilt",
-  "zoom"
-];
-var EXTENDED_CONSTRAIN_BOOLEAN_KEYS = [
-  // Voice Activity Detection
-  "vad",
-  // Audio Signal Detection
-  "asd",
-  // Mixing with another track
-  "mixWithAdditionalMedia",
-  // Noise Suppression using our own impl
-  "denoise",
-  // Flip the video horizontally
-  "flipHorizontal"
-];
-var CONSTRAINT_SET_KEYS = [
-  ...CONSTRAIN_DOUBLE_KEYS,
-  ...CONSTRAIN_U_LONG_KEYS,
-  ...CONSTRAIN_STRING_KEYS,
-  ...CONSTRAIN_BOOLEAN_KEYS
-];
-var isConstrainStringKeys = (t) => CONSTRAIN_STRING_KEYS.includes(t);
-var isExtendedConstrainStringKeys = (t) => EXTENDED_CONSTRAIN_STRING_KEYS.includes(t);
-var isConstrainULongKeys = (t) => CONSTRAIN_U_LONG_KEYS.includes(t);
-var isExtendedConstrainULongKeys = (t) => EXTENDED_CONSTRAIN_U_LONG_KEYS.includes(t);
-var isConstrainDoubleKeys = (t) => CONSTRAIN_DOUBLE_KEYS.includes(t);
-var isExtendedConstrainDoubleKeys = (t) => EXTENDED_CONSTRAIN_DOUBLE_KEYS.includes(t);
-var isConstrainBooleanKeys = (t) => CONSTRAIN_BOOLEAN_KEYS.includes(t);
-var isExtendedConstrainBooleanKeys = (t) => EXTENDED_CONSTRAIN_BOOLEAN_KEYS.includes(t);
-var isMediaTrackConstraintSetKey = (t) => CONSTRAINT_SET_KEYS.includes(t);
-var isMediaTrackConstraintsKey = (t) => isMediaTrackConstraintSetKey(t) || t === "advanced";
-var isMediaTrackConstraints = (t) => {
-  if (!t || typeof t !== "object" || Array.isArray(t) || t === null) {
-    return false;
-  }
-  const keys = Object.keys(t);
-  return !!keys.length && Object.keys(t).every((key) => isMediaTrackConstraintsKey(key));
-};
-var isMediaDeviceInfo = (t) => {
-  if (!t || typeof t !== "object") {
-    return false;
-  }
-  return !!t && "deviceId" in t && "kind" in t;
-};
-var isMediaDeviceInfoArray = (t) => {
-  if (Array.isArray(t) && t.length && t.some(isMediaDeviceInfo)) {
-    return true;
-  }
-  return false;
-};
-var isDeviceConstraint = (t) => {
-  return isMediaDeviceInfo(t) || isMediaDeviceInfoArray(t);
-};
-var isConstraintDOMString = (t) => typeof t === "string" && !!t || Array.isArray(t) && t.some(Boolean);
-var CONSTRAIN_PARAM_KEYS = ["exact", "ideal"];
-var CONSTRAIN_RANGE_KEYS = ["min", "max"];
-var CONSTRAIN_KEYS = [
-  ...CONSTRAIN_PARAM_KEYS,
-  ...CONSTRAIN_RANGE_KEYS
-];
-var isConstrainDOMParameters = (isType, keys = CONSTRAIN_PARAM_KEYS) => (t) => {
-  if (!t || typeof t !== "object" || t === null || Object.keys(t).length <= 0) {
-    return false;
-  }
-  return keys.some((key) => hasOwnProperty(t, key) && isType(t[key]));
-};
-var isConstrainDOMStringParameters = isConstrainDOMParameters(
-  isConstraintDOMString
-);
-var isConstrainBooleanParameters = isConstrainDOMParameters(isBoolean);
-var isConstrainRange = isConstrainDOMParameters(
-  (t) => isFloat(t) || isInteger(t),
-  CONSTRAIN_RANGE_KEYS
-);
-var isConstrainDoubleRange = isConstrainDOMParameters(isFloat, CONSTRAIN_KEYS);
-var isConstrainULongRange = isConstrainDOMParameters(isInteger, CONSTRAIN_KEYS);
-var isConstraintDeviceParameters = isConstrainDOMParameters(
-  (t) => isMediaDeviceInfo(t) || isMediaDeviceInfoArray(t)
-);
-var isConstraintSetDevice = (t) => isMediaDeviceInfo(t) || isMediaDeviceInfoArray(t) || isConstraintDeviceParameters(t);
-var isExtendedConstraint = (t) => {
-  if (typeof t !== "object" || t === null) {
-    return false;
-  }
-  if (hasOwnProperty(t, "device")) {
-    const { device } = t;
-    return isConstraintSetDevice(device);
-  }
-  return [
-    ...EXTENDED_CONSTRAIN_DOUBLE_KEYS,
-    ...EXTENDED_CONSTRAIN_STRING_KEYS,
-    ...EXTENDED_CONSTRAIN_U_LONG_KEYS,
-    ...EXTENDED_CONSTRAIN_BOOLEAN_KEYS
-  ].some((key) => hasOwnProperty(t, key));
-};
-var isInputConstraintSet = (t) => {
-  if (typeof t !== "object" || t === null) {
-    return false;
-  }
-  return isExtendedConstraint(t) || isMediaTrackConstraints(t);
-};
-var isMediaStreamTrack = (m) => {
-  if (m && typeof m === "object") {
-    return !!m && "getSettings" in m;
-  }
-  return false;
-};
-var isFacingMode = (s) => {
-  if (typeof s === "string" && FACING_MODE.includes(s)) {
-    return true;
-  }
-  return false;
-};
-
-// ../../shared/baseLogger.ts
-var LogLevels = ((LogLevels2) => {
-  LogLevels2[LogLevels2["trace"] = 10] = "trace";
-  LogLevels2[LogLevels2["debug"] = 20] = "debug";
-  LogLevels2[LogLevels2["info"] = 30] = "info";
-  LogLevels2[LogLevels2["warn"] = 40] = "warn";
-  LogLevels2[LogLevels2["error"] = 50] = "error";
-  LogLevels2[LogLevels2["fatal"] = 60] = "fatal";
-  LogLevels2[LogLevels2["silent"] = Number.MAX_SAFE_INTEGER] = "silent";
-  return LogLevels2;
-})(LogLevels || {});
-function createConsoleLogger() {
-  return Object.freeze({
-    /* eslint-disable no-console -- set logger to console */
-    fatal: (meta, message) => console.error(message, meta),
-    error: (meta, message) => console.error(message, meta),
-    warn: (meta, message) => console.warn(message, meta),
-    info: (meta, message) => console.info(message, meta),
-    debug: (meta, message) => console.debug(message, meta),
-    trace() {
-    },
-    // Noop
-    silent() {
-    },
-    // Noop
-    redact() {
-    }
-    // Noop
-    /* eslint-enable no-console -- set logger to console */
-  });
-}
-
-// src/logger.ts
-var logger = createConsoleLogger();
-function setLogger(newLogger) {
-  logger = newLogger;
-}
-
-// src/utils.ts
-var isSameDeviceKind = (kind) => (device) => device.kind === kind;
-var isAudioInput = isSameDeviceKind("audioinput" /* AUDIOINPUT */);
-var isVideoInput = isSameDeviceKind("videoinput" /* VIDEOINPUT */);
-var isAudioOutput = isSameDeviceKind("audiooutput" /* AUDIOOUTPUT */);
-var isDeviceGranted = (device) => Boolean(device.label);
-var not = (fn) => (arg) => !fn(arg);
-var compareDevices = (deviceInfo, key = "deviceId") => (anotherDeviceInfo) => deviceInfo.kind === anotherDeviceInfo.kind && deviceInfo[key] === anotherDeviceInfo[key];
-var findDevice = (deviceToFind, useFallback = true) => (devices) => {
-  const compareIDTo = compareDevices(deviceToFind);
-  const found = devices.find(
-    (device) => compareIDTo(device)
-  );
-  if (found || !useFallback) {
-    return found;
-  }
-  const compareLabelTo = compareDevices(deviceToFind, "label");
-  return devices.find(
-    (device) => compareLabelTo(device)
-  );
-};
-
-// src/constraints.ts
-var isExactDeviceConstraint = (constraint) => {
-  if (isInputConstraintSet(constraint)) {
-    return !!constraint.device && typeof constraint.device === "object" && "exact" in constraint.device || !!constraint.deviceId && typeof constraint.deviceId === "object" && "exact" in constraint.deviceId;
-  }
-  return false;
-};
-var getConstraintsSetFilter = (supportedConstraints) => (trackConstraints) => {
-  if (!isMediaTrackConstraints(trackConstraints)) {
-    return trackConstraints;
-  }
-  const constraints = Object.entries(trackConstraints).reduce(
-    (acc, [key, val]) => key === "advanced" || supportedConstraints.has(
-      key
-    ) ? { ...acc, [key]: val } : acc,
-    {}
-  );
-  if (Object.keys(constraints).length === 0) {
-    return true;
-  }
-  return constraints;
-};
-var getDefinedOnly = (obj) => {
-  return Object.entries(obj).reduce(
-    (acc, [key, val]) => typeof val === "undefined" ? acc : { ...acc, [key]: val },
-    {}
-  );
-};
-var removeUnsupportedConstraints = (constraints) => {
-  if (!(navigator && "getSupportedConstraints" in navigator.mediaDevices)) {
-    return constraints;
-  }
-  const supportedConstraints = Object.entries(
-    navigator.mediaDevices.getSupportedConstraints()
-  );
-  logger.debug({ supportedConstraints }, "Supported constraints");
-  const constraintsSetFilter = getConstraintsSetFilter(
-    supportedConstraints.reduce(
-      (set, [key, value]) => (
-        // FIXME: Cast inserted to unblock typescript upgrade, will have to be verified and properly fixed.
-        value && isMediaTrackConstraintSetKey(key) ? set.add(
-          key
-        ) : set
-      ),
-      /* @__PURE__ */ new Set()
-    )
-  );
-  return getDefinedOnly({
-    audio: constraintsSetFilter(constraints.audio),
-    peerIdentity: constraints.peerIdentity,
-    video: constraintsSetFilter(constraints.video)
-  });
-};
-var mergeConstraints = (baseConstraints) => (constraints) => {
-  if (!isInputConstraintSet(baseConstraints)) {
-    if (isDeviceConstraint(constraints)) {
-      return { device: constraints };
-    }
-    return constraints ?? false;
-  }
-  if (!constraints) {
-    return false;
-  }
-  if (isDeviceConstraint(constraints)) {
-    const result = {
-      ...baseConstraints,
-      device: constraints
-    };
-    delete result.facingMode;
-    delete result.deviceId;
-    return result;
-  }
-  if (isInputConstraintSet(constraints)) {
-    const combined = { ...baseConstraints, ...constraints };
-    const hasDeviceId = isConstraintDOMString(combined.deviceId) || isConstrainDOMStringParameters(combined.deviceId);
-    const hasDevice = isDeviceConstraint(combined.device) || isConstraintDeviceParameters(combined.device);
-    if (hasDeviceId && hasDevice) {
-      const result = {
-        ...combined
-      };
-      delete result.facingMode;
-      delete result.deviceId;
-      return result;
-    }
-    if (hasDevice || hasDeviceId) {
-      delete combined.facingMode;
-      return combined;
-    }
-    return combined;
-  }
-  return baseConstraints;
-};
-var normalizeDevice = (device) => {
-  if (!device) {
-    return void 0;
-  }
-  if (isMediaDeviceInfo(device)) {
-    return [device];
-  }
-  if (Array.isArray(device)) {
-    const devices = device.filter(isMediaDeviceInfo);
-    if (devices.length) {
-      return devices;
-    }
-  }
-  return void 0;
-};
-var normalizeDeviceConstraint = (constraints) => {
-  if (!constraints) {
-    return void 0;
-  }
-  if (isConstraintDeviceParameters(constraints)) {
-    return Object.keys(constraints).filter((k) => ["ideal", "exact"].includes(k)).reduce(
-      (cs, k) => {
-        const key = k;
-        const value = constraints[key];
-        const devices = normalizeDevice(value);
-        if (devices) {
-          return { ...cs ?? {}, [key]: devices };
-        }
-        return cs;
-      },
-      void 0
-    );
-  }
-  const normalized = normalizeDevice(constraints);
-  return normalized && { ideal: normalized };
-};
-var toDeviceIdConstraintSet = (constraint) => {
-  const [devices, param] = extractConstrainDevice({ device: constraint });
-  return devices && { [param]: devices.map((device) => device.deviceId) };
-};
-var toArray = (t) => {
-  const r = Array.isArray(t) ? t : [t];
-  return r.filter(Boolean);
-};
-var NONE = [void 0, "ideal"];
-var extractConstrainString = (key) => (constraints) => {
-  const constraint = constraints[key];
-  if (!constraint) {
-    return NONE;
-  }
-  if (isConstraintDOMString(constraint)) {
-    return [toArray(constraint), "ideal"];
-  }
-  if (isConstrainDOMStringParameters(constraint)) {
-    if (constraint.exact) {
-      const normalized = toArray(constraint.exact);
-      if (normalized.length) {
-        return [normalized, "exact"];
-      }
-    }
-    if (constraint.ideal) {
-      return [toArray(constraint.ideal), "ideal"];
-    }
-  }
-  return NONE;
-};
-var extractConstrainBoolean = (key) => (constraints) => {
-  const constraint = constraints[key];
-  if (isUndefined(constraint)) {
-    return NONE;
-  }
-  if (isBoolean(constraint)) {
-    return [constraint, "ideal"];
-  }
-  if (isConstrainBooleanParameters(constraint)) {
-    const { ideal, exact } = constraint;
-    if (isBoolean(exact)) {
-      return [exact, "exact"];
-    }
-    if (isBoolean(ideal)) {
-      return [ideal, "ideal"];
-    }
-  }
-  return NONE;
-};
-var extractConstrainNumber = (key) => (constraints) => {
-  const constraint = constraints[key];
-  if (constraint === void 0 || constraint === null) {
-    return NONE;
-  }
-  if (isFloat(constraint) || isInteger(constraint)) {
-    return [constraint, "ideal"];
-  }
-  if (isConstrainULongRange(constraint) || isConstrainDoubleRange(constraint)) {
-    const { exact, ideal, min, max } = constraint;
-    if (isFloat(min) || isFloat(max) || isInteger(min) || isInteger(max)) {
-      return [{ min, max, ideal, exact }, "min-max"];
-    }
-    if (isFloat(exact) || isInteger(exact)) {
-      return [exact, "exact"];
-    }
-    if (isFloat(ideal) || isInteger(ideal)) {
-      return [ideal, "ideal"];
-    }
-  }
-  return NONE;
-};
-var extractConstrainDevice = (constraints) => {
-  if (!constraints || isBoolean(constraints) || Array.isArray(constraints) && !constraints.length) {
-    return NONE;
-  }
-  const { device } = isInputConstraintSet(constraints) ? constraints : { device: constraints };
-  if (isMediaDeviceInfo(device) || isMediaDeviceInfoArray(device)) {
-    const normalized = normalizeDevice(device);
-    if (normalized) {
-      return [normalized, "ideal"];
-    }
-  }
-  if (isConstraintDeviceParameters(device)) {
-    const { exact, ideal } = normalizeDeviceConstraint(device) ?? {};
-    if (exact) {
-      return [exact, "exact"];
-    }
-    if (ideal) {
-      return [ideal, "ideal"];
-    }
-  }
-  return NONE;
-};
-var closedTo = (a, b, numDigits = 5) => {
-  const multiplier = Math.pow(10, numDigits);
-  return Math.round(a * multiplier) === Math.round(b * multiplier);
-};
-var between = (min, num, max) => {
-  if (!isUndefined(min)) {
-    if (!isUndefined(max)) {
-      return num >= min && num <= max;
-    }
-    return num >= min;
-  }
-  if (!isUndefined(max)) {
-    return num <= max;
-  }
-  return true;
-};
-var getValueFromConstrainNumber = (constraint) => {
-  if (isNumber(constraint)) {
-    return constraint;
-  }
-  const { min, max, ideal, exact } = constraint;
-  if (exact !== void 0) {
-    const withinRange = between(min, exact, max);
-    if (withinRange) {
-      return exact;
-    }
-  }
-  if (ideal !== void 0) {
-    const withinRange = between(min, ideal, max);
-    if (withinRange) {
-      return ideal;
-    }
-  }
-  const value = max ?? min;
-  if (value !== void 0) {
-    return value;
-  }
-  throw Error("Constrain Number is undefined");
-};
-var getFacingModeFromConstraintString = (constraint) => {
-  if (isFacingMode(constraint)) {
-    return constraint;
-  }
-  return void 0;
-};
-var satisfyConstrainNumber = (constraint, num) => {
-  if (isUndefined(constraint) || isUndefined(num)) {
-    return true;
-  }
-  if (isInteger(constraint)) {
-    return num === constraint;
-  }
-  if (isFloat(constraint)) {
-    return closedTo(constraint, num);
-  }
-  if (isConstrainRange(constraint)) {
-    const { min, max, ideal, exact } = constraint;
-    const withinRange = between(min, num, max);
-    if (isFloat(exact)) {
-      return withinRange && closedTo(exact, num);
-    }
-    if (isInteger(exact)) {
-      return withinRange && exact === num;
-    }
-    if (isFloat(ideal)) {
-      return withinRange && closedTo(ideal, num);
-    }
-    if (isInteger(ideal)) {
-      return withinRange && ideal === num;
-    }
-    return withinRange;
-  }
-  return false;
-};
-var resolveMediaDeviceConstraints = (constraints, base) => {
-  const merge = mergeConstraints(base);
-  if (isInputConstraintSet(constraints)) {
-    if (isConstraintSetDevice(constraints.device)) {
-      return merge(
-        Object.keys(constraints).reduce((cs, k) => {
-          const key = k;
-          if (key === "device") {
-            return {
-              ...cs,
-              deviceId: toDeviceIdConstraintSet(
-                constraints.device
-              )
-            };
-          }
-          return { ...cs, [key]: constraints[key] };
-        }, {})
-      );
-    }
-    return merge(constraints);
-  }
-  if (isConstraintSetDevice(constraints)) {
-    const deviceId = toDeviceIdConstraintSet(constraints);
-    return merge({ deviceId });
-  }
-  if (constraints && isMediaTrackConstraints(base)) {
-    return base;
-  }
-  return !!constraints;
-};
-var getMediaConstraints = ({
-  audio,
-  video,
-  defaultConstraints
-}) => {
-  return removeUnsupportedConstraints({
-    audio: resolveMediaDeviceConstraints(audio, defaultConstraints.audio),
-    video: resolveMediaDeviceConstraints(video, defaultConstraints.video)
-  });
-};
-var applyConstraints = async (tracks, constraints) => {
-  if (!tracks || tracks.length === 0 || Object.keys(constraints).length === 0) {
-    return Promise.resolve();
-  }
-  const { audio, video } = removeUnsupportedConstraints({
-    audio: resolveMediaDeviceConstraints(constraints.audio),
-    video: resolveMediaDeviceConstraints(constraints.video)
-  });
-  await Promise.all(
-    tracks.flatMap((track) => {
-      if (track.kind === "audio" && isMediaTrackConstraints(audio)) {
-        return [track.applyConstraints(audio)];
-      }
-      if (track.kind === "video" && isMediaTrackConstraints(video)) {
-        return [track.applyConstraints(video)];
-      }
-      return [];
-    })
-  );
-};
-var findDeviceFrom = (devicesToFind, deviceList) => {
-  const devicesFound = devicesToFind.flatMap((device) => {
-    const found = findDevice(device)(deviceList);
-    if (found) {
-      return [found];
-    }
-    return [];
-  });
-  if (devicesFound.length) {
-    return devicesFound;
-  }
-  return void 0;
-};
-var findDeviceFromDeviceConstraints = (device, devices) => {
-  const normalized = normalizeDeviceConstraint(device);
-  if (normalized) {
-    const { ideal, exact } = normalized;
-    if (exact) {
-      return findDeviceFrom(exact, devices);
-    }
-    if (ideal) {
-      return findDeviceFrom(ideal, devices);
-    }
-  }
-};
-var relaxDevice = (device, devices) => {
-  const found = findDeviceFromDeviceConstraints(device, devices);
-  if (found) {
-    return found;
-  }
-  return normalizeDevice(device);
-};
-var resolveOnlyDevice = (devices) => {
-  switch (devices.length) {
-    case 1:
-      return devices[0];
-    case 0:
-      return void 0;
-    default:
-      return true;
-  }
-};
-function extractConstraints(key) {
-  return (constraints) => {
-    if (!constraints || typeof constraints === "boolean" || Array.isArray(constraints) && !constraints.length) {
-      return NONE;
-    }
-    if (key === "device" && (isMediaDeviceInfo(constraints) || isMediaDeviceInfoArray(constraints))) {
-      return extractConstrainDevice(constraints);
-    }
-    if (isInputConstraintSet(constraints)) {
-      if (key === "device") {
-        return extractConstrainDevice(constraints);
-      }
-      if (isConstrainStringKeys(key) || isExtendedConstrainStringKeys(key)) {
-        return extractConstrainString(key)(constraints);
-      }
-      if (isConstrainDoubleKeys(key) || isConstrainULongKeys(key) || isExtendedConstrainULongKeys(key) || isExtendedConstrainDoubleKeys(key)) {
-        return extractConstrainNumber(key)(constraints);
-      }
-      if (isConstrainBooleanKeys(key) || isExtendedConstrainBooleanKeys(key)) {
-        return extractConstrainBoolean(key)(constraints);
-      }
-    }
-    return [void 0, "ideal"];
-  };
-}
-var extractConstraintsWithKeys = (keys) => (constraints) => keys.reduce(
-  (result, key) => {
-    if (key === "device") {
-      return {
-        ...result,
-        [key]: extractConstraints(key)(constraints)
-      };
-    }
-    if (isConstrainULongKeys(key) || isConstrainDoubleKeys(key) || isExtendedConstrainULongKeys(key) || isExtendedConstrainDoubleKeys(key)) {
-      return {
-        ...result,
-        [key]: extractConstraints(key)(constraints)
-      };
-    }
-    if (isConstrainStringKeys(key) || isExtendedConstrainStringKeys(key)) {
-      return {
-        ...result,
-        [key]: extractConstraints(key)(constraints)
-      };
-    }
-    if (isConstrainBooleanKeys(key) || isExtendedConstrainBooleanKeys(key)) {
-      return {
-        ...result,
-        [key]: extractConstraints(key)(constraints)
-      };
-    }
-    return result;
-  },
-  {}
-);
-var extractDeviceId = extractConstrainString("deviceId");
-var findDeviceFromConstraints = (constraints, devices) => {
-  if (typeof constraints === "boolean") {
-    return constraints ? resolveOnlyDevice(devices) : constraints;
-  }
-  if (constraints === void 0 || !devices.length || devices.some((device) => !device.label) || Array.isArray(constraints) && !constraints.length) {
-    return void 0;
-  }
-  const [constrainDevices, deviceParam] = extractConstraints("device")(constraints);
-  if (constrainDevices) {
-    const [device] = findDeviceFrom(constrainDevices, devices) ?? [];
-    if (device) {
-      return device;
-    }
-    if (deviceParam === "exact") {
-      return void 0;
-    }
-  }
-  const [ConstrainDeviceIds, deviceIdParam] = extractConstraints("deviceId")(constraints);
-  if (ConstrainDeviceIds) {
-    const deviceFound = devices.find((device) => {
-      const id = ConstrainDeviceIds.find(
-        (id2) => id2 && device.label && device.deviceId === id2
-      );
-      return !!id;
-    });
-    if (deviceFound) {
-      return deviceFound;
-    }
-    if (deviceIdParam === "exact") {
-      return void 0;
-    }
-  }
-  return resolveOnlyDevice(devices);
-};
-var relaxInputConstraint = (input, devices) => {
-  if (devices.length === 0 || !input || typeof input === "boolean") {
-    return input;
-  }
-  const [device, param] = extractConstrainDevice(input);
-  const relaxedDevice = relaxDevice(device, devices);
-  const otherConstraints = isInputConstraintSet(input) ? input : {};
-  return relaxedDevice ? { ...otherConstraints, device: { [param]: relaxedDevice } } : input;
-};
-var getConstraintsHandlers = () => {
-  let defaultConstraints = {
-    audio: {
-      echoCancellation: { ideal: true },
-      noiseSuppression: { ideal: true }
-    },
-    video: {
-      frameRate: { ideal: 30 }
-    }
-  };
-  const setDefaultConstraints2 = (newConstraints) => {
-    defaultConstraints = { ...defaultConstraints, ...newConstraints };
-  };
-  const getDefaultConstraints = () => {
-    return defaultConstraints;
-  };
-  return {
-    getDefaultConstraints,
-    setDefaultConstraints: setDefaultConstraints2
-  };
-};
-
-// src/devices.ts
-var SEPARATOR = ":";
-var toKey = ({ id, kind, label }) => [kind, id, label].join(SEPARATOR);
-var getDevices = async () => {
-  if ("mediaDevices" in navigator && "enumerateDevices" in navigator.mediaDevices) {
-    const devices = await navigator.mediaDevices.enumerateDevices();
-    return devices;
-  }
-  return [];
-};
-var toDeviceKey = (device) => toKey({ id: device.deviceId, kind: device.kind, label: device.label });
-var toDeviceTuple = (device) => [toDeviceKey(device), device];
-var toDevicesMap = (devices) => {
-  return new Map(devices.map(toDeviceTuple));
-};
-var toUniqueDevices = (devices) => {
-  const map = toDevicesMap(devices);
-  return Array.from(map.values());
-};
-var createTrackDevicesChanges = (prevDevices = []) => {
-  let seen = toDevicesMap(prevDevices);
-  return (devices) => {
-    const found = [];
-    const lost = [];
-    const uniqueDevices = toUniqueDevices(devices);
-    const { authorized, unauthorized } = uniqueDevices.reduce(
-      (ds, d) => {
-        if (d.label) {
-          ds.authorized.push(d);
-        } else {
-          ds.unauthorized.push(d);
-        }
-        return ds;
-      },
-      { authorized: [], unauthorized: [] }
-    );
-    for (const device of authorized) {
-      if (!seen.delete(toDeviceKey(device))) {
-        found.push(device);
-      }
-    }
-    for (const device of seen.values()) {
-      lost.push(device);
-    }
-    seen = new Map(authorized.map(toDeviceTuple));
-    return { unauthorized, authorized, found, lost, devices: uniqueDevices };
-  };
-};
-var deviceChanged = (fn) => {
-  const trackChanges = createTrackDevicesChanges();
-  const odc = async () => {
-    const devices = await getDevices();
-    const changes = trackChanges(devices);
-    fn(changes);
-  };
-  if (navigator.mediaDevices && "ondevicechange" in navigator.mediaDevices) {
-    navigator.mediaDevices.ondevicechange = odc;
-    return () => {
-      navigator.mediaDevices.ondevicechange = null;
-    };
-  }
-  const it = window.setInterval(() => void odc(), 5e3);
-  return () => {
-    window.clearInterval(it);
-  };
-};
-var extractDeviceInfo = (track) => {
-  const { deviceId, groupId, ...settings } = track.getSettings();
-  const kind = track.kind === "audio" ? "audioinput" /* AUDIOINPUT */ : "videoinput" /* VIDEOINPUT */;
-  return {
-    kind,
-    deviceId: deviceId ?? "",
-    groupId: groupId ?? "",
-    label: track.label,
-    settings
-  };
-};
-var toMediaDeviceInfoLike = (track) => {
-  const { deviceId, label, kind, groupId } = extractDeviceInfo(track);
-  if (!deviceId) {
-    return;
-  }
-  return { deviceId, label, kind, groupId };
-};
-var compareMediaDeviceToMediaTrack = (track) => (device) => {
-  const { deviceId } = track.getSettings();
-  const sameLabel = device.label === track.label;
-  const sameKind = device.kind.startsWith(track.kind);
-  if (deviceId) {
-    return sameKind && deviceId === device.deviceId;
-  }
-  return sameKind && sameLabel;
-};
-var toMediaDeviceInfoLikeJSON = (info) => ({
-  deviceId: info.deviceId,
-  groupId: info.groupId,
-  kind: info.kind,
-  label: info.label,
-  settings: info.settings
-});
-var findMediaInputFromMediaStreamTrack = (devices) => (track) => {
-  if (!devices.length || !track) {
-    return void 0;
-  }
-  const settings = track.getSettings();
-  const devicesWithSameKind = devices.filter(
-    (d) => d.kind === `${track.kind}input`
-  );
-  const onlyDevice = devicesWithSameKind[0];
-  if (devicesWithSameKind.length === 1 && onlyDevice) {
-    onlyDevice.settings = settings;
-    onlyDevice.toJSON = () => toMediaDeviceInfoLikeJSON(onlyDevice);
-    return onlyDevice;
-  }
-  const device = devicesWithSameKind.find(
-    compareMediaDeviceToMediaTrack(track)
-  );
-  if (device) {
-    device.settings = settings;
-    device.toJSON = () => toMediaDeviceInfoLikeJSON(device);
-    return device;
-  }
-  return device;
-};
-var findMediaInputFromStream = (devices) => (stream) => {
-  if (!stream || !devices.length) {
-    return {};
-  }
-  const findMediaInput = findMediaInputFromMediaStreamTrack(devices);
-  return {
-    audioInput: findMediaInput(...stream.getAudioTracks()),
-    videoInput: findMediaInput(...stream.getVideoTracks())
-  };
-};
-var compareDeviceConstraintAndTrackDevice = (device) => (constraint) => {
-  if (!device || !constraint) {
-    return Boolean(device) === Boolean(constraint);
-  }
-  const normalized = normalizeDeviceConstraint(constraint);
-  if (normalized) {
-    const requestingDevices = Object.values(
-      normalized
-    ).flatMap((t) => Array.isArray(t) ? t : [t]);
-    const compare = compareDevices(
-      device,
-      device.label ? "label" : "deviceId"
-    );
-    return requestingDevices.some(compare);
-  }
-  return false;
-};
-var isRequestedResolution = (request, response) => {
-  if (!response || !request) {
-    return Boolean(response) === Boolean(request);
-  }
-  if (isInputConstraintSet(request)) {
-    const [width] = extractConstrainNumber("width")(request);
-    const [height] = extractConstrainNumber("height")(request);
-    const { width: responseWidth = 0, height: responseHeight = 0 } = response.settings ?? {};
-    const portrait = responseHeight >= responseWidth;
-    const resultWidth = portrait ? responseHeight : responseWidth;
-    const resultHeight = portrait ? responseWidth : responseHeight;
-    const sameWidth = satisfyConstrainNumber(width, resultWidth);
-    const sameHeight = satisfyConstrainNumber(height, resultHeight);
-    return sameWidth && sameHeight;
-  }
-  return true;
-};
-var isRequestedInputDevice = (request, response) => {
-  if (!response || !request) {
-    return Boolean(response) === Boolean(request);
-  }
-  const compareDevice = compareDeviceConstraintAndTrackDevice(response);
-  if (isInputConstraintSet(request)) {
-    if (isConstraintSetDevice(request.device)) {
-      const isSameDevice = compareDevice(request.device);
-      return isSameDevice;
-    }
-    if (request.deviceId) {
-      const { deviceId } = response;
-      if (!deviceId) {
-        return true;
-      }
-      if (isConstraintDOMString(request.deviceId)) {
-        const ids = toArray(request.deviceId);
-        return ids.some((id) => deviceId === id);
-      }
-      if (isConstrainDOMStringParameters(request.deviceId)) {
-        return Object.values(request.deviceId).flatMap(toArray).some((id) => id === deviceId);
-      }
-    }
-    const facingMode = response.settings?.facingMode;
-    if (request.facingMode && facingMode) {
-      const [facingModes] = extractConstrainString("facingMode")(request);
-      return facingModes?.some((fm) => fm === facingMode) ?? true;
-    }
-    return true;
-  }
-  if (isConstraintSetDevice(request)) {
-    return compareDevice(request);
-  }
-  return !!response;
-};
-var isRequestedInputTrack = (request, current) => {
-  if (!request || !current) {
-    return Boolean(request) === Boolean(current);
-  }
-  if (isMediaDeviceInfo(current)) {
-    return isRequestedInputDevice(request, current);
-  }
-  if (isMediaStreamTrack(current)) {
-    const device = extractDeviceInfo(current);
-    return isRequestedInputDevice(request, device);
-  }
-  return true;
-};
-var extractDevice = extractConstraintsWithKeys(["device", "deviceId"]);
-var hasRequestingDevice = (request, kind, currentDevices) => {
-  if (!request) {
-    return false;
-  }
-  const {
-    device: [devices],
-    deviceId: [deviceIds]
-  } = extractDevice(request);
-  if ((!devices || devices.length === 0) && (!deviceIds || deviceIds.length === 0)) {
-    return currentDevices.some((device) => device.kind === kind);
-  }
-  const find = (device) => findDevice(device)(currentDevices);
-  return devices?.some((device) => find(device)) ?? deviceIds?.some(
-    (deviceId) => find({ kind, deviceId, label: "", groupId: "" })
-  ) ?? false;
-};
-var shouldRequestDevice = (request, tracks, currentDevices) => {
-  if (!request || !currentDevices.some((device) => device.label)) {
-    return false;
-  }
-  const { kind } = currentDevices[0] ?? {};
-  if (!kind || currentDevices.some((device) => device.kind !== kind)) {
-    throw new Error("Expect a single kind of device");
-  }
-  const [track] = tracks;
-  if (tracks.length === 0 || tracks.some((track2) => track2.readyState === "ended")) {
-    return true;
-  }
-  if (isRequestedInputTrack(request, track)) {
-    return false;
-  }
-  if (hasRequestingDevice(request, kind, currentDevices)) {
-    return true;
-  }
-  return false;
-};
-var resolveInputDevice = (tracksOrDevice, findInput) => {
-  if (isMediaDeviceInfo(tracksOrDevice)) {
-    return tracksOrDevice;
-  }
-  if (Array.isArray(tracksOrDevice)) {
-    const [track] = tracksOrDevice;
-    if (track?.readyState === "live") {
-      return findInput(track) ?? track;
-    }
-  }
-  return void 0;
-};
-var isStreamingRequestedDevicesBase = (request, tracksOrDevices, devices) => {
-  const audioRequest = relaxInputConstraint(request.audio, devices);
-  const videoRequest = relaxInputConstraint(request.video, devices);
-  const findInput = findMediaInputFromMediaStreamTrack(devices);
-  const audioInput = resolveInputDevice(tracksOrDevices.audio, findInput);
-  const videoInput = resolveInputDevice(tracksOrDevices.video, findInput);
-  const audio = isRequestedInputTrack(audioRequest, audioInput);
-  const video = isRequestedInputTrack(videoRequest, videoInput);
-  return { audio, video };
-};
-var isStreamingRequestedDevices = (request, stream, devices) => isStreamingRequestedDevicesBase(
-  request,
-  {
-    audio: stream?.getAudioTracks(),
-    video: stream?.getVideoTracks()
-  },
-  devices
-);
-var findPermissionGrantedDevices = (devices) => devices.filter(isDeviceGranted);
-var toPermissionState = (devices, anyActiveStream = false) => {
-  const granted = devices.some((device) => device.label);
-  if (anyActiveStream) {
-    return granted ? "granted" : "denied";
-  }
-  return granted ? "granted" : "prompt";
-};
-var getInputDevicePermissionState = async (anyActiveStream = false) => {
-  try {
-    const video = await navigator.permissions.query({ name: "camera" });
-    const audio = await navigator.permissions.query({ name: "microphone" });
-    return { video: video.state, audio: audio.state };
-  } catch {
-    const devices = await getDevices();
-    return ["videoinput", "audioinput"].reduce(
-      (permission, kind) => {
-        const state2 = toPermissionState(
-          devices.filter((device) => device.kind === kind),
-          anyActiveStream
-        );
-        permission[kind === "audioinput" ? "audio" : "video"] = state2;
-        return permission;
-      },
-      { video: "prompt", audio: "prompt" }
-    );
-  }
-};
-var findCurrentAudioOutputId = (audioOutput, devices) => {
-  let selectedAudioOutputDeviceId = "";
-  if (audioOutput?.deviceId && devices) {
-    const latestSelectedAudioInput = findDevice(audioOutput)(devices);
-    if (latestSelectedAudioInput) {
-      selectedAudioOutputDeviceId = latestSelectedAudioInput.deviceId;
-    }
-  }
-  return selectedAudioOutputDeviceId;
-};
-var findCurrentVideoInputDeviceIdFromStream = (stream) => {
-  const [videoTrack] = stream.getVideoTracks();
-  return videoTrack && toMediaDeviceInfoLike(videoTrack)?.deviceId;
-};
-var findDeviceWithDeviceId = (devices, deviceId) => devices.find((d) => d.deviceId === deviceId);
-var findDevicesByKind = (kind) => (devices) => devices.filter(isSameDeviceKind(kind));
-var findAudioInputDevices = findDevicesByKind(
-  "audioinput" /* AUDIOINPUT */
-);
-var findVideoInputDevices = findDevicesByKind(
-  "videoinput" /* VIDEOINPUT */
-);
-var findAudioOutputDevices = findDevicesByKind(
-  "audiooutput" /* AUDIOOUTPUT */
-);
-var muteStreamTrack = (stream) => (mute, mediaType = "all") => {
-  switch (mediaType) {
-    case "audio":
-      stream?.getAudioTracks().forEach((track) => {
-        track.enabled = !mute;
-      });
-      break;
-    case "video":
-      stream?.getVideoTracks().forEach((track) => {
-        track.enabled = !mute;
-      });
-      break;
-    default:
-      stream?.getTracks().forEach((track) => {
-        track.enabled = !mute;
-      });
-      break;
-  }
-};
-var stopMediaStream = (stream, onStopped) => {
-  if (!stream) {
-    return;
-  }
-  stream.getTracks().forEach((track) => {
-    track.stop();
-    onStopped?.(track);
-  });
-};
-var areTracksEnabled = (stream, type) => {
-  if (!stream) {
-    return false;
-  }
-  const tracks = type === "audio" ? stream.getAudioTracks() : stream.getVideoTracks();
-  return tracks.length > 0 && tracks.every((track) => track.enabled);
-};
-var hasAudioOrVideoInputs = (devices) => devices.some(not(isAudioOutput));
-var hasAudioInputs = (devices) => devices.some(isAudioInput);
-var hasVideoInputs = (devices) => devices.some(isVideoInput);
-var hasAnyGrantedInput = (devices) => devices.some(
-  (device) => isDeviceGranted(device) && (isVideoInput(device) || isAudioInput(device))
-);
-var hasAnyInputs = (devices, grantedOnly = false) => {
-  let anyAudioDevices = false;
-  let anyVideoDevices = false;
-  for (const device of devices) {
-    if (isAudioOutput(device) || grantedOnly && !isDeviceGranted(device)) {
-      continue;
-    }
-    if (isAudioInput(device)) {
-      anyAudioDevices = true;
-    }
-    if (isVideoInput(device)) {
-      anyVideoDevices = true;
-    }
-    if (anyVideoDevices && anyAudioDevices) {
-      return [true, true];
-    }
-  }
-  return [anyAudioDevices, anyVideoDevices];
-};
-var hasChangedInput = (oldInput, newInput) => {
-  if (isMediaDeviceInfo(newInput)) {
-    if (isMediaDeviceInfo(oldInput) && !compareDevices(oldInput)(newInput) || !oldInput) {
-      return true;
-    }
-  } else if (oldInput) {
-    return true;
-  }
-  return false;
-};
-var areMultipleFacingModeSupported = (currentDevices, getSupportedConstraints = () => navigator.mediaDevices.getSupportedConstraints()) => {
-  if (!getSupportedConstraints().facingMode) {
-    return false;
-  }
-  const set = /* @__PURE__ */ new Set();
-  const hasFrontAndBackCameras = currentDevices.some((device) => {
-    if (device.kind !== "videoinput") {
-      return false;
-    }
-    if (device.label.match(/front/i)) {
-      set.add("front");
-    }
-    if (device.label.match(/(back|rear)/i)) {
-      set.add("back");
-    }
-    return set.size > 1;
-  });
-  if (!hasFrontAndBackCameras) {
-    return false;
-  }
-  return true;
-};
-var interpretCurrentFacingMode = (currentTrack) => {
-  if (!currentTrack || currentTrack.kind !== "video") {
-    return void 0;
-  }
-  const settings = currentTrack.getSettings();
-  if ("getCapabilities" in currentTrack) {
-    const capabilities = currentTrack.getCapabilities();
-    if (capabilities.facingMode && capabilities.facingMode.length > 0) {
-      return settings.facingMode;
-    }
-  }
-  if (settings.facingMode) {
-    return settings.facingMode;
-  }
-  if (currentTrack.label.match(/front/i)) {
-    return "user";
-  }
-  if (currentTrack.label.match(/(back|rear)/i)) {
-    return "environment";
-  }
-};
-
-// src/eventEmitter.ts
-var MediaEventType = /* @__PURE__ */ ((MediaEventType2) => {
-  MediaEventType2["Mute"] = "mute";
-  MediaEventType2["Unmute"] = "unmute";
-  MediaEventType2["Ended"] = "ended";
-  MediaEventType2["DevicesChanged"] = "devices:changed";
-  MediaEventType2["DevicesFound"] = "devices:found";
-  MediaEventType2["DevicesLost"] = "devices:lost";
-  MediaEventType2["DeviceLost"] = "device:lost";
-  MediaEventType2["DevicesUnauthorized"] = "devices:unauthorized";
-  MediaEventType2["NoInputDevices"] = "devices:noinput";
-  MediaEventType2["Error"] = "error";
-  MediaEventType2["Stream"] = "stream";
-  return MediaEventType2;
-})(MediaEventType || {});
-var eventEmitter = () => {
-  const element = document.createElement("a");
-  const createEvent = (data) => {
-    return new CustomEvent("data", { detail: data });
-  };
-  return {
-    dispatch(event) {
-      element.dispatchEvent(createEvent(event));
-    },
-    subscriber(listener, onUnsubscribe) {
-      element.addEventListener(
-        "data",
-        listener,
-        false
-      );
-      return () => {
-        element.removeEventListener(
-          "data",
-          listener,
-          false
-        );
-        onUnsubscribe();
-      };
-    }
-  };
-};
-
-// src/errors.ts
-var isDeviceInUseError = (error) => {
-  return error === "NotReadableError" /* NotReadableError */ || error === "TrackStartError" /* TrackStartError */;
-};
-var isPermissionDeniedError = (error) => {
-  return error === "NotAllowedError" /* NotAllowedError */ || error === "PermissionDeniedError" /* PermissionDeniedError */;
-};
-var isInputNotFoundError = ({ input, kind, devices }) => (error) => {
-  if (error === "NotFoundError" /* NotFoundError */) {
-    const hasDevices = devices.some((d) => d.kind === kind);
-    if (typeof input === "boolean") {
-      if (!hasDevices && input) {
-        return true;
-      }
-      return input && !hasDevices;
-    }
-    if (isMediaTrackConstraints(input)) {
-      const [deviceIds, requirement] = extractDeviceId(input);
-      if (requirement === "ideal") {
-        return !hasDevices;
-      }
-      if (requirement === "exact") {
-        return !devices.some(
-          (device) => deviceIds?.some(
-            (id) => device.kind === kind && id === device.deviceId
-          )
-        );
-      }
-    }
-  }
-  return false;
-};
-var normalizeError = (errors, parameters = []) => {
-  const error = errors.find((e) => e.fn(...parameters));
-  if (error) {
-    return error.type;
-  }
-  return false;
-};
-var normalizeGetUserMediaError = (browserError, constraints, devices) => {
-  const isAudioInputNotFoundError = isInputNotFoundError({
-    input: constraints.audio,
-    kind: "audioinput",
-    devices
-  });
-  const isVideoInputNotFoundError = isInputNotFoundError({
-    input: constraints.video,
-    kind: "videoinput",
-    devices
-  });
-  const areBothInputsNotFoundError = (error2) => isAudioInputNotFoundError(error2) && isVideoInputNotFoundError(error2);
-  const errorsFn = [
-    {
-      fn: isDeviceInUseError,
-      type: "NotReadableError" /* NotReadableError */
-      // For now just normalize to current spec
-    },
-    {
-      fn: isPermissionDeniedError,
-      type: "NotAllowedError" /* NotAllowedError */
-    },
-    {
-      fn: areBothInputsNotFoundError,
-      type: "AudioAndVideoDeviceNotFoundError" /* AudioAndVideoDeviceNotFoundError */
-    },
-    {
-      fn: isAudioInputNotFoundError,
-      type: "AudioInputDeviceNotFoundError" /* AudioInputDeviceNotFoundError */
-    },
-    {
-      fn: isVideoInputNotFoundError,
-      type: "VideoInputDeviceNotFoundError" /* VideoInputDeviceNotFoundError */
-    }
-  ];
-  const errorMsg = browserError.name === "Error" ? browserError.message : browserError.name;
-  const error = normalizeError(errorsFn, [errorMsg]);
-  return error ? error : errorMsg;
-};
-
-// src/getMediaStream.ts
-var getMediaStream = async (request) => {
-  if (!request.audio && !request.video) {
-    throw new Error("MissingConstraintsError" /* MissingConstraintsError */);
-  }
-  const devices = await getDevices();
-  const audio = relaxInputConstraint(request.audio, devices);
-  const video = relaxInputConstraint(request.video, devices);
-  const constraints = getMediaConstraints({
-    audio,
-    video,
-    defaultConstraints: request.getDefaultConstraints()
-  });
-  logger.debug(
-    { request, constraints, devices },
-    "Constraints used for getting media"
-  );
-  try {
-    navigator.mediaDevices.dispatchEvent(new Event("devicechange"));
-    const stream = await navigator.mediaDevices.getUserMedia(constraints);
-    navigator.mediaDevices.dispatchEvent(new Event("devicechange"));
-    return stream;
-  } catch (error) {
-    if (error instanceof Error) {
-      const devices2 = await getDevices();
-      throw new Error(
-        normalizeGetUserMediaError(error, constraints, devices2)
-      );
-    }
-    throw error;
-  }
-};
-
-// src/streams.ts
-var handleMediaStream = ({
-  dispatch,
-  getDefaultConstraints,
-  streamTrackMap
-}) => {
-  const setupMediaStreamTracks = ({ stream }) => {
-    let userFacingMode = false;
-    for (const track of stream.getTracks()) {
-      const { facingMode } = track.getSettings();
-      if (track) {
-        streamTrackMap.add(track);
-      }
-      if (track.kind === "video" && isBoolean(facingMode)) {
-        userFacingMode = facingMode;
-      }
-      const mutedListener = () => {
-        dispatch({ id: track.id, type: "mute" /* Mute */ });
-      };
-      track.addEventListener("mute" /* Mute */, mutedListener, false);
-      const unmutedListener = () => {
-        dispatch({ id: track.id, type: "unmute" /* Unmute */ });
-      };
-      track.addEventListener(
-        "unmute" /* Unmute */,
-        unmutedListener,
-        false
-      );
-      const endedListener = () => {
-        dispatch({ id: track.id, type: "ended" /* Ended */ });
-        track.removeEventListener(
-          "ended" /* Ended */,
-          endedListener,
-          false
-        );
-        track.removeEventListener(
-          "mute" /* Mute */,
-          mutedListener,
-          false
-        );
-        track.removeEventListener(
-          "unmute" /* Unmute */,
-          unmutedListener,
-          false
-        );
-        if (streamTrackMap.has(track)) {
-          streamTrackMap.remove(track);
-        }
-      };
-      track.addEventListener("ended", endedListener, true);
-    }
-    dispatch({
-      facingMode: userFacingMode,
-      stream,
-      type: "stream" /* Stream */,
-      video: stream.getVideoTracks().length > 0
-    });
-  };
-  const getUserMedia2 = async ({
-    audio,
-    video
-  }) => {
-    try {
-      const stream = await getMediaStream({
-        audio,
-        video,
-        getDefaultConstraints
-      });
-      setupMediaStreamTracks({ stream });
-      return stream;
-    } catch (error) {
-      if (error instanceof Error) {
-        dispatch({ type: "error" /* Error */, error });
-      }
-      throw error;
-    }
-  };
-  return { getUserMedia: getUserMedia2 };
-};
-var createStreamTrackEventSubscriptions = (track, handlers) => {
-  const trackSubscriptions = Object.keys(handlers).flatMap((eventKey) => {
-    const key = eventKey;
-    const trackEventHandler = handlers[key];
-    if (trackEventHandler) {
-      const handleEvent = () => trackEventHandler(track);
-      track.addEventListener(key, handleEvent);
-      const removeTrackEventHandler = () => {
-        track.removeEventListener(key, handleEvent);
-      };
-      return [removeTrackEventHandler];
-    }
-    return [];
-  });
-  return () => {
-    trackSubscriptions.forEach((unsubscribeEvent) => unsubscribeEvent());
-  };
-};
-
-// src/streamTrackMap.ts
-var createStreamTrackMap = (tracks) => {
-  const streamTrackMap = new Map(
-    tracks?.map((track) => [toKey(track), track])
-  );
-  const findTrack = (device) => {
-    return [...streamTrackMap].map(([_, track]) => track).find((track) => {
-      const { kind } = track;
-      const { deviceId } = track.getSettings();
-      if (!deviceId) {
-        return false;
-      }
-      return device.kind.includes(kind) && device.deviceId === deviceId;
-    });
-  };
-  const toStreamTrackKey = (deviceOrTrack) => {
-    const track = isMediaStreamTrack(deviceOrTrack) ? deviceOrTrack : findTrack(deviceOrTrack);
-    if (!track?.kind || !track.id) {
-      return "";
-    }
-    return toKey(track);
-  };
-  const add = (track) => {
-    const key = toStreamTrackKey(track);
-    if (key) {
-      return streamTrackMap.set(key, track);
-    }
-    throw new Error("StreamTrackNotFound" /* StreamTrackNotFound */);
-  };
-  const has = (deviceOrTrack) => {
-    const key = toStreamTrackKey(deviceOrTrack);
-    return key && streamTrackMap.has(key);
-  };
-  const clear = () => {
-    streamTrackMap.forEach((track) => {
-      track.stop();
-    });
-    streamTrackMap.clear();
-  };
-  const remove = (track) => {
-    const key = toStreamTrackKey(track);
-    track.stop();
-    return streamTrackMap.delete(key);
-  };
-  const size = () => streamTrackMap.size;
-  return {
-    add,
-    has,
-    clear,
-    remove,
-    size
-  };
-};
-
-// src/constants.ts
-var DISPLAY_CAPTURE_SURFACE_TYPE = {
-  Monitor: "monitor",
-  Window: "window",
-  Browser: "browser"
-};
-var CURSOR_CAPTURE_CONSTRAINT = {
-  Never: "never",
-  Always: "always",
-  Motion: "motion"
-};
-var INCLUDE_EXCLUDE_CONSTRAINT = {
-  Include: "include",
-  Exclude: "exclude"
-};
-
-// src/displayMedia.ts
-var limitSharingMonitorInterface = (constraints, stream) => {
-  if (!constraints.monitorTypeSurfaces || constraints.monitorTypeSurfaces !== "exclude") {
-    return stream;
-  }
-  for (const track of stream.getTracks()) {
-    const { displaySurface } = track.getSettings();
-    if (!displaySurface || displaySurface !== "monitor") {
-      continue;
-    }
-    stopMediaStream(stream);
-    throw new TypeError("MonitorSharingNotAllowed", {
-      cause: {
-        monitorTypeSurfaces: constraints.monitorTypeSurfaces,
-        track,
-        displaySurface
-      }
-    });
-  }
-  return stream;
-};
-
-// src/index.ts
-var state = () => {
-  const { dispatch, subscriber } = eventEmitter();
-  const streamTrackMap = createStreamTrackMap();
-  const { getDefaultConstraints, setDefaultConstraints: setDefaultConstraints2 } = getConstraintsHandlers();
-  const { getUserMedia: getUserMedia2 } = handleMediaStream({
-    dispatch,
-    getDefaultConstraints,
-    streamTrackMap
-  });
-  const subscribe2 = (listener) => {
-    return subscriber(
-      listener,
-      deviceChanged((event) => {
-        dispatch({
-          type: "devices:changed" /* DevicesChanged */,
-          devices: event.devices
-        });
-        if (!hasAudioOrVideoInputs(event.devices)) {
-          return dispatch({
-            type: "devices:noinput" /* NoInputDevices */,
-            devices: event.devices
-          });
-        }
-        if (event.unauthorized.length) {
-          dispatch({
-            type: "devices:unauthorized" /* DevicesUnauthorized */,
-            devices: event.unauthorized,
-            authorizedDevices: event.authorized
-          });
-        }
-        if (event.found.length) {
-          dispatch({
-            type: "devices:found" /* DevicesFound */,
-            authorizedDevices: event.authorized,
-            unauthorizedDevices: event.unauthorized,
-            devices: event.found
-          });
-        }
-        if (event.lost.length) {
-          dispatch({
-            type: "devices:lost" /* DevicesLost */,
-            authorizedDevices: event.authorized,
-            unauthorizedDevices: event.unauthorized,
-            devices: event.lost
-          });
-          for (const device of event.lost) {
-            if (streamTrackMap.has(device)) {
-              dispatch({ type: "device:lost" /* DeviceLost */, device });
-            }
-          }
-        }
-      })
-    );
-  };
-  return {
-    getUserMedia: getUserMedia2,
-    setDefaultConstraints: setDefaultConstraints2,
-    subscribe: subscribe2
-  };
-};
-var {
-  /**
-   * Get MediaStream with provided {@link MediaDeviceRequest | input constraints}
-   */
-  getUserMedia,
-  /**
-   * Set default media stream constraints
-   *
-   * A {@link
-   * https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamConstraints |
-   * MediaStreamConstraints} object specifying the types of media to request, along with any requirements for each type.
-   */
-  setDefaultConstraints,
-  /**
-   * Subscribe media events
-   */
-  subscribe
-} = state();
-export {
-  CURSOR_CAPTURE_CONSTRAINT,
-  DISPLAY_CAPTURE_SURFACE_TYPE,
-  INCLUDE_EXCLUDE_CONSTRAINT,
-  MediaDeviceFailure,
-  MediaDeviceKinds,
-  MediaEventType,
-  applyConstraints,
-  areMultipleFacingModeSupported,
-  areTracksEnabled,
-  compareDevices,
-  createStreamTrackEventSubscriptions,
-  createTrackDevicesChanges,
-  deviceChanged,
-  extractConstraintsWithKeys,
-  findAudioInputDevices,
-  findAudioOutputDevices,
-  findCurrentAudioOutputId,
-  findCurrentVideoInputDeviceIdFromStream,
-  findDevice,
-  findDeviceFromConstraints,
-  findDeviceWithDeviceId,
-  findDevicesByKind,
-  findMediaInputFromMediaStreamTrack,
-  findMediaInputFromStream,
-  findPermissionGrantedDevices,
-  findVideoInputDevices,
-  getDevices,
-  getFacingModeFromConstraintString,
-  getInputDevicePermissionState,
-  getUserMedia,
-  getValueFromConstrainNumber,
-  hasAnyGrantedInput,
-  hasAnyInputs,
-  hasAudioInputs,
-  hasAudioOrVideoInputs,
-  hasChangedInput,
-  hasRequestingDevice,
-  hasVideoInputs,
-  interpretCurrentFacingMode,
-  isAudioInput,
-  isAudioOutput,
-  isDeviceGranted,
-  isExactDeviceConstraint,
-  isFacingMode,
-  isMediaDeviceInfo,
-  isMediaDeviceInfoArray,
-  isMediaStreamTrack,
-  isRequestedInputDevice,
-  isRequestedInputTrack,
-  isRequestedResolution,
-  isStreamingRequestedDevices,
-  isStreamingRequestedDevicesBase,
-  isVideoInput,
-  limitSharingMonitorInterface,
-  mergeConstraints,
-  muteStreamTrack,
-  relaxInputConstraint,
-  setDefaultConstraints,
-  setLogger,
-  shouldRequestDevice,
-  stopMediaStream,
-  subscribe,
-  toKey,
-  toMediaDeviceInfoLike
-};