native-fn 1.0.80 → 1.0.82

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

@@ -0,0 +1,12 @@
+export declare enum AppOpenState {
+    Scheme = 0,
+    Universal = 1,
+    Intent = 2,
+    Fallback = 3,
+    Store = 4
+}
+export declare enum MessengerType {
+    Telephone = "telephone",
+    Message = "message",
+    Mail = "mail"
+}

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

@@ -0,0 +1,13 @@
+import { AppInstance } from "../types";
+declare global {
+    interface Document {
+        webkitVisibilityState?: 'hidden' | 'visible';
+        mozVisibilityState?: 'hidden' | 'visible';
+        msVisibilityState?: 'hidden' | 'visible';
+        webkitHidden?: boolean;
+        mozHidden?: boolean;
+        msHidden?: boolean;
+    }
+}
+declare const App: AppInstance;
+export default App;

package/dist/plugin/dimension/src/plugin/app/errors/url-open-error.d.ts

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

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

@@ -0,0 +1,12 @@
+import type { NativePlugin } from "../../types";
+import type { AppInstance } from "./types";
+import { AppOpenState, MessengerType } from "./constants";
+import { URLOpenError } from "./errors/url-open-error";
+export * from "./types";
+declare const NativeAppPlugin: NativePlugin<'App', AppInstance, {
+    AppOpenState: typeof AppOpenState;
+    Messengers: typeof MessengerType;
+}, {
+    URLOpenError: typeof URLOpenError;
+}>;
+export default NativeAppPlugin;

package/dist/plugin/dimension/src/plugin/app/types/app.d.ts

@@ -0,0 +1,54 @@
+import { AppOpenState, MessengerType } from "../constants";
+import { OS } from "../../platform/constants";
+export declare interface AppInfo {
+    scheme?: URLCandidate;
+    fallback?: URLCandidateOrFallback;
+    timeout?: number;
+    allowAppStore?: boolean;
+    allowWebStore?: boolean;
+}
+export declare interface AndroidAppInfo extends AppInfo {
+    packageName?: string;
+    intent?: URLCandidate;
+}
+export declare interface IOSAppInfo extends MacOSAppInfo {
+    universal?: URLCandidate;
+}
+export declare interface WindowsAppInfo extends AppInfo {
+    productId?: string;
+}
+export declare interface MacOSAppInfo extends AppInfo {
+    bundleId?: string;
+    trackId?: string;
+}
+export declare interface StoreInfo {
+    appStore?: string;
+    webStore?: string;
+}
+export declare interface AppOpenOptions {
+    [OS.Android]?: AndroidAppInfo;
+    ['android']?: AndroidAppInfo;
+    [OS.iOS]?: IOSAppInfo;
+    ['ios']?: IOSAppInfo;
+    [OS.Windows]?: WindowsAppInfo;
+    ['windows']?: WindowsAppInfo;
+    [OS.MacOS]?: MacOSAppInfo;
+    ['mac']?: MacOSAppInfo;
+}
+export declare type URLCandidate = URL | string;
+export declare type URLCandidateOrFallback = URLCandidate | (() => any);
+export declare type URLStringOrFallback = string | (() => any);
+export declare type Stringifiable = string | number | boolean | HTMLElement | null | undefined;
+export declare type StringifiableSequence = Stringifiable[] | NodeList | NodeListOf<Node> | HTMLCollectionBase;
+export declare type MessengerOpenOptions = {
+    to?: Stringifiable | StringifiableSequence;
+    cc?: Stringifiable | StringifiableSequence;
+    bcc?: Stringifiable | StringifiableSequence;
+    subject?: Stringifiable;
+    body?: Stringifiable;
+} | HTMLFormElement | FormData;
+export declare type Messenger = Record<MessengerType, (options: MessengerOpenOptions) => Promise<void>>;
+export declare interface AppInstance {
+    open(options: AppOpenOptions): Promise<AppOpenState>;
+    messenger: Messenger;
+}

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

@@ -0,0 +1,16 @@
+export * from "./app";
+import type { AppInstance } from "./";
+import { AppOpenState, MessengerType } from "../constants";
+import { URLOpenError } from "../errors/url-open-error";
+declare module 'native-fn' {
+    interface NativePlugins {
+        App: AppInstance;
+    }
+    interface NativeConstants {
+        AppOpenState: typeof AppOpenState;
+        Messengers: typeof MessengerType;
+    }
+    interface NativeErrors {
+        URLOpenError: typeof URLOpenError;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { ListenerEntry } from "../types";
+export declare enum Appearances {
+    Unknown = "unknown",
+    Light = "light",
+    Dark = "dark"
+}
+export declare const MEDIA_QUERY_LIST: MediaQueryList;
+export declare const SUPPORT_PREFERS_COLOR_SCHEME: boolean;
+export declare const CONTEXT: CanvasRenderingContext2D | null;
+export declare const SVG_PIXEL_DATA_URL: string;
+export declare const ENTRIES: ListenerEntry[];

package/dist/plugin/dimension/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/dimension/src/plugin/appearance/index.d.ts

@@ -0,0 +1,8 @@
+import { NativePlugin } from "../../types";
+import { AppearanceInstance } from "./types";
+import { Appearances } from "./constants";
+export * from "./types";
+declare const NativeAppearancePlugin: NativePlugin<'Appearance', AppearanceInstance, {
+    Appearances: typeof Appearances;
+}, {}>;
+export default NativeAppearancePlugin;

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

@@ -0,0 +1,12 @@
+import { Appearances } from "../constants";
+export declare interface ListenerEntry {
+    fn: (appearance: Appearances) => any;
+    capture: boolean;
+    once: boolean;
+    signal?: AbortSignal;
+}
+export declare interface AppearanceInstance {
+    get value(): Appearances;
+    set value(appearances: Exclude<Appearances, Appearances.Unknown>);
+    onchange(listener: (appearance?: Appearances) => any, options?: boolean | AddEventListenerOptions): () => void;
+}

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

@@ -0,0 +1,13 @@
+export * from "./appearance";
+import type { AppearanceInstance } from "./appearance";
+import { Appearances } from "../constants";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Appearance: AppearanceInstance;
+    }
+    interface NativeConstants {
+        Appearances: typeof Appearances;
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/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/dimension/src/plugin/clipboard/index.d.ts

@@ -0,0 +1,5 @@
+import type { NativePlugin } from "../../types";
+import type { ClipboardInstance } from "./types";
+export * from "./types";
+declare const NativeClipboardPlugin: NativePlugin<'Clipboard', ClipboardInstance, {}, {}>;
+export default NativeClipboardPlugin;

package/dist/plugin/dimension/src/plugin/clipboard/types/appearance.d.ts

@@ -0,0 +1,13 @@
+import { Appearances } from "../constants";
+import { NativeModule } from "../../../types";
+export declare interface ListenerEntry {
+    fn: (appearance: Appearances) => any;
+    capture: boolean;
+    once: boolean;
+    signal?: AbortSignal;
+}
+export declare interface AppearanceInstance extends NativeModule {
+    get value(): Appearances;
+    set value(appearances: Exclude<Appearances, Appearances.Unknown>);
+    onchange(listener: (appearance?: Appearances) => any, options?: boolean | AddEventListenerOptions): () => void;
+}

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

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

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

@@ -0,0 +1,11 @@
+export * from "./clipboard";
+import type { ClipboardInstance } from "./clipboard";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Clipboard: ClipboardInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/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/dimension/src/plugin/dimension/index.d.ts

@@ -0,0 +1,4 @@
+import { NativePlugin } from "../../types";
+import { DimensionInstance } from "./types";
+declare const NativeDimensionPlugin: NativePlugin<'Dimension', DimensionInstance, {}, {}>;
+export default NativeDimensionPlugin;

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

@@ -0,0 +1,8 @@
+export declare interface ListenerEntry {
+    fn: () => any;
+    capture: boolean;
+    once: boolean;
+    signal?: AbortSignal;
+}
+export declare interface DimensionInstance {
+}

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

@@ -0,0 +1,13 @@
+import { DimensionInstance } from "./dimension";
+import Dimension from "../cores";
+export * from "./dimension";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Dimension: DimensionInstance;
+    }
+    interface NativeConstants {
+        Dimension: typeof Dimension;
+    }
+    interface NativeErrors {
+    }
+}

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

@@ -0,0 +1,35 @@
+import { FullscreenInstance } from "../types";
+declare const Fullscreen: FullscreenInstance;
+declare global {
+    interface HTMLVideoElement {
+        webkitEnterFullscreen?: () => void;
+        webkitExitFullscreen?: () => void;
+        webkitSupportsFullscreen?: boolean;
+        webkitDisplayingFullscreen?: boolean;
+        __fsBridged__?: boolean;
+    }
+    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>;
+    }
+}
+export default Fullscreen;

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

@@ -0,0 +1,5 @@
+import type { NativePlugin } from "../../types";
+import type { FullscreenInstance } from "./types";
+export * from "./types";
+declare const NativeFullscreenPlugin: NativePlugin<'Fullscreen', FullscreenInstance, {}, {}>;
+export default NativeFullscreenPlugin;

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

@@ -0,0 +1,10 @@
+export declare interface FullscreenInstance {
+    enabled: boolean;
+    element: any;
+    isFullscreen: boolean;
+    request(target?: any, options?: FullscreenOptions): Promise<void>;
+    exit(): Promise<void>;
+    toggle(target?: any, options?: FullscreenOptions): Promise<void>;
+    onchange(handler: (event: Event) => void): () => void;
+    onerror(handler: (event: Event) => void): () => void;
+}

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

@@ -0,0 +1,11 @@
+export * from "./fullscreen";
+import type { FullscreenInstance } from "./fullscreen";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Fullscreen: FullscreenInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

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

@@ -0,0 +1,42 @@
+export declare enum OS {
+    Unknown = "Unknown",
+    Android = "Android",
+    iOS = "iOS",
+    Windows = "Windows",
+    MacOS = "MacOS"
+}
+export declare enum Devices {
+    Unknown = "Unknown",
+    Mobile = "Mobile",
+    Desktop = "Desktop"
+}
+export declare enum Engines {
+    Unknown = "Unknown",
+    EdgeHTML = "EdgeHTML",
+    ArkWeb = "ArkWeb",
+    Blink = "Blink",
+    Presto = "Presto",
+    WebKit = "WebKit",
+    Trident = "Trident",
+    NetFront = "NetFront",
+    KHTML = "KHTML",
+    Tasman = "Tasman",
+    Gecko = "Gecko"
+}
+export declare enum Browsers {
+    Unknown = "Unknown",
+    Chrome = "Chrome",
+    Safari = "Safari",
+    Edge = "Edge",
+    Firefox = "Firefox",
+    Opera = "Opera",
+    IE = "IE",
+    SamsungInternet = "SamsungInternet"
+}
+export declare enum CrossPlatformFramework {
+    Unknown = "Unknown",
+    ReactNative = "ReactNative",
+    Electron = "Electron",
+    Cordova = "Cordova"
+}
+export declare const USER_AGENT: string;

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

@@ -0,0 +1,45 @@
+import { PlatformInstance } from "../types";
+declare global {
+    var cordova: string | undefined;
+    var device: CordovaDevice | undefined;
+    interface Navigator {
+        userAgent?: string;
+        userAgentData?: UserAgentData;
+        language?: string;
+        languages?: readonly string[];
+        browserLanguage?: string;
+        systemLanguage?: string;
+        userLanguage?: string;
+        connection?: NavigatorConnection;
+        mozConnection?: NavigatorConnection;
+        webkitConnection?: NavigatorConnection;
+    }
+}
+interface NavigatorConnection {
+    effectiveType?: 'slow-2g' | '2g' | '3g' | '4g';
+    type?: 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other';
+    downlink?: number;
+    rtt?: number;
+    saveData?: boolean;
+}
+interface CordovaDevice {
+    platform: string;
+    version: string;
+}
+interface ModernUserAgentDataBrand {
+    brand: string;
+    version: string;
+}
+type UserAgentDataBrand = ModernUserAgentDataBrand | string | null | undefined;
+interface UserAgentDataValues {
+    brands?: UserAgentDataBrand[];
+    fullVersionList?: UserAgentDataBrand[];
+    platformVersion?: string | null | undefined;
+    platform?: string | null | undefined;
+    mobile?: boolean;
+}
+interface UserAgentData {
+    getHighEntropyValues?(hints: string[]): Promise<UserAgentDataValues>;
+}
+declare const Platform: PlatformInstance;
+export default Platform;

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

@@ -0,0 +1,12 @@
+import type { NativePlugin } from "../../types";
+import { PlatformInstance } from "./types";
+import { Browsers, CrossPlatformFramework, Devices, Engines, OS } from "./constants";
+export * from "./types";
+declare const NativePlatformPlugin: NativePlugin<'Platform', PlatformInstance, {
+    OS: typeof OS;
+    Devices: typeof Devices;
+    Engines: typeof Engines;
+    Browsers: typeof Browsers;
+    CrossPlatformFramework: typeof CrossPlatformFramework;
+}, {}>;
+export default NativePlatformPlugin;

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

@@ -0,0 +1,11 @@
+export * from "./platform";
+import type { PlatformInstance } from "./platform";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Platform: PlatformInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/platform/types/platform.d.ts

@@ -0,0 +1,43 @@
+import { Browsers, CrossPlatformFramework, Devices, Engines, OS } from "../constants";
+export declare interface PlatformInstance {
+    os: NameVersionPair<OS>;
+    engine: NameVersionPair<Engines>;
+    browser: NameVersionPair<Browsers>;
+    device: Devices;
+    crossPlatformFramework: CrossPlatformFramework;
+    network: Network;
+    locale: Locale;
+    dimension: Dimension;
+    renderer: string;
+    userAgent: string;
+    readyState: 'loading' | 'complete';
+    isNode: boolean;
+    isStandalone: boolean;
+    isWebview: boolean;
+    onready(callback: (platform: PlatformInstance) => void): void;
+}
+export declare interface NameVersionPair<T> {
+    name: T;
+    version: string;
+}
+export declare interface Network {
+    isOnline: boolean | null;
+    effectiveType: 'slow-2g' | '2g' | '3g' | '4g' | null;
+    type: 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | null;
+    downlink: number | null;
+    rtt: number | null;
+    saveData: boolean | null;
+}
+export declare interface Dimension {
+    outerWidth: number;
+    outerHeight: number;
+    innerWidth: number;
+    innerHeight: number;
+    scale: number;
+}
+export declare interface Locale {
+    language: string;
+    languages: string[];
+    timezone: string;
+    timezoneOffset: number;
+}

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

@@ -0,0 +1,2 @@
+export declare const IS_IE_MOBILE: boolean;
+export declare const IS_WINDOWS_PHONE: boolean;

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

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

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

@@ -0,0 +1,5 @@
+import type { NativePlugin } from "../../types";
+import type { ThemeInstance } from "./types";
+export * from "./types";
+declare const NativeThemePlugin: NativePlugin<'Theme', ThemeInstance, {}, {}>;
+export default NativeThemePlugin;

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

@@ -0,0 +1,11 @@
+export * from "./theme";
+import type { ThemeInstance } from "./theme";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Theme: ThemeInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/theme/types/theme.d.ts

@@ -0,0 +1,4 @@
+export declare interface ThemeInstance {
+    get value(): string | undefined;
+    set value(color: string | undefined);
+}

package/dist/plugin/dimension/src/types/event-listener-util.d.ts

@@ -0,0 +1,11 @@
+export declare interface EventListenerUtil {
+    useStd: boolean;
+    add<T extends EventTarget | undefined, E extends Event = Event>(target: T, eventListenerOptions: EventListenerOptions<NonNullable<T>, E>): void;
+    remove<T extends EventTarget | undefined, E extends Event = Event>(target: T, eventListenerOptions: EventListenerOptions<NonNullable<T>, E>): void;
+    withVender(target: any, type?: string): string;
+}
+export declare interface EventListenerOptions<T extends EventTarget = EventTarget, E extends Event = Event> {
+    type?: string | undefined;
+    callback: ((this: T, event: E) => void) | EventListenerObject | null;
+    options?: AddEventListenerOptions | boolean;
+}

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

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

package/dist/plugin/dimension/src/types/native.d.ts

@@ -0,0 +1,27 @@
+import { PluginNotExtendedError } from "../errors/plugin-not-extended-error";
+export declare interface NativePlugins {
+}
+export declare interface NativeConstants extends Record<string, any> {
+}
+export declare interface NativeErrors extends Record<string, ErrorConstructor> {
+    PluginNotExtendedError: typeof PluginNotExtendedError;
+}
+export declare interface NativePlugin<Key extends string, Module, Constants extends Record<string, any> = Record<string, any>, Errors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>> {
+    installed: boolean;
+    name: Key;
+    module: Module;
+    Constants: Constants;
+    Errors: Errors;
+}
+export declare type ExtendedNativeBase<Key extends string, Module, Constants extends Record<string, any> = Record<string, any>, Errors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>> = NativeBase<NativePlugins & {
+    [Plugin in Key]: Module;
+}, NativeConstants & Constants, NativeErrors & Errors>;
+export declare type NativeBase<Plugins, AssignedConstants extends Record<string, any> = Record<string, any>, AssignedErrors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>> = {
+    Version: string;
+    Constants: AssignedConstants;
+    Errors: AssignedErrors;
+    extends: <Key extends string, Module, Constants extends Record<string, any> = Record<string, any>, Errors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>>(this: NativeBase<Plugins, AssignedConstants, AssignedErrors>, plugin: NativePlugin<Key, Module, Constants, Errors>) => NativeBase<Plugins & {
+        [Plugin in Key]: Module;
+    }, AssignedConstants & Constants, AssignedErrors & Errors>;
+} & NativePlugins;
+export type NativeInstance = NativeBase<NativePlugins, NativeConstants, NativeErrors>;

package/dist/plugin/dimension/src/utils/assign.d.ts

@@ -0,0 +1 @@
+export default function assign(...args: any[]): any;

package/dist/plugin/dimension/src/utils/compare-version.d.ts

@@ -0,0 +1 @@
+export default function compareVersion(lhs: string, rhs: string): -1 | 0 | 1;

package/dist/plugin/dimension/src/utils/create-custom-error.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface ErrorConstructor {
+        captureStackTrace?: (targetObject: object, constructorOpt?: Function) => void;
+    }
+}
+export default function createCustomError(name: string, Base?: ErrorConstructor): ErrorConstructor;

package/dist/plugin/dimension/src/utils/create-hidden-element.d.ts

@@ -0,0 +1 @@
+export default function createHiddenElement<K extends keyof HTMLElementTagNameMap>(tagName: K, focusable?: boolean): HTMLElementTagNameMap[K] | undefined;

package/dist/plugin/dimension/src/utils/dispatch-click-event.d.ts

@@ -0,0 +1 @@
+export default function dispatchClickEvent(element: HTMLElement, view?: WindowProxy): void;

package/dist/plugin/dimension/src/utils/event-listener-utils.d.ts

@@ -0,0 +1,3 @@
+import type { EventListenerUtil } from "../types/event-listener-util";
+declare const EventListenerUtils: EventListenerUtil;
+export default EventListenerUtils;

package/dist/plugin/dimension/src/utils/get-topmost-window.d.ts

@@ -0,0 +1 @@
+export default function getTopmostWindow(): WindowProxy;

package/dist/plugin/dimension/src/utils/is-secure-context.d.ts

@@ -0,0 +1 @@
+export default function isSecureContext(): boolean;