native-fn 1.1.3 → 1.1.4

package/dist/plugin/permission/index.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+var PermissionType;
+(function (PermissionType) {
+    PermissionType["Notification"] = "notifications";
+    PermissionType["Geolocation"] = "geolocation";
+    PermissionType["Camera"] = "camera";
+    PermissionType["Microphone"] = "microphone";
+    PermissionType["MIDI"] = "midi";
+})(PermissionType || (PermissionType = {}));
+var PermissionState;
+(function (PermissionState) {
+    PermissionState["Grant"] = "grant";
+    PermissionState["Denied"] = "denied";
+    PermissionState["Prompt"] = "prompt";
+    PermissionState["Unsupported"] = "unsupported";
+})(PermissionState || (PermissionState = {}));
+var GET_USER_MEDIA = (function () {
+    if (typeof globalThis.navigator.mediaDevices !== 'undefined' && typeof globalThis.navigator.mediaDevices.getUserMedia !== 'undefined')
+        return globalThis.navigator.mediaDevices.getUserMedia.bind(globalThis.navigator.mediaDevices);
+    var legacy = (function () {
+        if (typeof globalThis.navigator.getUserMedia !== 'undefined')
+            return globalThis.navigator.getUserMedia;
+        if (typeof globalThis.navigator.webkitGetUserMedia !== 'undefined')
+            return globalThis.navigator.webkitGetUserMedia;
+        if (typeof globalThis.navigator.mozGetUserMedia !== 'undefined')
+            return globalThis.navigator.mozGetUserMedia;
+        if (typeof globalThis.navigator.msGetUserMedia !== 'undefined')
+            return globalThis.navigator.msGetUserMedia;
+    })();
+    if (typeof legacy !== 'undefined') {
+        return function legacyUserMedia(constraints) {
+            if (constraints === void 0) { constraints = {}; }
+            return new Promise(function (resolve, reject) {
+                legacy.call(globalThis.navigator, constraints, resolve, reject);
+            });
+        };
+    }
+})();
+
+var Permission = {
+    request: request,
+    check: check,
+    Constants: {
+        PermissionType: PermissionType,
+        PermissionState: PermissionState,
+    },
+    Errors: {},
+};
+function request(type) {
+    var instance = this;
+    return new Promise(function (resolve) {
+        function resolveAfterCheck() {
+            instance.check(type).then(resolve);
+        }
+        instance.check(type)
+            .then(function (state) {
+            if (state === PermissionState.Grant)
+                return resolve(state);
+            switch (type) {
+                case PermissionType.Notification:
+                    if (typeof globalThis.Notification === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.Notification.requestPermission().then(function (value) {
+                        switch (value) {
+                            case 'default':
+                                return resolve(PermissionState.Prompt);
+                            case 'granted':
+                                return resolve(PermissionState.Grant);
+                            case 'denied':
+                                return resolve(PermissionState.Denied);
+                            default:
+                                resolveAfterCheck();
+                        }
+                    });
+                    break;
+                case PermissionType.Geolocation:
+                    if (typeof globalThis.navigator.geolocation === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.geolocation.getCurrentPosition(resolveAfterCheck, resolveAfterCheck);
+                    break;
+                case PermissionType.Microphone:
+                case PermissionType.Camera:
+                    if (typeof GET_USER_MEDIA === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    GET_USER_MEDIA({
+                        video: type === PermissionType.Camera,
+                        audio: type === PermissionType.Microphone,
+                    })
+                        .then(function (stream) {
+                        var tracks = stream.getTracks();
+                        for (var i = 0; i < tracks.length; i++)
+                            tracks[i].stop();
+                        resolveAfterCheck();
+                    })
+                        .catch(resolveAfterCheck);
+                    break;
+                case PermissionType.MIDI:
+                    if (typeof globalThis.navigator.requestMIDIAccess === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.requestMIDIAccess()
+                        .then(resolveAfterCheck)
+                        .catch(resolveAfterCheck);
+                    break;
+                default:
+                    return resolve(PermissionState.Unsupported);
+            }
+        });
+    });
+}
+function check(type) {
+    return new Promise(function (resolve) {
+        if (typeof globalThis.navigator.permissions === 'undefined')
+            return resolve(PermissionState.Unsupported);
+        globalThis.navigator.permissions.query({ name: type })
+            .then(function (status) {
+            switch (status.state) {
+                case 'prompt':
+                    return resolve(PermissionState.Prompt);
+                case 'granted':
+                    return resolve(PermissionState.Grant);
+                case 'denied':
+                    return resolve(PermissionState.Denied);
+                default:
+                    return resolve(PermissionState.Unsupported);
+            }
+        });
+    });
+}
+
+module.exports = Permission;

package/dist/plugin/permission/index.d.ts

@@ -0,0 +1,36 @@
+declare global {
+    interface Navigator {
+        getUserMedia?(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+        webkitGetUserMedia?(constraints: MediaStreamConstraints, successCallback: (stream: MediaStream) => void, errorCallback: (error: DOMException) => void): void;
+        mozGetUserMedia?(constraints: MediaStreamConstraints, successCallback: (stream: MediaStream) => void, errorCallback: (error: DOMException) => void): void;
+        msGetUserMedia?(constraints: MediaStreamConstraints, successCallback: (stream: MediaStream) => void, errorCallback: (error: DOMException) => void): void;
+    }
+}
+declare enum PermissionType {
+    Notification = "notifications",
+    Geolocation = "geolocation",
+    Camera = "camera",
+    Microphone = "microphone",
+    MIDI = "midi"
+}
+declare enum PermissionState {
+    Grant = "grant",
+    Denied = "denied",
+    Prompt = "prompt",
+    Unsupported = "unsupported"
+}
+
+declare interface PermissionInstance {
+    request(type: PermissionType): Promise<PermissionState>;
+    check(type: PermissionType): Promise<PermissionState>;
+    Constants: {
+        PermissionType: typeof PermissionType;
+        PermissionState: typeof PermissionState;
+    };
+    Errors: {};
+}
+
+declare const Permission: PermissionInstance;
+
+export { Permission as default };
+export type { PermissionInstance };

package/dist/plugin/permission/index.mjs

@@ -0,0 +1,129 @@
+var PermissionType;
+(function (PermissionType) {
+    PermissionType["Notification"] = "notifications";
+    PermissionType["Geolocation"] = "geolocation";
+    PermissionType["Camera"] = "camera";
+    PermissionType["Microphone"] = "microphone";
+    PermissionType["MIDI"] = "midi";
+})(PermissionType || (PermissionType = {}));
+var PermissionState;
+(function (PermissionState) {
+    PermissionState["Grant"] = "grant";
+    PermissionState["Denied"] = "denied";
+    PermissionState["Prompt"] = "prompt";
+    PermissionState["Unsupported"] = "unsupported";
+})(PermissionState || (PermissionState = {}));
+var GET_USER_MEDIA = (function () {
+    if (typeof globalThis.navigator.mediaDevices !== 'undefined' && typeof globalThis.navigator.mediaDevices.getUserMedia !== 'undefined')
+        return globalThis.navigator.mediaDevices.getUserMedia.bind(globalThis.navigator.mediaDevices);
+    var legacy = (function () {
+        if (typeof globalThis.navigator.getUserMedia !== 'undefined')
+            return globalThis.navigator.getUserMedia;
+        if (typeof globalThis.navigator.webkitGetUserMedia !== 'undefined')
+            return globalThis.navigator.webkitGetUserMedia;
+        if (typeof globalThis.navigator.mozGetUserMedia !== 'undefined')
+            return globalThis.navigator.mozGetUserMedia;
+        if (typeof globalThis.navigator.msGetUserMedia !== 'undefined')
+            return globalThis.navigator.msGetUserMedia;
+    })();
+    if (typeof legacy !== 'undefined') {
+        return function legacyUserMedia(constraints) {
+            if (constraints === void 0) { constraints = {}; }
+            return new Promise(function (resolve, reject) {
+                legacy.call(globalThis.navigator, constraints, resolve, reject);
+            });
+        };
+    }
+})();
+
+var Permission = {
+    request: request,
+    check: check,
+    Constants: {
+        PermissionType: PermissionType,
+        PermissionState: PermissionState,
+    },
+    Errors: {},
+};
+function request(type) {
+    var instance = this;
+    return new Promise(function (resolve) {
+        function resolveAfterCheck() {
+            instance.check(type).then(resolve);
+        }
+        instance.check(type)
+            .then(function (state) {
+            if (state === PermissionState.Grant)
+                return resolve(state);
+            switch (type) {
+                case PermissionType.Notification:
+                    if (typeof globalThis.Notification === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.Notification.requestPermission().then(function (value) {
+                        switch (value) {
+                            case 'default':
+                                return resolve(PermissionState.Prompt);
+                            case 'granted':
+                                return resolve(PermissionState.Grant);
+                            case 'denied':
+                                return resolve(PermissionState.Denied);
+                            default:
+                                resolveAfterCheck();
+                        }
+                    });
+                    break;
+                case PermissionType.Geolocation:
+                    if (typeof globalThis.navigator.geolocation === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.geolocation.getCurrentPosition(resolveAfterCheck, resolveAfterCheck);
+                    break;
+                case PermissionType.Microphone:
+                case PermissionType.Camera:
+                    if (typeof GET_USER_MEDIA === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    GET_USER_MEDIA({
+                        video: type === PermissionType.Camera,
+                        audio: type === PermissionType.Microphone,
+                    })
+                        .then(function (stream) {
+                        var tracks = stream.getTracks();
+                        for (var i = 0; i < tracks.length; i++)
+                            tracks[i].stop();
+                        resolveAfterCheck();
+                    })
+                        .catch(resolveAfterCheck);
+                    break;
+                case PermissionType.MIDI:
+                    if (typeof globalThis.navigator.requestMIDIAccess === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.requestMIDIAccess()
+                        .then(resolveAfterCheck)
+                        .catch(resolveAfterCheck);
+                    break;
+                default:
+                    return resolve(PermissionState.Unsupported);
+            }
+        });
+    });
+}
+function check(type) {
+    return new Promise(function (resolve) {
+        if (typeof globalThis.navigator.permissions === 'undefined')
+            return resolve(PermissionState.Unsupported);
+        globalThis.navigator.permissions.query({ name: type })
+            .then(function (status) {
+            switch (status.state) {
+                case 'prompt':
+                    return resolve(PermissionState.Prompt);
+                case 'granted':
+                    return resolve(PermissionState.Grant);
+                case 'denied':
+                    return resolve(PermissionState.Denied);
+                default:
+                    return resolve(PermissionState.Unsupported);
+            }
+        });
+    });
+}
+
+export { Permission as default };

package/dist/plugin/permission/src/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const FALLBACK_MEDIA_QUERY_LIST: MediaQueryList;

package/dist/plugin/permission/src/errors/not-supported-error.d.ts

@@ -0,0 +1,2 @@
+declare const NotSupportedError: ErrorConstructor;
+export { NotSupportedError, };

package/dist/plugin/permission/src/errors/permission-not-granted-error.d.ts

@@ -0,0 +1,2 @@
+declare const PermissionNotGrantedError: ErrorConstructor;
+export { PermissionNotGrantedError, };

package/dist/plugin/permission/src/plugin/appearance/constants/index.d.ts

@@ -0,0 +1,8 @@
+export declare enum Appearances {
+    Unknown = "unknown",
+    Light = "light",
+    Dark = "dark"
+}
+export declare let MEDIA_QUERY_LIST: MediaQueryList;
+export declare const CONTEXT: CanvasRenderingContext2D | null;
+export declare const SVG_PIXEL_DATA_URL: string;

package/dist/plugin/permission/src/plugin/appearance/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { AppearanceInstance } from "../types";
+declare const Appearance: AppearanceInstance;
+export default Appearance;

package/dist/plugin/permission/src/plugin/appearance/index.d.ts

@@ -0,0 +1,4 @@
+import Appearance from "./cores";
+export * from "./types";
+export * from "./constants";
+export default Appearance;

package/dist/plugin/permission/src/plugin/appearance/types/appearance.d.ts

@@ -0,0 +1,9 @@
+import { Appearances } from "../constants";
+export declare interface AppearanceInstance {
+    get value(): Appearances;
+    onChange(listener: (appearance: Appearances) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {
+        Appearances: typeof Appearances;
+    };
+    Errors: {};
+}

package/dist/plugin/permission/src/plugin/appearance/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./appearance";

package/dist/plugin/permission/src/plugin/badge/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { BadgeInstance } from "../types";
+declare const Badge: BadgeInstance;
+export default Badge;

package/dist/plugin/permission/src/plugin/badge/index.d.ts

@@ -0,0 +1,3 @@
+import Badge from "./cores";
+export * from "./types";
+export default Badge;

package/dist/plugin/permission/src/plugin/badge/types/badge.d.ts

@@ -0,0 +1,10 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface BadgeInstance {
+    set(contents: number): Promise<void>;
+    clear(): Promise<void>;
+    get supported(): boolean;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

package/dist/plugin/permission/src/plugin/badge/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./badge";

package/dist/plugin/permission/src/plugin/battery/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { BatteryInstance } from "../types";
+declare const Battery: BatteryInstance;
+export default Battery;

package/dist/plugin/permission/src/plugin/battery/index.d.ts

@@ -0,0 +1,3 @@
+import Badge from "./cores";
+export * from "./types";
+export default Badge;

package/dist/plugin/permission/src/plugin/battery/types/battery.d.ts

@@ -0,0 +1,26 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+declare global {
+    interface Navigator {
+        getBattery(): Promise<BatteryManager>;
+    }
+}
+export interface BatteryManager extends EventTarget {
+    readonly charging: boolean;
+    readonly chargingTime: number;
+    readonly dischargingTime: number;
+    readonly level: number;
+    onChange: ((this: BatteryManager, ev: Event) => any) | null;
+    onchargingchange: ((this: BatteryManager, ev: Event) => any) | null;
+    onchargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
+    ondischargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
+    onlevelchange: ((this: BatteryManager, ev: Event) => any) | null;
+}
+export declare interface BatteryInstance {
+    get value(): Promise<BatteryManager>;
+    get supported(): boolean;
+    onChange(listener: (battery: BatteryManager) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

package/dist/plugin/permission/src/plugin/battery/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./battery";

package/dist/plugin/permission/src/plugin/clipboard/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { ClipboardInstance } from "../types";
+declare const Clipboard: ClipboardInstance;
+export default Clipboard;

package/dist/plugin/permission/src/plugin/clipboard/index.d.ts

@@ -0,0 +1,3 @@
+import Clipboard from "./cores";
+export * from "./types";
+export default Clipboard;

package/dist/plugin/permission/src/plugin/clipboard/types/clipboard.d.ts

@@ -0,0 +1,6 @@
+export declare interface ClipboardInstance {
+    copy(item: any): Promise<boolean>;
+    paste(): Promise<string>;
+    Constants: {};
+    Errors: {};
+}

package/dist/plugin/permission/src/plugin/clipboard/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./clipboard";

package/dist/plugin/permission/src/plugin/dimension/constants/index.d.ts

@@ -0,0 +1,44 @@
+import { Dimensions } from "../types";
+export declare enum Orientation {
+    Portrait = "portrait",
+    Landscape = "landscape",
+    Unknown = "unknown"
+}
+export declare const ENV_PRESETS: {
+    readonly 'safe-area-inset': {
+        readonly top: "safe-area-inset-top";
+        readonly right: "safe-area-inset-right";
+        readonly bottom: "safe-area-inset-bottom";
+        readonly left: "safe-area-inset-left";
+    };
+    readonly 'safe-area-max-inset': {
+        readonly top: "safe-area-max-inset-top";
+        readonly right: "safe-area-max-inset-right";
+        readonly bottom: "safe-area-max-inset-bottom";
+        readonly left: "safe-area-max-inset-left";
+    };
+    readonly 'titlebar-area': {
+        readonly x: "titlebar-area-x";
+        readonly y: "titlebar-area-y";
+        readonly width: "titlebar-area-width";
+        readonly height: "titlebar-area-height";
+    };
+    readonly 'keyboard-inset': {
+        readonly top: "keyboard-inset-top";
+        readonly right: "keyboard-inset-right";
+        readonly bottom: "keyboard-inset-bottom";
+        readonly left: "keyboard-inset-left";
+        readonly width: "keyboard-inset-width";
+        readonly height: "keyboard-inset-height";
+    };
+    readonly 'viewport-segment': {
+        readonly width: "viewport-segment-width";
+        readonly height: "viewport-segment-height";
+        readonly top: "viewport-segment-top";
+        readonly right: "viewport-segment-right";
+        readonly bottom: "viewport-segment-bottom";
+        readonly left: "viewport-segment-left";
+    };
+};
+export declare const FALLBACK_DIMENSION: Dimensions;
+export declare let MEDIA_QUERY_LIST: MediaQueryList;

package/dist/plugin/permission/src/plugin/dimension/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { DimensionInstance } from "../types";
+declare const Dimension: DimensionInstance;
+export default Dimension;

package/dist/plugin/permission/src/plugin/dimension/index.d.ts

@@ -0,0 +1,4 @@
+import Dimension from "./cores";
+export * from "./types";
+export * from "./constants";
+export default Dimension;

package/dist/plugin/permission/src/plugin/dimension/types/dimensions.d.ts

@@ -0,0 +1,34 @@
+import { ENV_PRESETS, Orientation } from "../constants";
+export type EnvironmentPresetKey = keyof typeof ENV_PRESETS;
+export type EnvironmentPresetAttr<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
+export type EnvironmentPresetValues<K extends EnvironmentPresetKey> = {
+    [P in EnvironmentPresetAttr<K>]: number;
+};
+export declare interface DimensionInstance {
+    get value(): Dimensions;
+    environment: Environment;
+    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {
+        Orientation: typeof Orientation;
+    };
+    Errors: {};
+}
+export declare interface Dimensions {
+    outerWidth: number;
+    outerHeight: number;
+    innerWidth: number;
+    innerHeight: number;
+    scale: number;
+    orientation: Orientation;
+}
+export declare interface EnvironmentPreset<K extends EnvironmentPresetKey> {
+    get value(): EnvironmentPresetValues<K>;
+    onChange(listener: (value: EnvironmentPresetValues<K>) => void, options?: AddEventListenerOptions): () => void;
+}
+export declare interface Environment {
+    safeAreaInset: EnvironmentPreset<'safe-area-inset'>;
+    safeAreaMaxInset: EnvironmentPreset<'safe-area-max-inset'>;
+    keyboardInset: EnvironmentPreset<'keyboard-inset'>;
+    titlebarArea: EnvironmentPreset<'titlebar-area'>;
+    viewportSegment: EnvironmentPreset<'viewport-segment'>;
+}

package/dist/plugin/permission/src/plugin/dimension/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./dimensions";

package/dist/plugin/permission/src/plugin/dimension/utils/create-env-observer.d.ts

@@ -0,0 +1,24 @@
+import { EnvironmentPresetKey, EnvironmentPresetValues } from "../types";
+declare global {
+    interface Navigator {
+        readonly virtualKeyboard?: VirtualKeyboard;
+    }
+}
+type ChangeCallback<K extends EnvironmentPresetKey> = (values: EnvironmentPresetValues<K>) => void;
+interface VirtualKeyboardEventMap {
+    geometrychange: Event;
+}
+interface VirtualKeyboard extends EventTarget {
+    readonly boundingRect: DOMRect;
+    overlaysContent: boolean;
+    show(): void;
+    hide(): void;
+    addEventListener<K extends keyof VirtualKeyboardEventMap>(type: K, listener: (this: VirtualKeyboard, ev: VirtualKeyboardEventMap[K]) => any, options?: AddEventListenerOptions): void;
+    removeEventListener<K extends keyof VirtualKeyboardEventMap>(type: K, listener: (this: VirtualKeyboard, ev: VirtualKeyboardEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+export type EnvObserver<K extends EnvironmentPresetKey> = {
+    get(): EnvironmentPresetValues<K>;
+    onChange(callback: ChangeCallback<K>, options?: AddEventListenerOptions): () => void;
+};
+export default function createEnvObserver<K extends EnvironmentPresetKey>(preset: K): EnvObserver<K>;
+export {};

package/dist/plugin/permission/src/plugin/fullscreen/cores/index.d.ts

@@ -0,0 +1,37 @@
+import { FullscreenInstance } from "../types";
+declare global {
+    interface HTMLVideoElement {
+        webkitEnterFullscreen?: () => void;
+        webkitExitFullscreen?: () => void;
+        webkitSupportsFullscreen?: boolean;
+        webkitDisplayingFullscreen?: boolean;
+        onwebkitbeginfullscreen?: ((this: HTMLVideoElement, ev: Event) => any) | null;
+        onwebkitendfullscreen?: ((this: HTMLVideoElement, ev: Event) => any) | null;
+        [key: symbol]: boolean | undefined;
+    }
+    interface Document {
+        readonly fullscreenEnabled: boolean;
+        fullscreenElement?: Element | null;
+        exitFullscreen: () => Promise<void>;
+        readonly webkitFullscreenEnabled?: boolean;
+        webkitFullscreenElement?: Element | null;
+        webkitCurrentFullScreenElement?: Element | null;
+        webkitExitFullscreen?: () => Promise<void>;
+        webkitCancelFullScreen?: () => Promise<void>;
+        readonly mozFullScreenEnabled?: boolean;
+        mozFullScreenElement?: Element | null;
+        mozCancelFullScreen?: () => Promise<void>;
+        readonly msFullscreenEnabled?: boolean;
+        msFullscreenElement?: Element | null;
+        msExitFullscreen?: () => Promise<void>;
+    }
+    interface Element {
+        requestFullscreen: (options?: FullscreenOptions) => Promise<void>;
+        webkitRequestFullscreen?: (options?: FullscreenOptions) => Promise<void>;
+        webkitRequestFullScreen?: (options?: FullscreenOptions) => Promise<void>;
+        mozRequestFullScreen?: () => Promise<void>;
+        msRequestFullscreen?: () => Promise<void>;
+    }
+}
+declare const _default: FullscreenInstance;
+export default _default;

package/dist/plugin/permission/src/plugin/fullscreen/index.d.ts

@@ -0,0 +1,3 @@
+import Fullscreen from "./cores";
+export * from "./types";
+export default Fullscreen;

package/dist/plugin/permission/src/plugin/fullscreen/types/fullscreen.d.ts

@@ -0,0 +1,15 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface FullscreenInstance {
+    supported: boolean;
+    element: Element | null;
+    isFullscreen: boolean;
+    request(target?: Element, options?: FullscreenOptions): Promise<void>;
+    exit(): Promise<void>;
+    toggle(target?: Element, options?: FullscreenOptions): Promise<void>;
+    onChange(listener: (event: Event) => void, options?: AddEventListenerOptions): () => void;
+    onError(listener: (event: Event) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

package/dist/plugin/permission/src/plugin/fullscreen/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./fullscreen";

package/dist/plugin/permission/src/plugin/geolocation/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { GeolocationInstance } from "../types";
+declare const Geolocation: GeolocationInstance;
+export default Geolocation;

package/dist/plugin/permission/src/plugin/geolocation/index.d.ts

@@ -0,0 +1,3 @@
+import Geolocation from "./cores";
+export * from "./types";
+export default Geolocation;

package/dist/plugin/permission/src/plugin/geolocation/types/geolocation.d.ts

@@ -0,0 +1,12 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+import { PermissionNotGrantedError } from "../../../errors/permission-not-granted-error";
+export declare interface GeolocationInstance {
+    get value(): Promise<GeolocationCoordinates>;
+    get supported(): boolean;
+    onChange(listener: (coordinates: GeolocationCoordinates) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
+}

package/dist/plugin/permission/src/plugin/geolocation/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./geolocation";

package/dist/plugin/permission/src/plugin/notification/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { NotificationInstance } from "../types";
+declare const Notification: NotificationInstance;
+export default Notification;

package/dist/plugin/permission/src/plugin/notification/index.d.ts

@@ -0,0 +1,3 @@
+import Notification from "./cores";
+export * from "./types";
+export default Notification;