native-fn 1.0.26 → 1.0.28

package/dist/plugin/app/index.cjs

@@ -0,0 +1,1025 @@
+'use strict';
+
+var USER_AGENT = navigator.userAgent;
+
+var AppOpenState;
+(function (AppOpenState) {
+    AppOpenState[AppOpenState["Scheme"] = 0] = "Scheme";
+    AppOpenState[AppOpenState["Universal"] = 1] = "Universal";
+    AppOpenState[AppOpenState["Intent"] = 2] = "Intent";
+    AppOpenState[AppOpenState["Fallback"] = 3] = "Fallback";
+    AppOpenState[AppOpenState["Store"] = 4] = "Store";
+})(AppOpenState || (AppOpenState = {}));
+var Messengers;
+(function (Messengers) {
+    Messengers["Telephone"] = "telephone";
+    Messengers["Message"] = "message";
+    Messengers["Mail"] = "mail";
+})(Messengers || (Messengers = {}));
+var IS_SUPPORT_INTENT = !/firefox|opr/i.test(USER_AGENT);
+
+var OS;
+(function (OS) {
+    OS["Unknown"] = "Unknown";
+    OS["Android"] = "Android";
+    OS["iOS"] = "iOS";
+    OS["Windows"] = "Windows";
+    OS["MacOS"] = "MacOS";
+})(OS || (OS = {}));
+var Devices;
+(function (Devices) {
+    Devices["Unknown"] = "Unknown";
+    Devices["Mobile"] = "Mobile";
+    Devices["Desktop"] = "Desktop";
+})(Devices || (Devices = {}));
+var Engines;
+(function (Engines) {
+    Engines["Unknown"] = "Unknown";
+    Engines["EdgeHTML"] = "EdgeHTML";
+    Engines["ArkWeb"] = "ArkWeb";
+    Engines["Blink"] = "Blink";
+    Engines["Presto"] = "Presto";
+    Engines["WebKit"] = "WebKit";
+    Engines["Trident"] = "Trident";
+    Engines["NetFront"] = "NetFront";
+    Engines["KHTML"] = "KHTML";
+    Engines["Tasman"] = "Tasman";
+    Engines["Gecko"] = "Gecko";
+})(Engines || (Engines = {}));
+var OS_RESOLVER_MAP = (function () {
+    function resolveIOSOrMacVersion(str) {
+        if (str === undefined)
+            return '';
+        return str.replace(/_/g, '.');
+    }
+    function resolveWindowsVersion(str) {
+        if (str === undefined)
+            return '';
+        var mapped = {
+            '4.90': 'ME',
+            'NT3.51': 'NT 3.11',
+            'NT4.0': 'NT 4.0',
+            'NT 5.0': '2000',
+            'NT 5.1': 'XP',
+            'NT 5.2': 'XP',
+            'NT 6.0': 'Vista',
+            'NT 6.1': '7',
+            'NT 6.2': '8',
+            'NT 6.3': '8.1',
+            'NT 6.4': '10',
+            'NT 10.0': '10',
+            'ARM': 'RT'
+        }[str];
+        if (mapped !== undefined)
+            return mapped;
+        return str;
+    }
+    function resolveVersion(str) {
+        if (str === undefined)
+            return '';
+        return str;
+    }
+    return [
+        [/android\w*[-\/.; ]?([\d.]*)/i, OS.Android, Devices.Mobile, resolveVersion],
+        [/microsoft windows (vista|xp)/i, OS.Windows, Devices.Desktop, resolveVersion],
+        [/windows (?:phone(?: os)?|mobile|iot)[\/ ]?([.\w ]*)/i, OS.Windows, Devices.Desktop, resolveWindowsVersion],
+        [/windows nt 6\.2; (arm)/i, OS.Windows, Devices.Desktop, resolveWindowsVersion],
+        [/windows[\/ ]([ntce\d. ]+\w)(?!.+xbox)/i, OS.Windows, Devices.Desktop, resolveWindowsVersion],
+        [/(?:win(?=[39n])|win 9x )([nt\d.]+)/i, OS.Windows, Devices.Desktop, resolveWindowsVersion],
+        [/[adehimnop]{4,7}\b(?:.*os (\w+) like mac|; opera)/i, OS.iOS, Devices.Mobile, resolveIOSOrMacVersion],
+        [/(?:ios;fbsv\/|iphone.+ios[\/ ])([\d.]+)/i, OS.iOS, Devices.Mobile, resolveIOSOrMacVersion],
+        [/cfnetwork\/.+darwin/i, OS.iOS, Devices.Mobile, resolveVersion],
+        [/mac os x ?([\w. ]*)/i, OS.MacOS, Devices.Desktop, resolveIOSOrMacVersion],
+        [/(?:macintosh|mac_powerpc\b)(?!.+haiku)/i, OS.MacOS, Devices.Desktop, resolveIOSOrMacVersion],
+    ];
+})();
+var ENGINE_RESOLVER_MAP = [
+    [/windows.+ edge\/([\w.]+)/i, Engines.EdgeHTML],
+    [/arkweb\/([\w.]+)/i, Engines.ArkWeb],
+    [/webkit\/537\.36.+chrome\/(?!27)([\w.]+)/i, Engines.Blink],
+    [/presto\/([\w.]+)/i, Engines.Presto],
+    [/webkit\/([\w.]+)/i, Engines.WebKit],
+    [/trident\/([\w.]+)/i, Engines.Trident],
+    [/netfront\/([\w.]+)/i, Engines.NetFront],
+    [/khtml[\/ ]\(?([\w.]+)/i, Engines.KHTML],
+    [/tasman[\/ ]\(?([\w.]+)/i, Engines.Tasman],
+    [/rv:([\w.]{1,9})\b.+gecko/i, Engines.Gecko]
+];
+var OS_NAME = OS.Unknown;
+var OS_VERSION = '';
+var DEVICE_NAME = Devices.Unknown;
+Engines.Unknown;
+for (var i = 0; i < OS_RESOLVER_MAP.length; i++) {
+    var map = OS_RESOLVER_MAP[i];
+    var regexp = map[0];
+    var os = map[1];
+    var device = map[2];
+    var resolver = map[3];
+    var matched = USER_AGENT.match(regexp);
+    if (matched !== null) {
+        OS_NAME = os;
+        OS_VERSION = resolver(matched[1]);
+        DEVICE_NAME = device;
+        break;
+    }
+}
+for (var i = 0; i < ENGINE_RESOLVER_MAP.length; i++) {
+    var map = ENGINE_RESOLVER_MAP[i];
+    var regexp = map[0];
+    map[1];
+    var matched = USER_AGENT.match(regexp);
+    if (matched !== null) {
+        matched[1];
+        break;
+    }
+}
+((function () {
+    var canvas = document.createElement('canvas');
+    if (typeof canvas.getContext !== 'function')
+        return '';
+    var context = canvas.getContext('webgl2') || canvas.getContext('experimental-webgl') || canvas.getContext('webgl');
+    if (context === null)
+        return '';
+    if (context instanceof WebGLRenderingContext || 'getParameter' in context && typeof context.getParameter === 'function') {
+        var extension = context.getExtension('WEBGL_debug_renderer_info');
+        if (extension === null)
+            return context.getParameter(context.RENDERER);
+        else
+            return context.getParameter(extension.UNMASKED_RENDERER_WEBGL);
+    }
+    else {
+        return '';
+    }
+}))();
+DEVICE_NAME === Devices.Mobile;
+DEVICE_NAME === Devices.Desktop;
+((function () {
+    if (OS_NAME === OS.iOS)
+        return 'standalone' in navigator && navigator.standalone;
+    else
+        return window.matchMedia('(display-mode: standalone)').matches;
+}))();
+
+function capitalize(match) {
+    var groups = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        groups[_i - 1] = arguments[_i];
+    }
+    var result = '';
+    for (var i = 0; i < groups.length - 2; i++) {
+        var arg = groups[i];
+        if (arg !== undefined)
+            result = result + arg.charAt(0).toUpperCase() + arg.slice(1);
+    }
+    return result;
+}
+function preventDefaultPolyfill() {
+    this.returnValue = false;
+}
+function stopPropagationPolyfill() {
+    this.cancelBubble = true;
+}
+var EventListenerUtils = {
+    useStd: typeof document !== 'undefined' && typeof document.addEventListener === 'function',
+    add: function (target, eventListenerOptions) {
+        if (eventListenerOptions === void 0) { eventListenerOptions = { callback: null, options: false }; }
+        var callback = eventListenerOptions.callback;
+        if (target === undefined || callback === null)
+            return;
+        var type = this.withVender(target, eventListenerOptions.type);
+        var options = eventListenerOptions.options;
+        if (typeof target.addEventListener === 'function') {
+            try {
+                return target.addEventListener(type, callback, options);
+            }
+            catch (_) {
+            }
+        }
+        if (typeof target.addListener === 'function') {
+            if (typeof target.matches === 'boolean') {
+                try {
+                    return target.addListener(callback);
+                }
+                catch (_) {
+                }
+            }
+            else {
+                try {
+                    return target.addListener(type, callback);
+                }
+                catch (_) {
+                }
+            }
+        }
+        function wrapper(event) {
+            if (event === undefined)
+                event = window.event;
+            if (event === undefined)
+                return;
+            event.currentTarget = target;
+            if (typeof event.preventDefault !== 'function')
+                event.preventDefault = preventDefaultPolyfill;
+            if (typeof event.stopPropagation !== 'function')
+                event.stopPropagation = stopPropagationPolyfill;
+            if (typeof callback === 'function')
+                callback.call(target, event);
+            else if (callback && typeof callback.handleEvent === 'function')
+                callback.handleEvent.call(target, event);
+        }
+        if (typeof target.attachEvent === 'function') {
+            if (callback.__ieWrapper)
+                return target.attachEvent('on' + type, callback.__ieWrapper);
+            return target.attachEvent('on' + type, callback.__ieWrapper = wrapper);
+        }
+    },
+    remove: function (target, eventListenerOptions) {
+        if (eventListenerOptions === void 0) { eventListenerOptions = { callback: null, options: false }; }
+        var callback = eventListenerOptions.callback;
+        if (target === undefined || callback === null)
+            return;
+        var type = this.withVender(target, eventListenerOptions.type);
+        var options = eventListenerOptions.options;
+        if (typeof target.removeEventListener === 'function') {
+            try {
+                return target.removeEventListener(type, callback, options);
+            }
+            catch (_) {
+            }
+        }
+        if (typeof target.removeListener === 'function') {
+            if (typeof target.matches === 'boolean') {
+                try {
+                    return target.removeListener(callback);
+                }
+                catch (_) {
+                }
+            }
+            else {
+                try {
+                    return target.removeListener(type, callback);
+                }
+                catch (_) {
+                }
+            }
+        }
+        if (typeof target.detachEvent === 'function') {
+            var wrapper = callback.__ieWrapper;
+            if (wrapper !== undefined) {
+                target.detachEvent('on' + type, wrapper);
+                delete callback.__ieWrapper;
+            }
+            return;
+        }
+    },
+    withVender: function (target, type) {
+        if (type === undefined)
+            return '';
+        var regex = /(animation)(start|iteration|end|cancel)|(transition)(start|run|end|cancel)|(fullscreen)(change|error)|(lost|got)(pointer)(capture)|(pointer)(lock)(change|error)|(pointer)(cancel|down|enter|leave|move|out|over|up)/i;
+        var vendors = ['', 'webkit', 'moz', 'ms', 'MS', 'o', 'O'];
+        var types;
+        if (type === 'wheel')
+            types = ['wheel', 'mousewheel', 'DOMMouseScroll'];
+        else if (type === 'focus')
+            types = ['focus', 'focusin'];
+        else if (type === 'blur')
+            types = ['blur', 'focusout'];
+        else if (regex.test(type))
+            types = [type, type.replace(regex, capitalize)];
+        else
+            types = [type];
+        for (var i = 0; i < vendors.length; i++) {
+            for (var j = 0; j < types.length; j++) {
+                var name_1 = vendors[i] + types[j];
+                if (typeof target['on' + name_1] !== 'undefined')
+                    return name_1;
+            }
+        }
+        return '';
+    }
+};
+
+function getTopmostWindow() {
+    try {
+        if (window.top && window.top !== window) {
+            void window.top.location.href;
+            return window.top;
+        }
+    }
+    catch (_) {
+    }
+    return window;
+}
+function openURLViaHref(url, index) {
+    var top = getTopmostWindow();
+    var a = undefined;
+    try {
+        if (index === 0) {
+            top.location.href = url;
+            return;
+        }
+        a = top.document.createElement('a');
+        a.href = url;
+        a.setAttribute('aria-hidden', 'true');
+        a.style.display = 'none';
+        top.document.body.appendChild(a);
+        var fake = void 0;
+        try {
+            fake = new MouseEvent('click', {
+                bubbles: true,
+                cancelable: true,
+                view: top
+            });
+        }
+        catch (_) {
+            fake = top.document.createEvent('MouseEvents');
+            fake.initMouseEvent('click', true, true, top, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+        }
+        a.dispatchEvent(fake);
+    }
+    catch (_) {
+    }
+    finally {
+        if (a !== undefined) {
+            try {
+                top.document.body.removeChild(a);
+            }
+            catch (_) {
+            }
+        }
+    }
+}
+function openURLViaIframe(url) {
+    var top = getTopmostWindow();
+    var iframe = undefined;
+    try {
+        iframe = document.createElement('iframe');
+        iframe.src = url;
+        iframe.width = iframe.height = iframe.frameBorder = '0';
+        iframe.setAttribute('aria-hidden', 'true');
+        iframe.style.display = 'none';
+        iframe.style.position = 'absolute';
+        iframe.style.top = '-9999px';
+        iframe.style.left = '-9999px';
+        top.document.body.appendChild(iframe);
+        window.setTimeout(function () {
+            if (iframe !== undefined) {
+                try {
+                    top.document.body.removeChild(iframe);
+                }
+                catch (_) {
+                }
+            }
+        }, 500);
+    }
+    catch (_) {
+    }
+}
+function isDocumentHidden() {
+    var document = getTopmostWindow().document;
+    if (document.visibilityState === 'hidden')
+        return true;
+    if (document.webkitVisibilityState === 'hidden')
+        return true;
+    if (document.mozVisibilityState === 'hidden')
+        return true;
+    if (document.msVisibilityState === 'hidden')
+        return true;
+    if (document.hidden !== undefined)
+        return document.hidden;
+    if (document.webkitHidden !== undefined)
+        return document.webkitHidden;
+    if (document.mozHidden !== undefined)
+        return document.mozHidden;
+    if (document.msHidden !== undefined)
+        return document.msHidden;
+    if (typeof document.hasFocus === 'function')
+        return !document.hasFocus();
+    return true;
+}
+function hasFocus(document) {
+    if (typeof document.hasFocus === 'function')
+        return document.hasFocus();
+    return false;
+}
+function focus(target) {
+    try {
+        target.focus({ preventScroll: true });
+    }
+    catch (_) {
+        try {
+            target.focus();
+        }
+        catch (_) {
+        }
+    }
+}
+function restoreFocus() {
+    var top = getTopmostWindow();
+    var document = top.document;
+    focus(top);
+    if (hasFocus(document))
+        return true;
+    if (document.body.tabIndex < 0) {
+        document.body.tabIndex = -1;
+    }
+    focus(document.body);
+    if (hasFocus(document))
+        return true;
+    var input = undefined;
+    try {
+        input = document.createElement('input');
+        input.type = 'text';
+        input.readOnly = true;
+        input.tabIndex = -1;
+        input.setAttribute('aria-hidden', 'true');
+        input.style.position = 'fixed';
+        input.style.width = input.style.height = '1px';
+        input.style.top = input.style.left = '0';
+        input.style.opacity = '0';
+        input.style.zIndex = '-1';
+        document.body.appendChild(input);
+        focus(input);
+        try {
+            input.select();
+        }
+        catch (_) {
+        }
+        if (hasFocus(document))
+            return true;
+    }
+    catch (_) {
+    }
+    finally {
+        if (input !== undefined) {
+            try {
+                input.blur();
+            }
+            catch (_) {
+            }
+            try {
+                document.body.removeChild(input);
+            }
+            catch (_) {
+            }
+        }
+    }
+    return hasFocus(document);
+}
+function tryOpenUrl(url, index, timeout) {
+    var top = getTopmostWindow();
+    var document = top.document;
+    var eventType = { focus: undefined, blur: undefined, visibilitychange: undefined };
+    var eventTarget = { focus: undefined, blur: undefined, visibilitychange: undefined };
+    if (OS_NAME === OS.iOS) {
+        if (parseInt(OS_VERSION) >= 8) {
+            eventTarget = { visibilitychange: document };
+            eventType = { visibilitychange: 'visibilitychange' };
+        }
+        else {
+            eventTarget = { focus: top, blur: top };
+            eventType = { focus: 'pageshow', blur: 'pagehide' };
+        }
+    }
+    else {
+        if (EventListenerUtils.useStd) {
+            eventTarget = { focus: top, blur: top, visibilitychange: document };
+            eventType = { focus: 'focus', blur: 'blur', visibilitychange: 'visibilitychange' };
+        }
+        else {
+            eventTarget = { focus: document, blur: document, visibilitychange: document };
+            eventType = { focus: 'focus', blur: 'blur', visibilitychange: 'visibilitychange' };
+        }
+    }
+    return new Promise(function (resolve, reject) {
+        var timeoutId;
+        var resolved = false;
+        function cleanup() {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+            }
+            try {
+                EventListenerUtils.remove(eventTarget.blur, { type: eventType.blur, callback: onBlur });
+                EventListenerUtils.remove(eventTarget.focus, { type: eventType.focus, callback: onFocus });
+                EventListenerUtils.remove(eventTarget.visibilitychange, { type: eventType.visibilitychange, callback: onVisibilityChange });
+            }
+            catch (_) {
+            }
+        }
+        function done(success) {
+            if (resolved)
+                return;
+            resolved = true;
+            try {
+                cleanup();
+                if (success)
+                    resolve();
+                else
+                    reject();
+            }
+            catch (_) {
+                resolve();
+            }
+        }
+        function onBlur() {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+            }
+            EventListenerUtils.remove(eventTarget.blur, { type: eventType.blur, callback: onBlur });
+            EventListenerUtils.add(eventTarget.focus, { type: eventType.focus, callback: onFocus });
+        }
+        function onFocus() {
+            done(true);
+        }
+        function onVisibilityChange() {
+            if (isDocumentHidden())
+                done(true);
+        }
+        timeoutId = window.setTimeout(function () {
+            done(false);
+        }, timeout);
+        EventListenerUtils.add(eventTarget.blur, { type: eventType.blur, callback: onBlur });
+        EventListenerUtils.add(eventTarget.visibilitychange, { type: eventType.visibilitychange, callback: onVisibilityChange });
+        if (!hasFocus(document))
+            restoreFocus();
+        try {
+            openURLViaHref(url, index);
+            openURLViaIframe(url);
+        }
+        catch (_) {
+            done(false);
+        }
+    });
+}
+
+function createCustomError(name, Base) {
+    if (Base === void 0) { Base = Error; }
+    function CustomError(message) {
+        if (!(this instanceof CustomError))
+            return new CustomError(message);
+        var error = new Base(message || '');
+        if (typeof Object.setPrototypeOf === 'function')
+            Object.setPrototypeOf(error, CustomError.prototype);
+        else
+            error.__proto__ = CustomError.prototype;
+        error.name = name;
+        if (message !== undefined)
+            error.message = message;
+        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+            try {
+                Object.defineProperty(error, Symbol.toStringTag, {
+                    value: name,
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            catch (_) {
+            }
+        }
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(error, CustomError);
+        }
+        else if (Base.captureStackTrace && typeof Base.captureStackTrace === 'function') {
+            Base.captureStackTrace(error, CustomError);
+        }
+        else {
+            try {
+                var tempError = new Base();
+                if (tempError.stack)
+                    error.stack = tempError.stack;
+            }
+            catch (_) {
+            }
+        }
+        return error;
+    }
+    CustomError.prototype = Object.create(Base.prototype, {
+        constructor: {
+            value: CustomError,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        }
+    });
+    try {
+        Object.defineProperty(CustomError.prototype, 'name', {
+            value: name,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+        try {
+            CustomError.prototype.name = name;
+        }
+        catch (_) {
+        }
+    }
+    try {
+        Object.defineProperty(CustomError, 'name', {
+            value: name,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+    }
+    return CustomError;
+}
+
+var URLOpenError = createCustomError('URLOpenError');
+
+var _a;
+var App = {
+    open: open,
+    messenger: (_a = {},
+        _a[Messengers.Telephone] = openMessengerTelephone,
+        _a[Messengers.Message] = openMessengerMessage,
+        _a[Messengers.Mail] = openMessengerMail,
+        _a),
+};
+function getTrackId(bundle) {
+    try {
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET', 'https://itunes.apple.com/lookup?bundleId=' + bundle, false);
+        xhr.send();
+        if (xhr.status === 200) {
+            try {
+                var response = JSON.parse(xhr.response);
+                if (response.results === undefined)
+                    return undefined;
+                var results = response.results;
+                if (!Array.isArray(results) || results.length === 0)
+                    return undefined;
+                var result = results[0];
+                if (result === undefined)
+                    return undefined;
+                return result.trackId;
+            }
+            catch (_) {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function createIntentURL(scheme, packageName, fallback) {
+    var split = scheme.split('://');
+    var prefix = split[0];
+    var suffix = split[1];
+    var intent = 'intent://';
+    if (suffix !== undefined)
+        intent = intent + suffix;
+    intent = intent + '#Intent;'
+        + 'scheme=' + prefix + ';'
+        + 'action=android.intent.action.VIEW;'
+        + 'category=android.intent.category.BROWSABLE;';
+    if (packageName !== undefined)
+        intent = intent + 'package=' + packageName + ';';
+    if (fallback !== undefined && typeof fallback === 'string')
+        intent = intent + 'S.browser_fallback_url=' + fallback + ';';
+    else if (packageName !== undefined)
+        intent = intent + 'S.browser_fallback_url=' + createAppStoreURL(packageName, OS.Android) + ';';
+    return intent + 'end';
+}
+function parseIntentURL(intent) {
+    var parsed = {};
+    var split = intent.split('#Intent;');
+    var host = split[0].substring(9);
+    var suffix = split[1];
+    var parameterString = suffix.substring(0, suffix.length - 4);
+    var parameters = parameterString.split(';');
+    var extras = {};
+    for (var i = 0; i < parameters.length; i++) {
+        var part = parameters[i];
+        var index = part.indexOf('=');
+        if (index !== -1)
+            extras[part.substring(0, index)] = part.substring(index + 1);
+    }
+    if (extras['scheme'] !== undefined)
+        parsed.scheme = (extras['scheme'] + '://' + host);
+    if (extras['package'] !== undefined)
+        parsed.packageName = extras['package'];
+    if (extras['S.browser_fallback_url'] !== undefined)
+        parsed.fallback = extras['S.browser_fallback_url'];
+    return parsed;
+}
+function createAppStoreURL(packageName, os) {
+    switch (os) {
+        case OS.Android: return 'market://details?id=' + packageName;
+        case OS.iOS: return 'itms-apps://itunes.apple.com/app/id' + packageName + '?mt=8';
+        case OS.Windows: return 'ms-windows-store://pdp/?ProductId=' + packageName;
+        case OS.MacOS: return 'macappstore://itunes.apple.com/app/id' + packageName + '?mt=12';
+        default: throw new URLOpenError('Unsupported OS: \"' + USER_AGENT + '\"');
+    }
+}
+function createWebStoreURL(packageName, os) {
+    switch (os) {
+        case OS.Android: return 'https://play.google.com/store/apps/details?id=' + packageName;
+        case OS.iOS: return 'https://itunes.apple.com/app/id' + packageName + '?mt=8';
+        case OS.Windows: return 'https://apps.microsoft.com/detail/' + packageName;
+        case OS.MacOS: return 'https://apps.apple.com/app/id' + packageName + '?mt=12';
+        default: throw new URLOpenError('Unsupported OS: \"' + USER_AGENT + '\"');
+    }
+}
+function getDefaultTimeoutByOS(os) {
+    switch (os) {
+        case OS.iOS: return 2000;
+        case OS.Android: return 1000;
+        default: return 750;
+    }
+}
+function open(options) {
+    var os = OS_NAME;
+    var urls = [];
+    var tried = [];
+    var timeout;
+    function getURLOpenError() {
+        var triedUrlString = '';
+        for (var i = 0; i < urls.length; i++)
+            triedUrlString += '\n' + (i + 1) + ': ' + tried[i];
+        if (triedUrlString.length > 0)
+            triedUrlString = '\n' + triedUrlString + '\n';
+        return new URLOpenError('Failed to open any of the provided URLs: ' + triedUrlString);
+    }
+    if (os === OS.Android) {
+        var option = options[OS.Android];
+        if (option === undefined)
+            return Promise.reject(getURLOpenError());
+        timeout = option.timeout;
+        var scheme = urlToString(option.scheme);
+        var intent = urlToString(option.intent);
+        var packageName = option.packageName;
+        var fallback = urlToString(option.fallback);
+        var allowWebStore = option.allowWebStore;
+        if (intent !== undefined && (scheme === undefined || packageName === undefined || fallback === undefined)) {
+            var parsed = parseIntentURL(intent);
+            if (parsed.scheme !== undefined && scheme === undefined)
+                scheme = parsed.scheme;
+            if (parsed.packageName !== undefined && packageName === undefined)
+                packageName = parsed.packageName;
+            if (parsed.fallback !== undefined && fallback === undefined)
+                fallback = parsed.fallback;
+        }
+        if (scheme !== undefined && intent === undefined)
+            intent = createIntentURL(scheme, packageName, fallback);
+        if (intent !== undefined && IS_SUPPORT_INTENT)
+            urls.push([intent, AppOpenState.Intent]);
+        if (scheme !== undefined)
+            urls.push([scheme, AppOpenState.Scheme]);
+        if (fallback !== undefined)
+            urls.push([fallback, AppOpenState.Fallback]);
+        if (packageName !== undefined)
+            urls.push([createAppStoreURL(packageName, OS.Android), AppOpenState.Store]);
+        if (packageName !== undefined && allowWebStore === true)
+            urls.push([createWebStoreURL(packageName, OS.Android), AppOpenState.Store]);
+    }
+    else if (os === OS.iOS) {
+        var option = options[OS.iOS];
+        if (option === undefined)
+            return Promise.reject(getURLOpenError());
+        timeout = option.timeout;
+        var scheme = urlToString(option.scheme);
+        var packageName = option.bundleId;
+        var trackId = option.trackId;
+        var universal = urlToString(option.universal);
+        var fallback = urlToString(option.fallback);
+        var allowWebStore = option.allowWebStore;
+        if (packageName !== undefined && trackId === undefined)
+            trackId = getTrackId(packageName);
+        if (universal !== undefined && parseInt(OS_VERSION) >= 9)
+            urls.push([universal, AppOpenState.Universal]);
+        if (scheme !== undefined)
+            urls.push([scheme, AppOpenState.Scheme]);
+        if (fallback !== undefined)
+            urls.push([fallback, AppOpenState.Fallback]);
+        if (trackId !== undefined)
+            urls.push([createAppStoreURL(trackId, OS.iOS), AppOpenState.Store]);
+        if (trackId !== undefined && allowWebStore === true)
+            urls.push([createWebStoreURL(trackId, OS.iOS), AppOpenState.Store]);
+    }
+    else if (os === OS.Windows) {
+        var option = options[OS.Windows];
+        if (option === undefined)
+            return Promise.reject(getURLOpenError());
+        timeout = option.timeout;
+        var scheme = urlToString(option.scheme);
+        var productId = option.productId;
+        var fallback = urlToString(option.fallback);
+        var allowWebStore = option.allowWebStore;
+        if (scheme !== undefined)
+            urls.push([scheme, AppOpenState.Scheme]);
+        if (fallback !== undefined)
+            urls.push([fallback, AppOpenState.Fallback]);
+        if (productId !== undefined)
+            urls.push([createAppStoreURL(productId, OS.Windows), AppOpenState.Store]);
+        if (productId !== undefined && allowWebStore === true)
+            urls.push([createWebStoreURL(productId, OS.Windows), AppOpenState.Store]);
+    }
+    else if (os === OS.MacOS) {
+        var option = options[OS.MacOS];
+        if (option === undefined)
+            return Promise.reject(getURLOpenError());
+        timeout = option.timeout;
+        var scheme = urlToString(option.scheme);
+        var packageName = option.bundleId;
+        var trackId = option.trackId;
+        var fallback = urlToString(option.fallback);
+        var allowWebStore = option.allowWebStore;
+        if (packageName !== undefined && trackId === undefined)
+            trackId = getTrackId(packageName);
+        if (scheme !== undefined)
+            urls.push([scheme, AppOpenState.Scheme]);
+        if (fallback !== undefined)
+            urls.push([fallback, AppOpenState.Fallback]);
+        if (trackId !== undefined)
+            urls.push([createAppStoreURL(trackId, OS.MacOS), AppOpenState.Store]);
+        if (trackId !== undefined && allowWebStore === true)
+            urls.push([createWebStoreURL(trackId, OS.MacOS), AppOpenState.Store]);
+    }
+    if (timeout === undefined)
+        timeout = getDefaultTimeoutByOS(os);
+    return new Promise(function (resolve, reject) {
+        function openURLSequential(index) {
+            if (index === void 0) { index = 0; }
+            if (index >= urls.length)
+                return reject(getURLOpenError());
+            var entry = urls[index];
+            var url = entry[0];
+            if (typeof url === 'string') {
+                tried[index] = url;
+                return tryOpenUrl(url, index, timeout)
+                    .then(function () {
+                    resolve(entry[1]);
+                })
+                    .catch(function () {
+                    openURLSequential(index + 1);
+                });
+            }
+            else {
+                tried[index] = '[function fallback]';
+                url();
+                resolve(entry[1]);
+            }
+        }
+        return openURLSequential();
+    });
+}
+function isArrayLike(value) {
+    if (value == null || typeof value === 'string')
+        return false;
+    var length = value.length;
+    return typeof length === 'number' && length >= 0 && !(length % 1);
+}
+function joining(values, mapfn, separator) {
+    if (separator === void 0) { separator = ','; }
+    var length = values.length;
+    var result = '';
+    for (var i = 0; i < length; i++) {
+        result = result + mapfn(values[i]);
+        if (i !== length - 1)
+            result = result + separator;
+    }
+    return result;
+}
+function encode(value) {
+    return encodeURIComponent(value)
+        .replace(/[!'()*]/g, function (c) {
+        return '%' + c.charCodeAt(0).toString(16);
+    });
+}
+function urlToString(value) {
+    if (value instanceof URL)
+        return value.toString();
+    return value;
+}
+function stringifiableToString(value) {
+    if (typeof value === 'string')
+        return encode(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return encode(String(value));
+    if (value == null)
+        return '';
+    if (isArrayLike(value))
+        return joining(value, function (v) {
+            return stringifiableToString(v);
+        });
+    if (value instanceof HTMLInputElement) {
+        var type = value.type;
+        if (type === 'checkbox') {
+            return encode(value.checked.toString());
+        }
+        else if (type === 'radio') {
+            if (value.checked)
+                return encode(value.value);
+            else
+                return '';
+        }
+        else if (type === 'file') {
+            var files = value.files;
+            if (files === null)
+                return '';
+            return joining(files, function (file) {
+                return encode(file.name);
+            });
+        }
+        else {
+            return encode(value.value);
+        }
+    }
+    if (value instanceof HTMLSelectElement) {
+        if (value.multiple)
+            return joining(value.selectedOptions, function (option) {
+                return encode(option.value);
+            });
+        return encode(value.value);
+    }
+    if (value instanceof HTMLTextAreaElement)
+        return encode(value.value);
+    if (value instanceof HTMLElement)
+        return encode(value.innerText);
+    if (value instanceof Node)
+        return stringifiableToString(value.textContent);
+    return encode(value.toString());
+}
+function normalize(value) {
+    if (value instanceof HTMLFormElement)
+        return normalize(new FormData(value));
+    if (value instanceof FormData) {
+        var result_1 = {};
+        value.forEach(function (value, key) {
+            var name;
+            if (value instanceof File)
+                name = value.name;
+            else
+                name = value;
+            if (Object.prototype.hasOwnProperty.call(result_1, key)) {
+                var prev = result_1[key];
+                if (Array.isArray(prev))
+                    prev.push(name);
+                else
+                    result_1[key] = [prev, name];
+            }
+            else {
+                result_1[key] = name;
+            }
+        });
+        return normalize(result_1);
+    }
+    var result = {};
+    var keys = Object.keys(value);
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        result[key] = stringifiableToString(value[key]);
+    }
+    if (result.to === undefined)
+        result.to = '';
+    if (result.cc === undefined)
+        result.cc = '';
+    if (result.bcc === undefined)
+        result.bcc = '';
+    if (result.subject === undefined)
+        result.subject = '';
+    if (result.body === undefined)
+        result.body = '';
+    return result;
+}
+function openMessenger(options, type) {
+    options = normalize(options);
+    return tryOpenUrl(type + ':' + options.to
+        + '?cc=' + options.cc
+        + '&bcc=' + options.bcc
+        + '&subject=' + options.subject
+        + '&body=' + options.body, 0, getDefaultTimeoutByOS(OS_NAME));
+}
+function openMessengerTelephone(options) {
+    return openMessenger(options, 'tel');
+}
+function openMessengerMessage(options) {
+    return openMessenger(options, 'sms');
+}
+function openMessengerMail(options) {
+    return openMessenger(options, 'mailto');
+}
+
+var AppPlugin = {
+    installed: false,
+    name: 'App',
+    module: App,
+    constants: {
+        AppOpenState: AppOpenState,
+        Messengers: Messengers
+    },
+    errors: {
+        URLOpenError: URLOpenError
+    }
+};
+
+module.exports = AppPlugin;