@angular-helpers/browser-web-apis 21.0.0 → 21.0.2

package/fesm2022/angular-helpers-browser-web-apis.mjs

@@ -0,0 +1,668 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, DestroyRef, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
+import { Observable } from 'rxjs';
+
+class PermissionsService {
+    async query(descriptor) {
+        if (!this.isSupported()) {
+            throw new Error('Permissions API not supported');
+        }
+        try {
+            return await navigator.permissions.query(descriptor);
+        }
+        catch (error) {
+            console.error('Error querying permission:', error);
+            throw error;
+        }
+    }
+    isSupported() {
+        return typeof navigator !== 'undefined' && 'permissions' in navigator;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Base class for all Browser Web API services
+ * Provides common functionality for:
+ * - Support checking
+ * - Permission management
+ * - Error handling
+ * - Lifecycle management with destroyRef
+ * - Logging
+ */
+class BrowserApiBaseService {
+    permissionsService = inject(PermissionsService);
+    destroyRef = inject(DestroyRef);
+    platformId = inject(PLATFORM_ID);
+    /**
+     * Check if running in browser environment using Angular's platform detection
+     */
+    isBrowserEnvironment() {
+        return isPlatformBrowser(this.platformId);
+    }
+    /**
+     * Check if running in server environment using Angular's platform detection
+     */
+    isServerEnvironment() {
+        return isPlatformServer(this.platformId);
+    }
+    /**
+     * Request a permission
+     */
+    async requestPermission(permission) {
+        if (this.isServerEnvironment()) {
+            throw new Error(`${this.getApiName()} API not available in server environment`);
+        }
+        try {
+            const status = await this.permissionsService.query({ name: permission });
+            return status.state === 'granted';
+        }
+        catch (error) {
+            console.error(`[${this.getApiName()}] Error requesting permission for ${permission}:`, error);
+            return false;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserApiBaseService, decorators: [{
+            type: Injectable
+        }] });
+
+class CameraService extends BrowserApiBaseService {
+    currentStream = null;
+    createError(message, cause) {
+        const error = new Error(message);
+        error.cause = cause;
+        return error;
+    }
+    getApiName() {
+        return 'camera';
+    }
+    ensureCameraSupport() {
+        if (!('mediaDevices' in navigator) || !('getUserMedia' in navigator.mediaDevices)) {
+            throw new Error('Camera API not supported in this browser');
+        }
+    }
+    async startCamera(constraints) {
+        this.ensureCameraSupport();
+        if (this.currentStream) {
+            this.stopCamera();
+        }
+        const permissionStatus = await this.permissionsService.query({ name: 'camera' });
+        if (permissionStatus.state !== 'granted') {
+            throw new Error('Camera permission required. Please grant camera access and try again.');
+        }
+        try {
+            const streamConstraints = constraints || {
+                video: {
+                    width: { ideal: 1280 },
+                    height: { ideal: 720 },
+                    facingMode: 'user'
+                }
+            };
+            this.currentStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
+            return this.currentStream;
+        }
+        catch (error) {
+            console.error('[CameraService] Error starting camera:', error);
+            if (error instanceof Error && error.name === 'NotAllowedError') {
+                throw this.createError('Camera permission denied by user. Please allow camera access in your browser settings and refresh the page.', error);
+            }
+            else if (error instanceof Error && error.name === 'NotFoundError') {
+                throw this.createError('No camera device found. Please connect a camera and try again.', error);
+            }
+            else if (error instanceof Error && error.name === 'NotReadableError') {
+                throw this.createError('Camera is already in use by another application. Please close other applications using the camera and try again.', error);
+            }
+            else if (error instanceof Error && error.name === 'OverconstrainedError') {
+                throw this.createError('Camera constraints cannot be satisfied. Try with different camera settings.', error);
+            }
+            else {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                throw this.createError(`Camera error: ${errorMessage}`, error);
+            }
+        }
+    }
+    stopCamera() {
+        if (this.currentStream) {
+            this.currentStream.getTracks().forEach((track) => {
+                track.stop();
+            });
+            this.currentStream = null;
+        }
+    }
+    async switchCamera(deviceId, constraints = {
+        video: {
+            width: { ideal: 1280 },
+            height: { ideal: 720 }
+        }
+    }) {
+        this.stopCamera();
+        const finalConstraints = {
+            video: constraints.video && typeof constraints.video === 'object'
+                ? { ...constraints.video, deviceId: { exact: deviceId } }
+                : { deviceId: { exact: deviceId } }
+        };
+        return this.startCamera(finalConstraints);
+    }
+    async getCameraCapabilities(deviceId) {
+        this.ensureCameraSupport();
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: { deviceId: { exact: deviceId } }
+            });
+            const videoTrack = stream.getVideoTracks()[0];
+            const capabilities = videoTrack.getCapabilities();
+            // Clean up the stream
+            stream.getTracks().forEach((track) => track.stop());
+            return capabilities || null;
+        }
+        catch (error) {
+            console.error('[CameraService] Error getting camera capabilities:', error);
+            return null;
+        }
+    }
+    getCurrentStream() {
+        return this.currentStream;
+    }
+    isStreaming() {
+        return this.currentStream !== null;
+    }
+    async getVideoInputDevices() {
+        this.ensureCameraSupport();
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.filter(device => device.kind === 'videoinput');
+        }
+        catch (error) {
+            console.error('[CameraService] Error enumerating video devices:', error);
+            throw this.createError('Failed to enumerate video devices', error);
+        }
+    }
+    // Direct access to native camera API
+    getNativeMediaDevices() {
+        this.ensureCameraSupport();
+        return navigator.mediaDevices;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: CameraService, decorators: [{
+            type: Injectable
+        }] });
+
+class GeolocationService extends BrowserApiBaseService {
+    getApiName() {
+        return 'geolocation';
+    }
+    ensureGeolocationSupport() {
+        if (!('geolocation' in navigator)) {
+            throw new Error('Geolocation API not supported in this browser');
+        }
+    }
+    getCurrentPosition(options) {
+        this.ensureGeolocationSupport();
+        return new Promise((resolve, reject) => {
+            navigator.geolocation.getCurrentPosition((position) => resolve(position), (error) => {
+                console.error('[GeolocationService] Error getting position:', error);
+                reject(error);
+            }, options);
+        });
+    }
+    watchPosition(options) {
+        this.ensureGeolocationSupport();
+        return new Observable((observer) => {
+            const watchId = navigator.geolocation.watchPosition((position) => observer.next(position), (error) => {
+                console.error('[GeolocationService] Error watching position:', error);
+                observer.error(error);
+            }, options);
+            return () => {
+                navigator.geolocation.clearWatch(watchId);
+            };
+        });
+    }
+    clearWatch(watchId) {
+        navigator.geolocation.clearWatch(watchId);
+    }
+    // Direct access to native geolocation API
+    getNativeGeolocation() {
+        this.ensureGeolocationSupport();
+        return navigator.geolocation;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: GeolocationService, decorators: [{
+            type: Injectable
+        }] });
+
+class MediaDevicesService extends BrowserApiBaseService {
+    createError(message, cause) {
+        const error = new Error(message);
+        error.cause = cause;
+        return error;
+    }
+    getApiName() {
+        return 'media-devices';
+    }
+    ensureMediaDevicesSupport() {
+        if (!('mediaDevices' in navigator)) {
+            throw new Error('MediaDevices API not supported in this browser');
+        }
+    }
+    async getDevices() {
+        this.ensureMediaDevicesSupport();
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices;
+        }
+        catch (error) {
+            console.error('[MediaDevicesService] Error enumerating devices:', error);
+            throw this.createError('Failed to enumerate media devices', error);
+        }
+    }
+    async getUserMedia(constraints) {
+        this.ensureMediaDevicesSupport();
+        try {
+            const defaultConstraints = {
+                video: true,
+                audio: true
+            };
+            const finalConstraints = constraints || defaultConstraints;
+            return await navigator.mediaDevices.getUserMedia(finalConstraints);
+        }
+        catch (error) {
+            console.error('[MediaDevicesService] Error getting user media:', error);
+            throw this.handleMediaError(error);
+        }
+    }
+    async getDisplayMedia(constraints) {
+        this.ensureMediaDevicesSupport();
+        if (!('getDisplayMedia' in navigator.mediaDevices)) {
+            throw new Error('Display media API not supported in this browser');
+        }
+        try {
+            const defaultConstraints = {
+                video: true,
+                audio: false
+            };
+            const finalConstraints = constraints || defaultConstraints;
+            return await navigator.mediaDevices.getDisplayMedia(finalConstraints);
+        }
+        catch (error) {
+            console.error('[MediaDevicesService] Error getting display media:', error);
+            throw this.createError('Failed to get display media', error);
+        }
+    }
+    watchDeviceChanges() {
+        this.ensureMediaDevicesSupport();
+        return new Observable((observer) => {
+            const handleDeviceChange = async () => {
+                try {
+                    const devices = await navigator.mediaDevices.enumerateDevices();
+                    observer.next(devices);
+                }
+                catch (error) {
+                    console.error('[MediaDevicesService] Error handling device change:', error);
+                }
+            };
+            // Listen for device changes
+            navigator.mediaDevices.addEventListener('devicechange', handleDeviceChange);
+            // Get initial devices
+            handleDeviceChange();
+            return () => {
+                navigator.mediaDevices.removeEventListener('devicechange', handleDeviceChange);
+            };
+        });
+    }
+    getVideoInputDevices() {
+        return this.getDevicesByKind('videoinput');
+    }
+    getAudioInputDevices() {
+        return this.getDevicesByKind('audioinput');
+    }
+    getAudioOutputDevices() {
+        return this.getDevicesByKind('audiooutput');
+    }
+    async getDevicesByKind(kind) {
+        const devices = await this.getDevices();
+        return devices.filter(device => device.kind === kind);
+    }
+    handleMediaError(error) {
+        let message;
+        if (error instanceof Error) {
+            switch (error.name) {
+                case 'NotAllowedError':
+                    message = 'Permission denied by user';
+                    break;
+                case 'NotFoundError':
+                    message = 'No media device found';
+                    break;
+                case 'NotReadableError':
+                    message = 'Media device is already in use';
+                    break;
+                case 'OverconstrainedError':
+                    message = 'Media constraints cannot be satisfied';
+                    break;
+                case 'TypeError':
+                    message = 'Invalid media constraints provided';
+                    break;
+                default:
+                    message = `Media error: ${error.message}`;
+            }
+        }
+        else {
+            message = 'Unknown media error occurred';
+        }
+        return this.createError(message, error);
+    }
+    // Direct access to native media devices API
+    getNativeMediaDevices() {
+        this.ensureMediaDevicesSupport();
+        return navigator.mediaDevices;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: MediaDevicesService, decorators: [{
+            type: Injectable
+        }] });
+
+class NotificationService extends BrowserApiBaseService {
+    getApiName() {
+        return 'notifications';
+    }
+    async showNotification(title, options) {
+        if (!('Notification' in window)) {
+            throw new Error('Notification API not supported in this browser');
+        }
+        const permissionStatus = await this.permissionsService.query({ name: 'notifications' });
+        if (permissionStatus.state !== 'granted') {
+            throw new Error('Notification permission required. Please grant notification access and try again.');
+        }
+        try {
+            return new Notification(title, options);
+        }
+        catch (error) {
+            console.error('[NotificationService] Error showing notification:', error);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: NotificationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: NotificationService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable
+        }] });
+
+class ClipboardService extends BrowserApiBaseService {
+    getApiName() {
+        return 'clipboard';
+    }
+    async ensureClipboardPermission(action) {
+        if (!('clipboard' in navigator)) {
+            throw new Error('Clipboard API not supported in this browser');
+        }
+        const permissionStatus = await this.permissionsService.query({
+            name: `clipboard-${action}`
+        });
+        if (permissionStatus.state !== 'granted') {
+            throw new Error(`Clipboard ${action} permission required. Please grant clipboard access and try again.`);
+        }
+    }
+    async writeText(text) {
+        await this.ensureClipboardPermission('write');
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch (error) {
+            console.error('[ClipboardService] Error writing to clipboard:', error);
+            throw error;
+        }
+    }
+    async readText() {
+        await this.ensureClipboardPermission('read');
+        try {
+            return await navigator.clipboard.readText();
+        }
+        catch (error) {
+            console.error('[ClipboardService] Error reading from clipboard:', error);
+            throw error;
+        }
+    }
+    async writeTextSecure(text) {
+        await this.ensureClipboardPermission('write');
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch (error) {
+            console.error('[ClipboardService] Error writing to clipboard:', error);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ClipboardService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ClipboardService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: ClipboardService, decorators: [{
+            type: Injectable
+        }] });
+
+const BROWSER_CAPABILITIES = [
+    { id: 'permissions', label: 'Permissions API', requiresSecureContext: false },
+    { id: 'geolocation', label: 'Geolocation API', requiresSecureContext: true },
+    { id: 'clipboard', label: 'Clipboard API', requiresSecureContext: true },
+    { id: 'notification', label: 'Notification API', requiresSecureContext: true },
+    { id: 'mediaDevices', label: 'MediaDevices API', requiresSecureContext: true },
+    { id: 'camera', label: 'Camera API', requiresSecureContext: true },
+    { id: 'webWorker', label: 'Web Worker API', requiresSecureContext: false },
+    { id: 'regexSecurity', label: 'Regex Security', requiresSecureContext: false },
+    { id: 'webStorage', label: 'Web Storage', requiresSecureContext: false },
+    { id: 'webShare', label: 'Web Share', requiresSecureContext: true },
+    { id: 'battery', label: 'Battery API', requiresSecureContext: false },
+    { id: 'webSocket', label: 'WebSocket API', requiresSecureContext: false }
+];
+class BrowserCapabilityService {
+    getCapabilities() {
+        return BROWSER_CAPABILITIES;
+    }
+    isSecureContext() {
+        return typeof window !== 'undefined' && window.isSecureContext;
+    }
+    isSupported(capability) {
+        switch (capability) {
+            case 'permissions':
+                return typeof navigator !== 'undefined' && 'permissions' in navigator;
+            case 'geolocation':
+                return typeof navigator !== 'undefined' && 'geolocation' in navigator;
+            case 'clipboard':
+                return typeof navigator !== 'undefined' && 'clipboard' in navigator;
+            case 'notification':
+                return typeof window !== 'undefined' && 'Notification' in window;
+            case 'mediaDevices':
+            case 'camera':
+                return typeof navigator !== 'undefined' && 'mediaDevices' in navigator;
+            case 'webWorker':
+            case 'regexSecurity':
+                return typeof Worker !== 'undefined';
+            case 'webStorage':
+                return typeof Storage !== 'undefined';
+            case 'webShare':
+                return typeof navigator !== 'undefined' && 'share' in navigator;
+            case 'battery':
+                return typeof navigator !== 'undefined' && 'getBattery' in navigator;
+            case 'webSocket':
+                return typeof WebSocket !== 'undefined';
+            default:
+                return false;
+        }
+    }
+    getAllStatuses() {
+        const secureContext = this.isSecureContext();
+        return this.getCapabilities().map((capability) => ({
+            id: capability.id,
+            label: capability.label,
+            supported: this.isSupported(capability.id),
+            secureContext,
+            requiresSecureContext: capability.requiresSecureContext
+        }));
+    }
+    async getPermissionState(permission) {
+        if (typeof navigator === 'undefined' || !('permissions' in navigator)) {
+            return 'unknown';
+        }
+        try {
+            const status = await navigator.permissions.query({ name: permission });
+            return status.state;
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: BrowserCapabilityService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class BrowserSupportUtil {
+    static isSupported(feature) {
+        if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+            return false;
+        }
+        switch (feature) {
+            case 'permissions':
+                return 'permissions' in navigator;
+            case 'camera':
+                return 'mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices;
+            case 'microphone':
+                return 'mediaDevices' in navigator && 'getUserMedia' in navigator.mediaDevices;
+            case 'geolocation':
+                return 'geolocation' in navigator;
+            case 'notifications':
+                return 'Notification' in window;
+            case 'clipboard':
+                return 'clipboard' in navigator;
+            case 'clipboard-read':
+                return 'clipboard' in navigator && 'readText' in navigator.clipboard;
+            case 'clipboard-write':
+                return 'clipboard' in navigator && 'writeText' in navigator.clipboard;
+            case 'persistent-storage':
+                return 'storage' in navigator && 'persist' in navigator.storage;
+            default:
+                return false;
+        }
+    }
+    static getUnsupportedFeatures() {
+        const features = [
+            'permissions',
+            'camera',
+            'microphone',
+            'geolocation',
+            'notifications',
+            'clipboard',
+            'clipboard-read',
+            'clipboard-write',
+            'persistent-storage'
+        ];
+        return features.filter(feature => !this.isSupported(feature));
+    }
+    static isSecureContext() {
+        return typeof window !== 'undefined' ? window.isSecureContext : false;
+    }
+    static getUserAgent() {
+        return typeof navigator !== 'undefined' ? navigator.userAgent : '';
+    }
+    static isMobile() {
+        const userAgent = this.getUserAgent().toLowerCase();
+        return /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
+    }
+    static isDesktop() {
+        return !this.isMobile();
+    }
+    static getBrowserInfo() {
+        const userAgent = this.getUserAgent();
+        return {
+            name: this.getBrowserName(userAgent),
+            version: this.getBrowserVersion(userAgent),
+            isChrome: /chrome/.test(userAgent) && !/edge/.test(userAgent),
+            isFirefox: /firefox/.test(userAgent),
+            isSafari: /safari/.test(userAgent) && !/chrome/.test(userAgent),
+            isEdge: /edge/.test(userAgent) || /edg/.test(userAgent)
+        };
+    }
+    static getBrowserName(userAgent) {
+        if (/chrome/.test(userAgent) && !/edge/.test(userAgent))
+            return 'Chrome';
+        if (/firefox/.test(userAgent))
+            return 'Firefox';
+        if (/safari/.test(userAgent) && !/chrome/.test(userAgent))
+            return 'Safari';
+        if (/edge/.test(userAgent) || /edg/.test(userAgent))
+            return 'Edge';
+        return 'Unknown';
+    }
+    static getBrowserVersion(userAgent) {
+        const match = userAgent.match(/(chrome|firefox|safari|edge|edg)\/(\d+)/i);
+        return match ? match[2] : 'Unknown';
+    }
+}
+
+class PermissionGuard {
+    permissionsService;
+    router;
+    constructor(permissionsService, router) {
+        this.permissionsService = permissionsService;
+        this.router = router;
+    }
+    canActivate(route) {
+        const permission = route.data?.['permission'];
+        if (!permission) {
+            return Promise.resolve(true);
+        }
+        return this.checkPermission(permission);
+    }
+    async checkPermission(permission) {
+        try {
+            const status = await this.permissionsService.query({ name: permission });
+            if (status.state !== 'granted') {
+                this.router.navigate(['/permission-denied'], {
+                    queryParams: { permission }
+                });
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Permission guard error:', error);
+            this.router.navigate(['/permission-denied'], {
+                queryParams: { permission }
+            });
+            return false;
+        }
+    }
+}
+function createPermissionGuard(permission) {
+    return {
+        canActivate: [PermissionGuard],
+        data: { permission }
+    };
+}
+
+// Browser Web APIs Services
+// Version
+const version = '0.1.0';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BrowserCapabilityService, BrowserSupportUtil, CameraService, ClipboardService, GeolocationService, MediaDevicesService, NotificationService, PermissionGuard, PermissionsService, createPermissionGuard, version };
+//# sourceMappingURL=angular-helpers-browser-web-apis.mjs.map