@pexip/media-control 17.2.0 → 17.4.0

package/dist/index.js

@@ -0,0 +1,105 @@
+/**
+ * media-control is meant to extend the mediaDevices api methods such as
+ * `getUserMedia`, `enumerateDevices` and events on media streams and tracks.
+ * The final goal is to have a library that gives a stable and robust way to use
+ * these methods while guaranteeing that the developer has better control over
+ * which devices are delivered, fail, or exist.
+ *
+ * @packageDocumentation
+ */
+import { areMultipleFacingModeSupported, areTracksEnabled, createTrackDevicesChanges, deviceChanged, findAudioInputDevices, findAudioOutputDevices, findCurrentAudioOutputId, findCurrentVideoInputDeviceIdFromStream, findDeviceWithDeviceId, findDevicesByKind, findMediaInputFromMediaStreamTrack, findMediaInputFromStream, findPermissionGrantedDevices, findVideoInputDevices, getDevices, getInputDevicePermissionState, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, muteStreamTrack, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, } from './devices';
+import { compareDevices, findDevice, isAudioOutput, isVideoInput, isAudioInput, isDeviceGranted, } from './utils';
+import { mergeConstraints, getConstraintsHandlers, relaxInputConstraint, findDeviceFromConstraints, isExactDeviceConstraint, extractConstraintsWithKeys, applyConstraints, getValueFromConstrainNumber, getFacingModeFromConstraintString, } from './constraints';
+import { eventEmitter, MediaEventType } from './eventEmitter';
+import { handleMediaStream, createStreamTrackEventSubscriptions, } from './streams';
+import { MediaDeviceFailure, MediaDeviceKinds, } from './types';
+import { isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isFacingMode, } from './typeGuards';
+import { createStreamTrackMap } from './streamTrackMap';
+export { setLogger } from './logger';
+const state = () => {
+    const { dispatch, subscriber } = eventEmitter();
+    const streamTrackMap = createStreamTrackMap();
+    const { getDefaultConstraints, setDefaultConstraints } = getConstraintsHandlers();
+    const { getUserMedia } = handleMediaStream({
+        dispatch,
+        getDefaultConstraints,
+        streamTrackMap,
+    });
+    /**
+     * Subscription media events
+     *
+     * @beta
+     */
+    const subscribe = (listener) => {
+        return subscriber(listener, deviceChanged(event => {
+            // Can be used to keep a store in sync
+            dispatch({
+                type: MediaEventType.DevicesChanged,
+                devices: event.devices,
+            });
+            if (!hasAudioOrVideoInputs(event.devices)) {
+                return dispatch({
+                    type: MediaEventType.NoInputDevices,
+                    devices: event.devices,
+                });
+            }
+            if (event.unauthorized.length) {
+                dispatch({
+                    type: MediaEventType.DevicesUnauthorized,
+                    devices: event.unauthorized,
+                    authorizedDevices: event.authorized,
+                });
+            }
+            if (event.found.length) {
+                // Can be used to trigger user notification of a potentially better device being available
+                dispatch({
+                    type: MediaEventType.DevicesFound,
+                    authorizedDevices: event.authorized,
+                    unauthorizedDevices: event.unauthorized,
+                    devices: event.found,
+                });
+            }
+            if (event.lost.length) {
+                // Can be used to trigger user notification of no longer seen devices
+                dispatch({
+                    type: MediaEventType.DevicesLost,
+                    authorizedDevices: event.authorized,
+                    unauthorizedDevices: event.unauthorized,
+                    devices: event.lost,
+                });
+                for (const device of event.lost) {
+                    if (streamTrackMap.has(device)) {
+                        // Can be used to trigger user warning that a device they were using is lost
+                        dispatch({ type: MediaEventType.DeviceLost, device });
+                    }
+                }
+            }
+        }));
+    };
+    return {
+        getUserMedia,
+        setDefaultConstraints,
+        subscribe,
+    };
+};
+const { 
+/**
+ * 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 { getUserMedia, setDefaultConstraints, subscribe };
+export { 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, getValueFromConstrainNumber, hasAnyGrantedInput, hasAnyInputs, hasAudioInputs, hasAudioOrVideoInputs, hasChangedInput, hasRequestingDevice, hasVideoInputs, interpretCurrentFacingMode, isAudioInput, isAudioOutput, isDeviceGranted, isExactDeviceConstraint, isFacingMode, isMediaDeviceInfo, isMediaDeviceInfoArray, isMediaStreamTrack, isRequestedInputDevice, isRequestedInputTrack, isRequestedResolution, isStreamingRequestedDevices, isStreamingRequestedDevicesBase, isVideoInput, mergeConstraints, muteStreamTrack, relaxInputConstraint, shouldRequestDevice, stopMediaStream, toKey, toMediaDeviceInfo, toMediaDeviceInfoLike, };
+export * from './constants';
+export * from './displayMedia';

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from './baseLogger';
+export declare let logger: Readonly<Logger>;
+export declare function setLogger(newLogger: Logger): void;

package/dist/logger.js

@@ -0,0 +1,5 @@
+import { createConsoleLogger } from './baseLogger';
+export let logger = createConsoleLogger();
+export function setLogger(newLogger) {
+    logger = newLogger;
+}

package/dist/streamTrackMap.d.ts

@@ -0,0 +1,9 @@
+import type { DeviceOrTrack, MediaStreamTrackLike } from './types';
+export declare const createStreamTrackMap: (tracks?: MediaStreamTrackLike[]) => {
+    add: (track: MediaStreamTrackLike) => Map<string, MediaStreamTrackLike>;
+    has: (deviceOrTrack: DeviceOrTrack) => boolean | "";
+    clear: () => void;
+    remove: (track: MediaStreamTrackLike) => boolean;
+    size: () => number;
+};
+export type StreamTrackMap = ReturnType<typeof createStreamTrackMap>;

package/dist/streamTrackMap.js

@@ -0,0 +1,79 @@
+import { MediaDeviceFailure } from './types';
+import { toKey } from './devices';
+import { isMediaStreamTrack } from './typeGuards';
+export const createStreamTrackMap = (tracks) => {
+    const streamTrackMap = new Map(tracks?.map(track => [toKey(track), track]));
+    /**
+     * Find track from the list of track in use.
+     */
+    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);
+        });
+    };
+    /**
+     * Construct a `StreamTrackKey` from `DeviceOrTrack`
+     */
+    const toStreamTrackKey = (deviceOrTrack) => {
+        // Unify interfaces
+        const track = isMediaStreamTrack(deviceOrTrack)
+            ? deviceOrTrack
+            : findTrack(deviceOrTrack);
+        if (!track?.kind || !track.id) {
+            return '';
+        }
+        return toKey(track);
+    };
+    /**
+     * Add the `MediaStreamTrack` to `streamTrackMap`
+     */
+    const add = (track) => {
+        const key = toStreamTrackKey(track);
+        if (key) {
+            return streamTrackMap.set(key, track);
+        }
+        throw new Error(MediaDeviceFailure.StreamTrackNotFound);
+    };
+    /**
+     * Check if `streamTrackMap` has provided track or device
+     */
+    const has = (deviceOrTrack) => {
+        const key = toStreamTrackKey(deviceOrTrack);
+        return key && streamTrackMap.has(key);
+    };
+    /**
+     * Stop all tracks and empty `streamTrackMap`
+     */
+    const clear = () => {
+        streamTrackMap.forEach(track => {
+            track.stop();
+        });
+        streamTrackMap.clear();
+    };
+    /**
+     * Stop the track and remove the track from `streamTrackMap`
+     */
+    const remove = (track) => {
+        const key = toStreamTrackKey(track);
+        track.stop();
+        return streamTrackMap.delete(key);
+    };
+    /**
+     * Get the size of `streamTrackMap`
+     */
+    const size = () => streamTrackMap.size;
+    return {
+        add,
+        has,
+        clear,
+        remove,
+        size,
+    };
+};

package/dist/streams.d.ts

@@ -0,0 +1,26 @@
+import type { MediaDeviceRequest, StreamTrackEventHandlers, Unsubscribe } from './types';
+import type { Dispatch } from './eventEmitter';
+import type { StreamTrackMap } from './streamTrackMap';
+/**
+ * Handle media streaming related functions and events
+ *
+ * @returns getUserMedia function to stream media
+ *
+ * @internal
+ */
+export declare const handleMediaStream: ({ dispatch, getDefaultConstraints, streamTrackMap, }: {
+    dispatch: Dispatch;
+    getDefaultConstraints: () => MediaStreamConstraints;
+    streamTrackMap: StreamTrackMap;
+}) => {
+    getUserMedia: ({ audio, video, }: MediaDeviceRequest) => Promise<MediaStream>;
+};
+/**
+ * Create a MediaStreamTrack's native events subscription
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#events
+ *
+ * @param track - The track used for the subscription
+ * @param handlers - An object contains the event handlers
+ */
+export declare const createStreamTrackEventSubscriptions: (track: MediaStreamTrack, handlers: StreamTrackEventHandlers) => Unsubscribe;

package/dist/streams.js

@@ -0,0 +1,99 @@
+import { isBoolean } from './typeGuards';
+import { MediaEventType } from './eventEmitter';
+import { getMediaStream } from './getMediaStream';
+/**
+ * Handle media streaming related functions and events
+ *
+ * @returns getUserMedia function to stream media
+ *
+ * @internal
+ */
+export const 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: MediaEventType.Mute });
+            };
+            track.addEventListener(MediaEventType.Mute, mutedListener, false);
+            const unmutedListener = () => {
+                dispatch({ id: track.id, type: MediaEventType.Unmute });
+            };
+            track.addEventListener(MediaEventType.Unmute, unmutedListener, false);
+            const endedListener = () => {
+                dispatch({ id: track.id, type: MediaEventType.Ended });
+                track.removeEventListener(MediaEventType.Ended, endedListener, false);
+                track.removeEventListener(MediaEventType.Mute, mutedListener, false);
+                track.removeEventListener(MediaEventType.Unmute, unmutedListener, false);
+                if (streamTrackMap.has(track)) {
+                    streamTrackMap.remove(track);
+                }
+            };
+            track.addEventListener('ended', endedListener, true);
+        }
+        dispatch({
+            facingMode: userFacingMode,
+            stream,
+            type: MediaEventType.Stream,
+            video: stream.getVideoTracks().length > 0,
+        });
+    };
+    /**
+     * Get MediaStream with MediaDeviceRequest
+     *
+     * @returns MediaStream
+     *
+     * @beta
+     */
+    const getUserMedia = async ({ audio, video, }) => {
+        try {
+            const stream = await getMediaStream({
+                audio,
+                video,
+                getDefaultConstraints,
+            });
+            setupMediaStreamTracks({ stream });
+            return stream;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                dispatch({ type: MediaEventType.Error, error });
+            }
+            throw error;
+        }
+    };
+    return { getUserMedia };
+};
+/**
+ * Create a MediaStreamTrack's native events subscription
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack#events
+ *
+ * @param track - The track used for the subscription
+ * @param handlers - An object contains the event handlers
+ */
+export const 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());
+    };
+};

package/dist/typeGuards.d.ts

@@ -0,0 +1,89 @@
+import type { ConstraintDeviceParameters, DeviceConstraint, InputConstraintSet } from './types';
+export declare const isBoolean: (t: unknown) => t is boolean;
+export declare const isUndefined: (t: unknown) => t is undefined;
+/**
+ * Check if provided variable is of type number and is NOT NaN
+ */
+export declare const isNumber: (t: unknown) => t is number;
+/**
+ * Check if provided variable is of type integer
+ */
+export declare const isInteger: (t: unknown) => t is number;
+/**
+ * Check if provided variable is of type floating point
+ */
+export declare const isFloat: (t: unknown) => t is number;
+/**
+ * Reference https://w3c.github.io/mediacapture-main/#dom-mediatrackconstraintset
+ */
+export declare const CONSTRAIN_STRING_KEYS: readonly ["facingMode", "resizeMode", "deviceId", "groupId"];
+export declare const EXTENDED_CONSTRAIN_STRING_KEYS: readonly ["videoSegmentation", "videoSegmentationModel", "bgImageUrl", "contentHint"];
+export type ExtendedConstrainStringKeys = (typeof EXTENDED_CONSTRAIN_STRING_KEYS)[number];
+export type ConstrainStringKeys = (typeof CONSTRAIN_STRING_KEYS)[number];
+export declare const CONSTRAIN_U_LONG_KEYS: readonly ["width", "height", "sampleRate", "sampleSize", "channelCount"];
+export declare const EXTENDED_CONSTRAIN_U_LONG_KEYS: readonly ["backgroundBlurAmount", "edgeBlurAmount"];
+export type ExtendedConstrainULongKeys = (typeof EXTENDED_CONSTRAIN_U_LONG_KEYS)[number];
+export type ConstrainULongKeys = (typeof CONSTRAIN_U_LONG_KEYS)[number];
+export declare const CONSTRAIN_DOUBLE_KEYS: readonly ["aspectRatio", "frameRate", "latency"];
+export declare const EXTENDED_CONSTRAIN_DOUBLE_KEYS: readonly ["foregroundThreshold"];
+export type ExtendedConstrainDoubleKeys = (typeof EXTENDED_CONSTRAIN_DOUBLE_KEYS)[number];
+export type ConstrainDoubleKeys = (typeof CONSTRAIN_DOUBLE_KEYS)[number];
+export declare const CONSTRAIN_BOOLEAN_KEYS: readonly ["echoCancellation", "autoGainControl", "noiseSuppression", "pan", "tilt", "zoom"];
+/**
+ * Extends boolean constraint keys for our own implementation of the media
+ * feature
+ */
+export declare const EXTENDED_CONSTRAIN_BOOLEAN_KEYS: readonly ["vad", "asd", "mixWithAdditionalMedia", "denoise", "flipHorizontal"];
+export type ExtendedConstrainBooleanKeys = (typeof EXTENDED_CONSTRAIN_BOOLEAN_KEYS)[number];
+export type ConstrainBooleanKeys = (typeof CONSTRAIN_BOOLEAN_KEYS)[number];
+/**
+ * The keys from the `MediaTrackConstraintSet`
+ */
+export declare const CONSTRAINT_SET_KEYS: readonly ["aspectRatio", "frameRate", "latency", "width", "height", "sampleRate", "sampleSize", "channelCount", "facingMode", "resizeMode", "deviceId", "groupId", "echoCancellation", "autoGainControl", "noiseSuppression", "pan", "tilt", "zoom"];
+export declare const isConstrainStringKeys: (t: unknown) => t is "deviceId" | "groupId" | "resizeMode" | "facingMode";
+export declare const isExtendedConstrainStringKeys: (t: unknown) => t is "videoSegmentation" | "videoSegmentationModel" | "bgImageUrl" | "contentHint";
+export declare const isConstrainULongKeys: (t: unknown) => t is "width" | "height" | "sampleRate" | "sampleSize" | "channelCount";
+export declare const isExtendedConstrainULongKeys: (t: unknown) => t is "backgroundBlurAmount" | "edgeBlurAmount";
+export declare const isConstrainDoubleKeys: (t: unknown) => t is "aspectRatio" | "frameRate" | "latency";
+export declare const isExtendedConstrainDoubleKeys: (t: unknown) => t is "foregroundThreshold";
+export declare const isConstrainBooleanKeys: (t: unknown) => t is "pan" | "tilt" | "zoom" | "echoCancellation" | "autoGainControl" | "noiseSuppression";
+export declare const isExtendedConstrainBooleanKeys: (t: unknown) => t is "denoise" | "vad" | "asd" | "mixWithAdditionalMedia" | "flipHorizontal";
+export declare const isMediaTrackConstraintSetKey: (t: string) => t is keyof MediaTrackConstraintSet;
+export declare const isMediaTrackConstraintsKey: (t: string) => t is keyof MediaTrackConstraints;
+export declare const isMediaTrackConstraints: (t: unknown) => t is MediaTrackConstraints;
+/**
+ * Check if provided is `MediaDeviceInfo`
+ *
+ * @beta
+ */
+export declare const isMediaDeviceInfo: (t: unknown) => t is MediaDeviceInfo;
+export declare const isMediaDeviceInfoArray: (t: unknown) => t is MediaDeviceInfo[];
+export declare const isDeviceConstraint: (t: unknown) => t is DeviceConstraint;
+export declare const isConstraintDOMString: (t: unknown) => t is string | string[];
+declare const CONSTRAIN_PARAM_KEYS: readonly ["exact", "ideal"];
+export type ConstrainParamKeys = (typeof CONSTRAIN_PARAM_KEYS)[number];
+declare const CONSTRAIN_RANGE_KEYS: readonly ["min", "max"];
+export type ConstrainRangeKeys = (typeof CONSTRAIN_RANGE_KEYS)[number];
+export type ConstrainRangeParamKeys = ConstrainParamKeys | ConstrainRangeKeys;
+export declare const isConstrainDOMParameters: <R>(isType: (x: unknown) => boolean, keys?: readonly ConstrainRangeParamKeys[]) => (t: unknown) => t is R;
+export declare const isConstrainDOMStringParameters: (t: unknown) => t is ConstrainDOMStringParameters;
+export declare const isConstrainBooleanParameters: (t: unknown) => t is ConstrainBooleanParameters;
+/**
+ * Check if provided var is a constraint object with `min` and/or `max` key only
+ */
+export declare const isConstrainRange: (t: unknown) => t is ConstrainDoubleRange;
+export declare const isConstrainDoubleRange: (t: unknown) => t is ConstrainDoubleRange;
+export declare const isConstrainULongRange: (t: unknown) => t is ConstrainULongRange;
+export declare const isConstraintDeviceParameters: (t: unknown) => t is ConstraintDeviceParameters;
+export declare const isConstraintSetDevice: (t: unknown) => t is DeviceConstraint | ConstraintDeviceParameters | undefined;
+type ExtendedConstraintSet = Pick<InputConstraintSet, ExtendedConstrainULongKeys | ExtendedConstrainDoubleKeys | ExtendedConstrainStringKeys | ExtendedConstrainBooleanKeys | 'device'>;
+export declare const isExtendedConstraint: (t: unknown) => t is ExtendedConstraintSet;
+export declare const isInputConstraintSet: (t: unknown) => t is InputConstraintSet;
+/**
+ * Check if provided is `MediaStreamTrack`
+ *
+ * @beta
+ */
+export declare const isMediaStreamTrack: (m: unknown) => m is MediaStreamTrack;
+export declare const isFacingMode: (s: unknown) => s is "user" | "environment" | "left" | "right";
+export {};

package/dist/typeGuards.js

@@ -0,0 +1,185 @@
+import { hasOwnProperty } from '@pexip/utils';
+import { FACING_MODE } from './types';
+export const isBoolean = (t) => typeof t === 'boolean';
+export const isUndefined = (t) => typeof t === 'undefined';
+/**
+ * Check if provided variable is of type number and is NOT NaN
+ */
+export const isNumber = (t) => typeof t === 'number' && !Number.isNaN(t);
+/**
+ * Check if provided variable is of type integer
+ */
+export const isInteger = (t) => Number.isInteger(t);
+/**
+ * Check if provided variable is of type floating point
+ */
+export const isFloat = (t) => isNumber(t) && !Number.isInteger(t) && Number.isFinite(t);
+/**
+ * Reference https://w3c.github.io/mediacapture-main/#dom-mediatrackconstraintset
+ */
+export const CONSTRAIN_STRING_KEYS = [
+    'facingMode',
+    'resizeMode',
+    'deviceId',
+    'groupId',
+];
+export const EXTENDED_CONSTRAIN_STRING_KEYS = [
+    'videoSegmentation',
+    'videoSegmentationModel',
+    'bgImageUrl',
+    'contentHint',
+];
+export const CONSTRAIN_U_LONG_KEYS = [
+    'width',
+    'height',
+    'sampleRate',
+    'sampleSize',
+    'channelCount',
+];
+export const EXTENDED_CONSTRAIN_U_LONG_KEYS = [
+    'backgroundBlurAmount',
+    'edgeBlurAmount',
+];
+export const CONSTRAIN_DOUBLE_KEYS = [
+    'aspectRatio',
+    'frameRate',
+    'latency',
+];
+export const EXTENDED_CONSTRAIN_DOUBLE_KEYS = ['foregroundThreshold'];
+export const CONSTRAIN_BOOLEAN_KEYS = [
+    'echoCancellation',
+    'autoGainControl',
+    'noiseSuppression',
+    'pan',
+    'tilt',
+    'zoom',
+];
+/**
+ * Extends boolean constraint keys for our own implementation of the media
+ * feature
+ */
+export const 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',
+];
+/**
+ * The keys from the `MediaTrackConstraintSet`
+ */
+export const CONSTRAINT_SET_KEYS = [
+    ...CONSTRAIN_DOUBLE_KEYS,
+    ...CONSTRAIN_U_LONG_KEYS,
+    ...CONSTRAIN_STRING_KEYS,
+    ...CONSTRAIN_BOOLEAN_KEYS,
+];
+export const isConstrainStringKeys = (t) => CONSTRAIN_STRING_KEYS.includes(t);
+export const isExtendedConstrainStringKeys = (t) => EXTENDED_CONSTRAIN_STRING_KEYS.includes(t);
+export const isConstrainULongKeys = (t) => CONSTRAIN_U_LONG_KEYS.includes(t);
+export const isExtendedConstrainULongKeys = (t) => EXTENDED_CONSTRAIN_U_LONG_KEYS.includes(t);
+export const isConstrainDoubleKeys = (t) => CONSTRAIN_DOUBLE_KEYS.includes(t);
+export const isExtendedConstrainDoubleKeys = (t) => EXTENDED_CONSTRAIN_DOUBLE_KEYS.includes(t);
+export const isConstrainBooleanKeys = (t) => CONSTRAIN_BOOLEAN_KEYS.includes(t);
+export const isExtendedConstrainBooleanKeys = (t) => EXTENDED_CONSTRAIN_BOOLEAN_KEYS.includes(t);
+export const isMediaTrackConstraintSetKey = (t) => CONSTRAINT_SET_KEYS.includes(t);
+export const isMediaTrackConstraintsKey = (t) => isMediaTrackConstraintSetKey(t) || t === 'advanced';
+export const 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)));
+};
+/**
+ * Check if provided is `MediaDeviceInfo`
+ *
+ * @beta
+ */
+export const isMediaDeviceInfo = (t) => {
+    if (!t || typeof t !== 'object') {
+        return false;
+    }
+    return !!t && 'deviceId' in t && 'kind' in t;
+};
+export const isMediaDeviceInfoArray = (t) => {
+    if (Array.isArray(t) && t.length && t.some(isMediaDeviceInfo)) {
+        return true;
+    }
+    return false;
+};
+export const isDeviceConstraint = (t) => {
+    return isMediaDeviceInfo(t) || isMediaDeviceInfoArray(t);
+};
+export const isConstraintDOMString = (t) => (typeof t === 'string' && !!t) || (Array.isArray(t) && t.some(Boolean));
+const CONSTRAIN_PARAM_KEYS = ['exact', 'ideal'];
+const CONSTRAIN_RANGE_KEYS = ['min', 'max'];
+const CONSTRAIN_KEYS = [
+    ...CONSTRAIN_PARAM_KEYS,
+    ...CONSTRAIN_RANGE_KEYS,
+];
+export const 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]));
+};
+export const isConstrainDOMStringParameters = isConstrainDOMParameters(isConstraintDOMString);
+export const isConstrainBooleanParameters = isConstrainDOMParameters(isBoolean);
+/**
+ * Check if provided var is a constraint object with `min` and/or `max` key only
+ */
+export const isConstrainRange = isConstrainDOMParameters(t => isFloat(t) || isInteger(t), CONSTRAIN_RANGE_KEYS);
+export const isConstrainDoubleRange = isConstrainDOMParameters(isFloat, CONSTRAIN_KEYS);
+export const isConstrainULongRange = isConstrainDOMParameters(isInteger, CONSTRAIN_KEYS);
+export const isConstraintDeviceParameters = isConstrainDOMParameters(t => isMediaDeviceInfo(t) || isMediaDeviceInfoArray(t));
+export const isConstraintSetDevice = (t) => isMediaDeviceInfo(t) ||
+    isMediaDeviceInfoArray(t) ||
+    isConstraintDeviceParameters(t);
+export const 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));
+};
+export const isInputConstraintSet = (t) => {
+    if (typeof t !== 'object' || t === null) {
+        return false;
+    }
+    return isExtendedConstraint(t) || isMediaTrackConstraints(t);
+};
+/**
+ * Check if provided is `MediaStreamTrack`
+ *
+ * @beta
+ */
+export const isMediaStreamTrack = (m) => {
+    if (m && typeof m === 'object') {
+        return !!m && 'getSettings' in m;
+    }
+    return false;
+};
+export const isFacingMode = (s) => {
+    if (typeof s === 'string' && FACING_MODE.includes(s)) {
+        return true;
+    }
+    return false;
+};