first commit

node_modules/@vkontakte/vk-bridge/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+
+Copyright (c) 2017-present, V Kontakte, LLC.
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@vkontakte/vk-bridge/README.md

@@ -0,0 +1,200 @@
+# VK Bridge Core
+
+## Usage
+
+```js
+import bridge from '@vkontakte/vk-bridge';
+
+// Sends event to client
+bridge.send('VKWebAppInit');
+
+// Subscribes to event, sended by client
+bridge.subscribe((e) => console.log(e));
+```
+
+For use in a browser, include the file [`dist/browser.min.js`](https://unpkg.com/@vkontakte/vk-bridge/dist/browser.min.js) and use as follows
+
+```html
+<script src="https://unpkg.com/@vkontakte/vk-bridge/dist/browser.min.js"></script>
+
+<script>
+  // Sends event to client
+  vkBridge.send('VKWebAppInit');
+</script>
+```
+
+## API Reference
+
+### `bridge.send(method[, params])`
+
+Sends a message to native client and returns the `Promise` object with response data
+
+**Parameters**
+
+- `method` _required_ The VK Bridge method
+- `params` _optional_ Message data object
+
+**Example**
+
+```js
+// Sending event to client
+bridge
+  .send('VKWebAppGetEmail')
+  .then((data) => {
+    // Handling received data
+    console.log(data.email);
+  })
+  .catch((error) => {
+    // Handling an error
+  });
+```
+
+You can also use imperative way
+
+```js
+try {
+  const data = await bridge.send('VKWebAppGetEmail');
+
+  // Handling received data
+  console.log(data.email);
+} catch (error) {
+  // Handling an error
+}
+```
+
+### `bridge.subscribe(fn)`
+
+Subscribes a function to events listening
+
+**Parameters**
+
+- `fn` _required_ Function to be subscribed to events
+
+**Example**
+
+```js
+// Subscribing to receiving events
+bridge.subscribe((event) => {
+  if (!event.detail) {
+    return;
+  }
+
+  const { type, data } = event.detail;
+
+  if (type === 'VKWebAppOpenCodeReaderResult') {
+    // Reading result of the Code Reader
+    console.log(data.code_data);
+  }
+
+  if (type === 'VKWebAppOpenCodeReaderFailed') {
+    // Catching the error
+    console.log(data.error_type, data.error_data);
+  }
+});
+
+// Sending method
+bridge.send('VKWebAppOpenCodeReader', {});
+```
+
+### `bridge.unsubscribe(fn)`
+
+Unsubscribes a function from events listening
+
+**Parameters**
+
+- `fn` _required_ Event subscribed function
+
+**Example**
+
+```js
+const fn = (event) => {
+  // ...
+};
+
+// Subscribing
+bridge.subscribe(fn);
+
+// Unsubscribing
+bridge.unsubscribe(fn);
+```
+
+### `bridge.supports(method)`
+
+Checks if an event is available on the current device
+
+**Parameters**
+
+- `method` _required_ The VK Bridge method
+
+### `bridge.isWebView()`
+
+Returns `true` if VK Bridge is running in mobile app, or `false` if not
+
+### `bridge.isIframe()`
+
+Returns `true` if VK Bridge is running in iframe, or `false` if not
+
+### `bridge.isEmbedded()`
+
+Returns `true` if VK Bridge is running in embedded app, or `false` if not
+
+### `bridge.isStandalone()`
+
+Returns `true` if VK Bridge is running in standalone app, or `false` if not
+
+## Middleware API
+
+_Middlewares_ are pieces of code that intercept and process data between sending and receiving. Thus, by creating middlewares, you can easily log data, modify data before sending it, talking to an asynchronous API, etc. If you've used Redux, you were also probably already familiar with the concept—a similar is used here.
+
+### `applyMiddleware(middleware1, ..., middlewareN)`
+
+Creates the VK Bridge enhancer that applies middleware to the `send`
+method. This is handy for a variety of task such as logging every sent
+event. Returns the VK Bridge enhancer applying the middleware.
+
+**Parameters**
+
+- `middlewareN` A middleware to be applied
+
+**Example**
+
+```js
+import bridge, { applyMiddleware } from '@vkontakte/vk-bridge';
+
+// Logs the result of each sent event
+const logger =
+  ({ send, subscribe }) =>
+  (next) =>
+  async (method, props) => {
+    const result = await next(method, props);
+    console.log(result);
+    return result;
+  };
+
+const enhancedBridge = applyMiddleware(logger)(bridge);
+```
+
+## Functions
+
+### `parseURLSearchParamsForGetLaunchParams(urlSearchParams: string)`
+
+Parse URL search params for get provided to mini app [launch params](https://dev.vk.ru/mini-apps/development/launch-params).
+
+**Parameters**
+
+- `urlSearchParams` a.k.a `window.location.search`.
+
+**Example**
+
+```js
+import { parseURLSearchParamsForGetLaunchParams } from '@vkontakte/vk-bridge';
+
+// https://exmample-mini-app.io/?vk_platform=desktop_web&vk_is_app_user=1&vk_user_id=12345
+const { vk_platform, vk_viewer_group_role, vk_user_id } = parseURLSearchParamsForGetLaunchParams(
+  window.location.search,
+);
+
+console.log(vk_platform); // 'desktop_web'
+console.log(vk_is_app_user); // 1
+console.log(vk_user_id); // 12345
+```

node_modules/@vkontakte/vk-bridge/dist/index.es.js

@@ -0,0 +1,715 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+/**
+ * Creates counter interface.
+ */
+function createCounter() {
+    return {
+        current: 0,
+        next: function () {
+            return ++this.current;
+        },
+    };
+}
+/**
+ * Creates interface for resolving request promises by request id's (or not).
+ *
+ * @param instanceId Uniq bridge instance ID.
+ */
+function createRequestResolver(instanceId) {
+    var counter = createCounter();
+    var promiseControllers = {};
+    return {
+        /**
+         * Adds new controller with resolve/reject methods.
+         *
+         * @param controller Object with `resolve` and `reject` functions
+         * @param customId Custom `request_id`
+         * @returns New request id of the added controller.
+         */
+        add: function (controller, customId) {
+            var id = customId != null ? customId : "".concat(counter.next(), "_").concat(instanceId);
+            promiseControllers[id] = controller;
+            return id;
+        },
+        /**
+         * Resolves/rejects an added promise by request id and the `isSuccess`
+         * predicate.
+         *
+         * @param requestId Request ID.
+         * @param data Data to pass to the resolve- or reject-function.
+         * @param isSuccess Predicate to select the desired function.
+         */
+        resolve: function (requestId, data, isSuccess) {
+            var requestPromise = promiseControllers[requestId];
+            if (requestPromise) {
+                if (isSuccess(data)) {
+                    requestPromise.resolve(data);
+                }
+                else {
+                    requestPromise.reject(data);
+                }
+                promiseControllers[requestId] = null;
+            }
+        },
+    };
+}
+/**
+ * Returns send function that returns promises.
+ *
+ * @param sendEvent Send event function.
+ * @param subscribe Subscribe event function.
+ * @param instanceId Uniq bridge instance ID.
+ * @returns Send function which returns the Promise object.
+ */
+function promisifySend(sendEvent, subscribe, instanceId) {
+    var requestResolver = createRequestResolver(instanceId);
+    // Subscribe to receive a data
+    subscribe(function (event) {
+        if (!event.detail || !event.detail.data || typeof event.detail.data !== 'object') {
+            return;
+        }
+        // There is no request_id in receive-only events, so we check its existence.
+        if ('request_id' in event.detail.data) {
+            var _a = event.detail.data, requestId = _a.request_id, data = __rest(_a, ["request_id"]);
+            if (requestId) {
+                requestResolver.resolve(requestId, data, function (data) { return !('error_type' in data); });
+            }
+        }
+    });
+    return function promisifiedSend(method, props) {
+        if (props === void 0) { props = {}; }
+        return new Promise(function (resolve, reject) {
+            var requestId = requestResolver.add({ resolve: resolve, reject: reject }, props.request_id);
+            sendEvent(method, __assign(__assign({}, props), { request_id: requestId }));
+        });
+    };
+}
+
+function createInstanceId() {
+    var allNumbersAndLetters = 36;
+    var positionAfterZeroAnDot = 2;
+    var keyLength = 3;
+    return Math.random()
+        .toString(allNumbersAndLetters)
+        .substring(positionAfterZeroAnDot, positionAfterZeroAnDot + keyLength);
+}
+
+/** Is the client side runtime environment */
+var IS_CLIENT_SIDE = typeof window !== 'undefined';
+/** Is the runtime environment an Android app */
+var IS_ANDROID_WEBVIEW = Boolean(IS_CLIENT_SIDE && window.AndroidBridge);
+/** Is the runtime environment an iOS app */
+var IS_IOS_WEBVIEW = Boolean(IS_CLIENT_SIDE &&
+    window.webkit &&
+    window.webkit.messageHandlers &&
+    window.webkit.messageHandlers.VKWebAppClose);
+var IS_REACT_NATIVE_WEBVIEW = Boolean(IS_CLIENT_SIDE &&
+    window.ReactNativeWebView &&
+    typeof window.ReactNativeWebView.postMessage === 'function');
+/** Is the runtime environment a browser */
+var IS_WEB = IS_CLIENT_SIDE && !IS_ANDROID_WEBVIEW && !IS_IOS_WEBVIEW;
+/** Is the runtime environment m.vk.ru */
+var IS_MVK = IS_WEB && /(^\?|&)vk_platform=mobile_web(&|$)/.test(location.search);
+/** Is the runtime environment vk.ru */
+var IS_DESKTOP_VK = IS_WEB && !IS_MVK;
+/** Type of subscribe event */
+var EVENT_TYPE = IS_WEB ? 'message' : 'VKWebAppEvent';
+/** Methods supported on the desktop */
+var DESKTOP_METHODS = __spreadArray([
+    'VKWebAppInit',
+    'VKWebAppGetCommunityAuthToken',
+    'VKWebAppAddToCommunity',
+    'VKWebAppAddToHomeScreenInfo',
+    'VKWebAppClose',
+    'VKWebAppCopyText',
+    'VKWebAppCreateHash',
+    'VKWebAppGetUserInfo',
+    'VKWebAppSetLocation',
+    'VKWebAppSendToClient',
+    'VKWebAppGetClientVersion',
+    'VKWebAppGetPhoneNumber',
+    'VKWebAppGetEmail',
+    'VKWebAppGetGroupInfo',
+    'VKWebAppGetGeodata',
+    'VKWebAppGetCommunityToken',
+    'VKWebAppGetConfig',
+    'VKWebAppGetLaunchParams',
+    'VKWebAppSetTitle',
+    'VKWebAppGetAuthToken',
+    'VKWebAppCallAPIMethod',
+    'VKWebAppJoinGroup',
+    'VKWebAppLeaveGroup',
+    'VKWebAppAllowMessagesFromGroup',
+    'VKWebAppDenyNotifications',
+    'VKWebAppAllowNotifications',
+    'VKWebAppOpenPayForm',
+    'VKWebAppOpenApp',
+    'VKWebAppShare',
+    'VKWebAppShowWallPostBox',
+    'VKWebAppScroll',
+    'VKWebAppShowOrderBox',
+    'VKWebAppShowLeaderBoardBox',
+    'VKWebAppShowInviteBox',
+    'VKWebAppShowRequestBox',
+    'VKWebAppAddToFavorites',
+    'VKWebAppShowStoryBox',
+    'VKWebAppStorageGet',
+    'VKWebAppStorageGetKeys',
+    'VKWebAppStorageSet',
+    'VKWebAppFlashGetInfo',
+    'VKWebAppSubscribeStoryApp',
+    'VKWebAppOpenWallPost',
+    'VKWebAppCheckAllowedScopes',
+    'VKWebAppCheckBannerAd',
+    'VKWebAppHideBannerAd',
+    'VKWebAppShowBannerAd',
+    'VKWebAppCheckNativeAds',
+    'VKWebAppShowNativeAds',
+    'VKWebAppRetargetingPixel',
+    'VKWebAppConversionHit',
+    'VKWebAppShowSubscriptionBox',
+    'VKWebAppCheckSurvey',
+    'VKWebAppShowSurvey',
+    'VKWebAppScrollTop',
+    'VKWebAppScrollTopStart',
+    'VKWebAppScrollTopStop',
+    'VKWebAppShowSlidesSheet',
+    'VKWebAppTranslate',
+    'VKWebAppRecommend',
+    'VKWebAppAddToProfile',
+    'VKWebAppGetFriends'
+], (IS_DESKTOP_VK
+    ? [
+        'VKWebAppResizeWindow',
+        'VKWebAppAddToMenu',
+        'VKWebAppShowInstallPushBox',
+        'VKWebAppShowCommunityWidgetPreviewBox',
+        'VKWebAppCallStart',
+        'VKWebAppCallJoin',
+        'VKWebAppCallGetStatus',
+    ]
+    : ['VKWebAppShowImages']), true);
+/** Cache for supported methods */
+var supportedHandlers;
+/** Android VK Bridge interface. */
+var androidBridge = IS_CLIENT_SIDE ? window.AndroidBridge : undefined;
+/** iOS VK Bridge interface. */
+var iosBridge = IS_IOS_WEBVIEW ? window.webkit.messageHandlers : undefined;
+/** Web VK Bridge interface. */
+var webBridge = IS_WEB
+    ? parent
+    : undefined;
+// [Примечание 1] Отключили использование в этом PR https://github.com/VKCOM/vk-bridge/pull/262
+// let webSdkHandlers: string[] | undefined;
+/**
+ * Creates a VK Bridge API that holds functions for interact with runtime
+ * environment.
+ *
+ * @param version Version of the package
+ */
+function createVKBridge(version) {
+    /** Current frame id. */
+    var webFrameId = undefined;
+    /** List of functions that subscribed on events. */
+    var subscribers = [];
+    /** Uniq instance ID */
+    var instanceId = createInstanceId();
+    /**
+     * Sends an event to the runtime env. In the case of Android/iOS application
+     * env is the application itself. In the case of the browser, the parent
+     * frame in which the event handlers is located.
+     *
+     * @param method The method (event) name to send
+     * @param [props] Method properties
+     */
+    function send(method, props) {
+        // Sending data through Android bridge
+        if (androidBridge && androidBridge[method]) {
+            androidBridge[method](JSON.stringify(props));
+        }
+        // Sending data through iOS bridge
+        else if (iosBridge &&
+            iosBridge[method] &&
+            typeof iosBridge[method].postMessage === 'function') {
+            iosBridge[method].postMessage(props);
+        }
+        // Sending data through React Native bridge
+        else if (IS_REACT_NATIVE_WEBVIEW) {
+            window.ReactNativeWebView.postMessage(JSON.stringify({
+                handler: method,
+                params: props,
+            }));
+        }
+        // Sending data through web bridge
+        else if (webBridge && typeof webBridge.postMessage === 'function') {
+            webBridge.postMessage({
+                handler: method,
+                params: props,
+                type: 'vk-connect',
+                webFrameId: webFrameId,
+                connectVersion: version,
+            }, '*');
+        }
+    }
+    /**
+     * Adds an event listener. It will be called any time a data is received.
+     *
+     * @param listener A callback to be invoked on every event receive.
+     */
+    function subscribe(listener) {
+        subscribers.push(listener);
+    }
+    /**
+     * Removes an event listener which has been subscribed for event listening.
+     *
+     * @param listener A callback to unsubscribe.
+     */
+    function unsubscribe(listener) {
+        var index = subscribers.indexOf(listener);
+        if (index > -1) {
+            subscribers.splice(index, 1);
+        }
+    }
+    function supportsInner(method) {
+        if (IS_ANDROID_WEBVIEW) {
+            // Android support check
+            return !!(androidBridge && typeof androidBridge[method] === 'function');
+        }
+        else if (IS_IOS_WEBVIEW) {
+            // iOS support check
+            return !!(iosBridge &&
+                iosBridge[method] &&
+                typeof iosBridge[method].postMessage === 'function');
+        }
+        else if (IS_WEB) {
+            // Web support check
+            return DESKTOP_METHODS.includes(method);
+            // см. Примечание 1
+            // if (!webSdkHandlers) {
+            //   console.error('You should call bridge.send("VKWebAppInit") first');
+            //   return false;
+            // }
+            // return webSdkHandlers.includes(method);
+        }
+        return false;
+    }
+    /**
+     * Checks if a method is supported on runtime platform.
+     *
+     * @param method Method (event) name to check.
+     * @returns Result of checking.
+     * @deprecated This method is deprecated. Use supportsAsync instead.
+     */
+    function supports(method) {
+        console.warn('bridge.supports method is deprecated. Use bridge.supportsAsync instead.');
+        return supportsInner(method);
+    }
+    /**
+     * Checks whether the runtime is a WebView.
+     *
+     * @returns Result of checking.
+     */
+    function isWebView() {
+        return IS_IOS_WEBVIEW || IS_ANDROID_WEBVIEW;
+    }
+    /**
+     * Checks whether the runtime is an iframe.
+     *
+     * @returns Result of checking.
+     */
+    function isIframe() {
+        return IS_WEB && window.parent !== window;
+    }
+    /**
+     * Checks whether the runtime is embedded.
+     *
+     * @returns Result of checking.
+     */
+    function isEmbedded() {
+        return isWebView() || isIframe();
+    }
+    /**
+     * Checks whether the runtime is standalone.
+     *
+     * @returns Result of checking.
+     */
+    function isStandalone() {
+        return !isEmbedded();
+    }
+    function handleEvent(event) {
+        if (IS_IOS_WEBVIEW || IS_ANDROID_WEBVIEW) {
+            // If it's webview
+            return __spreadArray([], subscribers, true).map(function (fn) { return fn.call(null, event); });
+        }
+        var bridgeEventData = event === null || event === void 0 ? void 0 : event.data;
+        if (!IS_WEB || !bridgeEventData) {
+            return;
+        }
+        if (IS_REACT_NATIVE_WEBVIEW && typeof bridgeEventData === 'string') {
+            try {
+                bridgeEventData = JSON.parse(bridgeEventData);
+            }
+            catch (_a) { }
+        }
+        var type = bridgeEventData.type, data = bridgeEventData.data, frameId = bridgeEventData.frameId;
+        if (!type) {
+            return;
+        }
+        // см. Примечание 1
+        // if (type === 'SetSupportedHandlers') {
+        //   webSdkHandlers = data.supportedHandlers;
+        //   return;
+        // }
+        if (type === 'VKWebAppSettings') {
+            webFrameId = frameId;
+            return;
+        }
+        __spreadArray([], subscribers, true).map(function (fn) { return fn({ detail: { type: type, data: data } }); });
+    }
+    // Subscribes to listening messages from a runtime for calling each
+    // subscribed event listener.
+    if (IS_REACT_NATIVE_WEBVIEW && /(android)/i.test(navigator.userAgent)) {
+        document.addEventListener(EVENT_TYPE, handleEvent);
+    }
+    else if (typeof window !== 'undefined' && 'addEventListener' in window) {
+        window.addEventListener(EVENT_TYPE, handleEvent);
+    }
+    /**
+     * Enhanced send functions for the ability to receive response data in
+     * the Promise object.
+     */
+    var sendPromise = promisifySend(send, subscribe, instanceId);
+    function supportsAsync(method) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (IS_ANDROID_WEBVIEW || IS_IOS_WEBVIEW) {
+                            return [2 /*return*/, supportsInner(method)];
+                        }
+                        if (supportedHandlers) {
+                            return [2 /*return*/, supportedHandlers.has(method)];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, sendPromise('SetSupportedHandlers')];
+                    case 2:
+                        response = _a.sent();
+                        supportedHandlers = new Set(response.supportedHandlers);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a.sent();
+                        supportedHandlers = new Set(['VKWebAppInit']);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, supportedHandlers.has(method)];
+                }
+            });
+        });
+    }
+    subscribe(function (event) {
+        if (!event.detail) {
+            return;
+        }
+        switch (event.detail.type) {
+            case 'SetSupportedHandlers':
+                supportedHandlers = new Set(event.detail.data.supportedHandlers);
+        }
+    });
+    return {
+        send: sendPromise,
+        sendPromise: sendPromise,
+        subscribe: subscribe,
+        unsubscribe: unsubscribe,
+        supports: supports,
+        supportsAsync: supportsAsync,
+        isWebView: isWebView,
+        isIframe: isIframe,
+        isEmbedded: isEmbedded,
+        isStandalone: isStandalone,
+    };
+}
+
+var version = "2.15.11";
+
+var EAdsFormats;
+(function (EAdsFormats) {
+    EAdsFormats["REWARD"] = "reward";
+    EAdsFormats["INTERSTITIAL"] = "interstitial";
+})(EAdsFormats || (EAdsFormats = {}));
+var BannerAdLayoutType;
+(function (BannerAdLayoutType) {
+    BannerAdLayoutType["RESIZE"] = "resize";
+    BannerAdLayoutType["OVERLAY"] = "overlay";
+})(BannerAdLayoutType || (BannerAdLayoutType = {}));
+var BannerAdLocation;
+(function (BannerAdLocation) {
+    BannerAdLocation["TOP"] = "top";
+    BannerAdLocation["BOTTOM"] = "bottom";
+})(BannerAdLocation || (BannerAdLocation = {}));
+var BannerAdAlign;
+(function (BannerAdAlign) {
+    BannerAdAlign["LEFT"] = "left";
+    BannerAdAlign["RIGHT"] = "right";
+    BannerAdAlign["CENTER"] = "center";
+})(BannerAdAlign || (BannerAdAlign = {}));
+var BannerAdHeightType;
+(function (BannerAdHeightType) {
+    BannerAdHeightType["COMPACT"] = "compact";
+    BannerAdHeightType["REGULAR"] = "regular";
+})(BannerAdHeightType || (BannerAdHeightType = {}));
+var BannerAdOrientation;
+(function (BannerAdOrientation) {
+    BannerAdOrientation["HORIZONTAL"] = "horizontal";
+    BannerAdOrientation["VERTICAL"] = "vertical";
+})(BannerAdOrientation || (BannerAdOrientation = {}));
+var EGrantedPermission;
+(function (EGrantedPermission) {
+    EGrantedPermission["CAMERA"] = "camera";
+    EGrantedPermission["LOCATION"] = "location";
+    EGrantedPermission["PHOTO"] = "photo";
+})(EGrantedPermission || (EGrantedPermission = {}));
+var EGetLaunchParamsResponseLanguages;
+(function (EGetLaunchParamsResponseLanguages) {
+    EGetLaunchParamsResponseLanguages["RU"] = "ru";
+    EGetLaunchParamsResponseLanguages["UK"] = "uk";
+    EGetLaunchParamsResponseLanguages["UA"] = "ua";
+    EGetLaunchParamsResponseLanguages["EN"] = "en";
+    EGetLaunchParamsResponseLanguages["BE"] = "be";
+    EGetLaunchParamsResponseLanguages["KZ"] = "kz";
+    EGetLaunchParamsResponseLanguages["PT"] = "pt";
+    EGetLaunchParamsResponseLanguages["ES"] = "es";
+})(EGetLaunchParamsResponseLanguages || (EGetLaunchParamsResponseLanguages = {}));
+var EGetLaunchParamsResponseGroupRole;
+(function (EGetLaunchParamsResponseGroupRole) {
+    EGetLaunchParamsResponseGroupRole["ADMIN"] = "admin";
+    EGetLaunchParamsResponseGroupRole["EDITOR"] = "editor";
+    EGetLaunchParamsResponseGroupRole["MEMBER"] = "member";
+    EGetLaunchParamsResponseGroupRole["MODER"] = "moder";
+    EGetLaunchParamsResponseGroupRole["NONE"] = "none";
+})(EGetLaunchParamsResponseGroupRole || (EGetLaunchParamsResponseGroupRole = {}));
+var EGetLaunchParamsResponsePlatforms;
+(function (EGetLaunchParamsResponsePlatforms) {
+    EGetLaunchParamsResponsePlatforms["DESKTOP_WEB"] = "desktop_web";
+    EGetLaunchParamsResponsePlatforms["DESKTOP_WEB_MESSENGER"] = "desktop_web_messenger";
+    EGetLaunchParamsResponsePlatforms["DESKTOP_APP_MESSENGER"] = "desktop_app_messenger";
+    EGetLaunchParamsResponsePlatforms["MOBILE_WEB"] = "mobile_web";
+    EGetLaunchParamsResponsePlatforms["MOBILE_ANDROID"] = "mobile_android";
+    EGetLaunchParamsResponsePlatforms["MOBILE_ANDROID_MESSENGER"] = "mobile_android_messenger";
+    EGetLaunchParamsResponsePlatforms["MOBILE_IPHONE"] = "mobile_iphone";
+    EGetLaunchParamsResponsePlatforms["MOBILE_IPHONE_MESSENGER"] = "mobile_iphone_messenger";
+    EGetLaunchParamsResponsePlatforms["MOBILE_IPAD"] = "mobile_ipad";
+})(EGetLaunchParamsResponsePlatforms || (EGetLaunchParamsResponsePlatforms = {}));
+
+/**
+ * Creates the VK Bridge enhancer that applies middleware to the `send`
+ * method. This is handy for a variety of task such as logging every sent
+ * event.
+ *
+ * @param middlewares The middleware chain to be applied.
+ * @returns The VK Bridge enhancer applying the middleware.
+ */
+function applyMiddleware() {
+    var middlewares = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        middlewares[_i] = arguments[_i];
+    }
+    if (middlewares.includes(undefined) || middlewares.includes(null)) {
+        return applyMiddleware.apply(void 0, middlewares.filter(function (item) { return typeof item === 'function'; }));
+    }
+    return function (bridge) {
+        if (middlewares.length === 0) {
+            return bridge;
+        }
+        var send = function () {
+            throw new Error('Sending events while constructing your middleware is not allowed. ' +
+                'Other middleware would not be applied to this send.');
+        };
+        var middlewareAPI = {
+            subscribe: bridge.subscribe,
+            send: function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return bridge.send.apply(bridge, args);
+            },
+        };
+        var chain = middlewares
+            .filter(function (item) { return typeof item === 'function'; })
+            .map(function (middleware) { return middleware(middlewareAPI); }) //
+            .reduce(function (a, b) { return function (send) { return a(b(send)); }; });
+        send = chain(bridge.send);
+        return __assign(__assign({}, bridge), { send: send });
+    };
+}
+
+/**
+ * @see https://dev.vk.ru/mini-apps/development/launch-params
+ */
+var parseURLSearchParamsForGetLaunchParams = function (searchParams) {
+    var launchParams = {};
+    try {
+        var parsedSearchParams = new URLSearchParams(searchParams);
+        var convertToggleStateFromStringToNumber_1 = function (value) {
+            switch (value) {
+                case '0':
+                    return 0;
+                case '1':
+                    return 1;
+                default:
+                    return undefined;
+            }
+        };
+        parsedSearchParams.forEach(function (value, query) {
+            switch (query) {
+                case 'vk_ts':
+                case 'vk_is_recommended':
+                case 'vk_profile_id':
+                case 'vk_has_profile_button':
+                case 'vk_testing_group_id':
+                case 'vk_user_id':
+                case 'vk_app_id':
+                case 'vk_group_id':
+                    launchParams[query] = Number(value);
+                    break;
+                case 'sign':
+                case 'vk_chat_id':
+                case 'vk_ref':
+                case 'vk_access_token_settings':
+                    launchParams[query] = value;
+                    break;
+                case 'odr_enabled':
+                    launchParams['odr_enabled'] = value === '1' ? 1 : undefined;
+                    break;
+                case 'vk_is_app_user':
+                case 'vk_are_notifications_enabled':
+                case 'vk_is_favorite': {
+                    launchParams[query] = convertToggleStateFromStringToNumber_1(value);
+                    break;
+                }
+                case 'vk_language': {
+                    var validateVKLanguage = function (value) {
+                        return Object.values(EGetLaunchParamsResponseLanguages).some(function (i) { return i === value; });
+                    };
+                    launchParams['vk_language'] = validateVKLanguage(value) ? value : undefined;
+                    break;
+                }
+                case 'vk_viewer_group_role': {
+                    var validateVKViewerGroupRole = function (value) {
+                        return Object.values(EGetLaunchParamsResponseGroupRole).some(function (i) { return i === value; });
+                    };
+                    launchParams['vk_viewer_group_role'] = validateVKViewerGroupRole(value)
+                        ? value
+                        : undefined;
+                    break;
+                }
+                case 'vk_platform': {
+                    var validateVKPlatform = function (value) {
+                        return Object.values(EGetLaunchParamsResponsePlatforms).some(function (i) { return i === value; });
+                    };
+                    launchParams['vk_platform'] = validateVKPlatform(value) ? value : undefined;
+                    break;
+                }
+            }
+        });
+    }
+    catch (e) {
+        console.warn(e);
+    }
+    return launchParams;
+};
+
+// VK Bridge API
+var bridge = createVKBridge(version);
+
+export { BannerAdAlign, BannerAdHeightType, BannerAdLayoutType, BannerAdLocation, BannerAdOrientation, EAdsFormats, EGetLaunchParamsResponseGroupRole, EGetLaunchParamsResponseLanguages, EGetLaunchParamsResponsePlatforms, EGrantedPermission, applyMiddleware, bridge as default, parseURLSearchParamsForGetLaunchParams };
+//# sourceMappingURL=index.es.js.map

node_modules/@vkontakte/vk-bridge/dist/types/src/applyMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { VKBridge } from './types/bridge';
+import { Middleware } from './types/middleware';
+/**
+ * Creates the VK Bridge enhancer that applies middleware to the `send`
+ * method. This is handy for a variety of task such as logging every sent
+ * event.
+ *
+ * @param middlewares The middleware chain to be applied.
+ * @returns The VK Bridge enhancer applying the middleware.
+ */
+export declare function applyMiddleware(...middlewares: Array<Middleware | undefined | null>): (bridge: VKBridge) => VKBridge;

node_modules/@vkontakte/vk-bridge/dist/types/src/bridge.d.ts

@@ -0,0 +1,25 @@
+import { VKBridge } from './types/bridge';
+/** Is the client side runtime environment */
+export declare const IS_CLIENT_SIDE: boolean;
+/** Is the runtime environment an Android app */
+export declare const IS_ANDROID_WEBVIEW: boolean;
+/** Is the runtime environment an iOS app */
+export declare const IS_IOS_WEBVIEW: boolean;
+export declare const IS_REACT_NATIVE_WEBVIEW: boolean;
+/** Is the runtime environment a browser */
+export declare const IS_WEB: boolean;
+/** Is the runtime environment m.vk.ru */
+export declare const IS_MVK: boolean;
+/** Is the runtime environment vk.ru */
+export declare const IS_DESKTOP_VK: boolean;
+/** Type of subscribe event */
+export declare const EVENT_TYPE: string;
+/** Methods supported on the desktop */
+export declare const DESKTOP_METHODS: string[];
+/**
+ * Creates a VK Bridge API that holds functions for interact with runtime
+ * environment.
+ *
+ * @param version Version of the package
+ */
+export declare function createVKBridge(version: string): VKBridge;

node_modules/@vkontakte/vk-bridge/dist/types/src/browser.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/@vkontakte/vk-bridge/dist/types/src/index.d.ts

@@ -0,0 +1,8 @@
+declare const bridge: import("./types/bridge").VKBridge;
+export * from './types/data';
+export * from './types/bridge';
+export * from './types/middleware';
+export * from './types/deprecated';
+export { applyMiddleware } from './applyMiddleware';
+export { parseURLSearchParamsForGetLaunchParams } from './parseURLSearchParamsForGetLaunchParams';
+export { bridge as default };

node_modules/@vkontakte/vk-bridge/dist/types/src/parseURLSearchParamsForGetLaunchParams.d.ts

@@ -0,0 +1,13 @@
+import type { GetLaunchParamsResponse } from './types/data';
+export interface LaunchParams extends GetLaunchParamsResponse {
+    vk_chat_id: string;
+    vk_is_recommended: number;
+    vk_profile_id: number;
+    vk_has_profile_button: number;
+    vk_testing_group_id: number;
+    odr_enabled: undefined | 1;
+}
+/**
+ * @see https://dev.vk.ru/mini-apps/development/launch-params
+ */
+export declare const parseURLSearchParamsForGetLaunchParams: (searchParams: string) => Partial<LaunchParams>;

node_modules/@vkontakte/vk-bridge/dist/types/src/promisifySend.d.ts

@@ -0,0 +1,10 @@
+import { VKBridgeSubscribeHandler, AnyRequestMethodName, RequestProps, RequestIdProp, ReceiveData, AnyReceiveMethodName } from './types/bridge';
+/**
+ * Returns send function that returns promises.
+ *
+ * @param sendEvent Send event function.
+ * @param subscribe Subscribe event function.
+ * @param instanceId Uniq bridge instance ID.
+ * @returns Send function which returns the Promise object.
+ */
+export declare function promisifySend(sendEvent: <K extends AnyRequestMethodName>(method: K, props?: RequestProps<K> & RequestIdProp) => void, subscribe: (fn: VKBridgeSubscribeHandler) => void, instanceId: string): <K extends keyof import(".").RequestPropsMap>(method: K, props?: RequestProps<K> & RequestIdProp) => Promise<K extends keyof import(".").ReceiveDataMap ? ReceiveData<K> : void>;

node_modules/@vkontakte/vk-bridge/dist/types/src/types/bridge.d.ts

@@ -0,0 +1,207 @@
+import { RequestPropsMap, ReceiveDataMap, ReceiveEventMap } from './data';
+/**
+ * Name of a method that can be sent.
+ */
+export type AnyRequestMethodName = keyof RequestPropsMap;
+/**
+ * Name of a method that can be received.
+ */
+export type AnyReceiveMethodName = keyof ReceiveDataMap;
+/**
+ * Name of a method that can be only sent.
+ */
+export type AnyRequestOnlyMethodName = Exclude<AnyRequestMethodName, AnyReceiveMethodName>;
+/**
+ * Name of a method that can be only received.
+ */
+export type AnyReceiveOnlyMethodName = Exclude<AnyReceiveMethodName, AnyRequestMethodName>;
+/**
+ * Name of a method which contains properties
+ */
+export type AnyRequestMethodNameWithProps = {
+    [K in keyof RequestPropsMap]: keyof RequestPropsMap[K] extends never ? never : K;
+}[keyof RequestPropsMap];
+/**
+ * Name of a method which doesn't contain properties
+ */
+export type AnyRequestMethodNameWithoutProps = Exclude<AnyRequestMethodName, AnyRequestMethodNameWithProps>;
+/**
+ * Type of any method name.
+ */
+export type AnyMethodName = AnyRequestMethodName | AnyReceiveMethodName;
+/**
+ * The name of the method that can be both sent and received.
+ */
+export type AnyIOMethodName = AnyRequestMethodName & AnyReceiveMethodName;
+/**
+ * Any failed event method name.
+ */
+export type AnyFailedResponseEventName = FailedResponseEventName<AnyRequestMethodName>;
+/**
+ * Any result response event method name.
+ */
+export type AnyResultResponseEventName = ResultResponseEventName<AnyRequestMethodName>;
+/**
+ * Getter of failed event name of a method.
+ */
+export type FailedResponseEventName<M extends AnyRequestMethodName> = M extends keyof ReceiveEventMap ? ReceiveEventMap[M]['failed'] : never;
+/**
+ * Getter of result event name of a method.
+ */
+export type ResultResponseEventName<M extends AnyRequestMethodName> = M extends keyof ReceiveEventMap ? ReceiveEventMap[M]['result'] : never;
+/**
+ * Getter of request properties of a method.
+ */
+export type RequestProps<M extends AnyRequestMethodName = AnyRequestMethodName> = RequestPropsMap[M];
+/**
+ * Getter of response data of a method.
+ */
+export type ReceiveData<M extends AnyReceiveMethodName> = ReceiveDataMap[M];
+/**
+ * Property for matching sent request and received message.
+ */
+export type RequestIdProp = {
+    request_id?: number | string;
+};
+/**
+ * Client error data.
+ */
+export type ErrorDataClientError = {
+    error_code: number;
+    error_reason: string;
+    error_description?: string;
+};
+/**
+ * API error data.
+ */
+export type ErrorDataAPIError = {
+    error_code: number;
+    error_msg: string;
+    request_params: string[];
+};
+/**
+ * Auth error data.
+ */
+export type ErrorDataAuthError = {
+    error_code: number;
+    error_reason: string;
+    error_description?: string[];
+};
+/**
+ * Type of error data
+ */
+export type ErrorData = {
+    error_type: 'client_error';
+    error_data: ErrorDataClientError;
+    request_id?: number | string;
+} | {
+    error_type: 'api_error';
+    error_data: ErrorDataAPIError;
+    request_id?: number | string;
+} | {
+    error_type: 'auth_error';
+    error_data: ErrorDataAuthError;
+    request_id?: number | string;
+};
+/**
+ * Generic event type for creating event types.
+ */
+export type VKBridgeEventBase<Type extends string, Data> = {
+    detail: {
+        type: Type;
+        data: Data;
+    };
+};
+/**
+ * Type of error event data
+ */
+export type VKBridgeErrorEvent<M extends AnyReceiveMethodName> = VKBridgeEventBase<M extends AnyRequestMethodName ? FailedResponseEventName<M> : never, ErrorData>;
+/**
+ * Type of event that is a response to a request
+ */
+export type VKBridgeIOEvent<M extends AnyIOMethodName> = {
+    [K in M]: VKBridgeEventBase<ResultResponseEventName<K>, ReceiveData<K> & RequestIdProp>;
+}[M];
+/**
+ * Type of event that is not a response to a request
+ */
+export type VKBridgeReceiveOnlyEvent<M extends AnyReceiveOnlyMethodName> = {
+    [K in M]: VKBridgeEventBase<K, ReceiveData<K>>;
+}[M];
+/**
+ * Type of result event data
+ */
+export type VKBridgeResultEvent<M extends AnyReceiveMethodName> = M extends AnyReceiveOnlyMethodName ? VKBridgeReceiveOnlyEvent<M> : M extends AnyIOMethodName ? VKBridgeIOEvent<M> : never;
+/**
+ * VK Bridge event.
+ */
+export type VKBridgeEvent<M extends AnyReceiveMethodName> = VKBridgeErrorEvent<M> | VKBridgeResultEvent<M>;
+/**
+ * Type of function that will be subscribed to VK Bridge events.
+ */
+export type VKBridgeSubscribeHandler = (event: VKBridgeEvent<AnyReceiveMethodName>) => void;
+/**
+ * Type of send function for methods that have props.
+ *
+ * @param method The method (event) name to send.
+ * @param props Method properties.
+ * @returns The Promise object with response data.
+ */
+export type VKBridgeSend = <K extends AnyRequestMethodName>(method: K, props?: RequestProps<K> & RequestIdProp) => Promise<K extends AnyReceiveMethodName ? ReceiveData<K> : void>;
+/**
+ * VK Bridge interface.
+ */
+export interface VKBridge {
+    /**
+     * Sends an event to the runtime env and returns the Promise object with
+     * response data. In the case of Android/iOS application env is the
+     * application itself. In the case of the browser, the parent frame in which
+     * the event handlers is located.
+     *
+     * @param method The method (event) name to send.
+     * @param [props] Method properties.
+     * @returns The Promise object with response data.
+     */
+    send: VKBridgeSend;
+    /**
+     * @alias send
+     * @deprecated
+     */
+    sendPromise: VKBridgeSend;
+    /**
+     * Adds an event listener. It will be called any time a data is received.
+     *
+     * @param listener A callback to be invoked on every event receive.
+     */
+    subscribe: (listener: VKBridgeSubscribeHandler) => void;
+    /**
+     * Removes an event listener which has been subscribed for event listening.
+     *
+     * @param listener A callback to unsubscribe.
+     */
+    unsubscribe: (listener: VKBridgeSubscribeHandler) => void;
+    /**
+     * Checks if a method is supported on runtime platform.
+     *
+     * @param method Method (event) name to check.
+     * @returns Result of checking.
+     * @deprecated This method is deprecated. Use supportsAsync instead.
+     */
+    supports: <K extends AnyRequestMethodName>(method: K) => boolean;
+    /**
+     * Checks if a method is supported on runtime platform.
+     *
+     * @param method Method (event) name to check.
+     * @returns The Promise object with result of checking.
+     */
+    supportsAsync: <K extends AnyRequestMethodName>(method: K) => Promise<boolean>;
+    /**
+     * Checks whether the runtime is a WebView.
+     *
+     * @returns Result of checking.
+     */
+    isWebView: () => boolean;
+    isIframe: () => boolean;
+    isEmbedded: () => boolean;
+    isStandalone: () => boolean;
+}

node_modules/@vkontakte/vk-bridge/dist/types/src/types/deprecated.d.ts

@@ -0,0 +1,56 @@
+import { AnyRequestMethodName, AnyReceiveMethodName, AnyRequestMethodNameWithProps, AnyRequestMethodNameWithoutProps, AnyMethodName, AnyIOMethodName, AnyRequestOnlyMethodName, AnyReceiveOnlyMethodName } from './bridge';
+import { CommunityWidgetType } from './data';
+/**
+ * Name of a method that can be sent.
+ * @alias AnyRequestMethodName
+ * @deprecated
+ */
+export type RequestMethodName = AnyRequestMethodName;
+/**
+ * Name of a method that can be received.
+ * @alias AnyReceiveMethodName
+ * @deprecated
+ */
+export type ReceiveMethodName = AnyReceiveMethodName;
+/**
+ * Name of a method that can be only sent.
+ * @alias AnyRequestOnlyMethodName
+ * @deprecated
+ */
+export type RequestOnlyMethodName = AnyRequestOnlyMethodName;
+/**
+ * Name of a method that can be only received.
+ * @alias AnyReceiveOnlyMethodName
+ * @deprecated
+ */
+export type ReceiveOnlyMethodName = AnyReceiveOnlyMethodName;
+/**
+ * Name of a method which contains properties
+ * @alias AnyRequestMethodNameWithProps
+ * @deprecated
+ */
+export type RequestMethodNameWithProps = AnyRequestMethodNameWithProps;
+/**
+ * Name of a method which doesn't contain properties
+ * @alias AnyRequestMethodNameWithoutProps
+ * @deprecated
+ */
+export type RequestMethodNameWithoutProps = AnyRequestMethodNameWithoutProps;
+/**
+ * Type of any method name.
+ * @alias AnyMethodName
+ * @deprecated
+ */
+export type MethodName = AnyMethodName;
+/**
+ * The name of the method that can be both sent and received.
+ * @alias AnyIOMethodName
+ * @deprecated
+ */
+export type IOMethodName = AnyIOMethodName;
+/**
+ * Community widget type
+ * @alias CommunityWidgetType
+ * @deprecated
+ */
+export type WidgetType = CommunityWidgetType;

node_modules/@vkontakte/vk-bridge/dist/types/src/types/middleware.d.ts

@@ -0,0 +1,13 @@
+import { VKBridgeSend, VKBridgeSubscribeHandler } from './bridge';
+/**
+ * API that can use middleware.
+ */
+export interface MiddlewareAPI<S extends VKBridgeSend = VKBridgeSend, L extends VKBridgeSubscribeHandler = VKBridgeSubscribeHandler> {
+    send: S;
+    subscribe(listener: L): void;
+}
+/**
+ * A middleware is a higher-order function that composes a dispatch function
+ * to return a new `send` function.
+ */
+export type Middleware<S extends VKBridgeSend = VKBridgeSend> = (api: MiddlewareAPI<S>) => (next: S) => S;

node_modules/@vkontakte/vk-bridge/dist/types/src/utils.d.ts

@@ -0,0 +1 @@
+export declare function createInstanceId(): string;

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/applyMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { VKBridge } from './types/bridge';
+import { Middleware } from './types/middleware';
+/**
+ * Creates the VK Bridge enhancer that applies middleware to the `send`
+ * method. This is handy for a variety of task such as logging every sent
+ * event.
+ *
+ * @param middlewares The middleware chain to be applied.
+ * @returns The VK Bridge enhancer applying the middleware.
+ */
+export declare function applyMiddleware(...middlewares: Array<Middleware | undefined | null>): (bridge: VKBridge) => VKBridge;

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/bridge.d.ts

@@ -0,0 +1,25 @@
+import { VKBridge } from './types/bridge';
+/** Is the client side runtime environment */
+export declare const IS_CLIENT_SIDE: boolean;
+/** Is the runtime environment an Android app */
+export declare const IS_ANDROID_WEBVIEW: boolean;
+/** Is the runtime environment an iOS app */
+export declare const IS_IOS_WEBVIEW: boolean;
+export declare const IS_REACT_NATIVE_WEBVIEW: boolean;
+/** Is the runtime environment a browser */
+export declare const IS_WEB: boolean;
+/** Is the runtime environment m.vk.ru */
+export declare const IS_MVK: boolean;
+/** Is the runtime environment vk.ru */
+export declare const IS_DESKTOP_VK: boolean;
+/** Type of subscribe event */
+export declare const EVENT_TYPE: string;
+/** Methods supported on the desktop */
+export declare const DESKTOP_METHODS: string[];
+/**
+ * Creates a VK Bridge API that holds functions for interact with runtime
+ * environment.
+ *
+ * @param version Version of the package
+ */
+export declare function createVKBridge(version: string): VKBridge;

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/browser.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/index.d.ts

@@ -0,0 +1,8 @@
+declare const bridge: import("./types/bridge").VKBridge;
+export * from './types/data';
+export * from './types/bridge';
+export * from './types/middleware';
+export * from './types/deprecated';
+export { applyMiddleware } from './applyMiddleware';
+export { parseURLSearchParamsForGetLaunchParams } from './parseURLSearchParamsForGetLaunchParams';
+export { bridge as default };

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/parseURLSearchParamsForGetLaunchParams.d.ts

@@ -0,0 +1,13 @@
+import type { GetLaunchParamsResponse } from './types/data';
+export interface LaunchParams extends GetLaunchParamsResponse {
+    vk_chat_id: string;
+    vk_is_recommended: number;
+    vk_profile_id: number;
+    vk_has_profile_button: number;
+    vk_testing_group_id: number;
+    odr_enabled: undefined | 1;
+}
+/**
+ * @see https://dev.vk.ru/mini-apps/development/launch-params
+ */
+export declare const parseURLSearchParamsForGetLaunchParams: (searchParams: string) => Partial<LaunchParams>;

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/types/bridge.d.ts

@@ -0,0 +1,207 @@
+import { RequestPropsMap, ReceiveDataMap, ReceiveEventMap } from './data';
+/**
+ * Name of a method that can be sent.
+ */
+export declare type AnyRequestMethodName = keyof RequestPropsMap;
+/**
+ * Name of a method that can be received.
+ */
+export declare type AnyReceiveMethodName = keyof ReceiveDataMap;
+/**
+ * Name of a method that can be only sent.
+ */
+export declare type AnyRequestOnlyMethodName = Exclude<AnyRequestMethodName, AnyReceiveMethodName>;
+/**
+ * Name of a method that can be only received.
+ */
+export declare type AnyReceiveOnlyMethodName = Exclude<AnyReceiveMethodName, AnyRequestMethodName>;
+/**
+ * Name of a method which contains properties
+ */
+export declare type AnyRequestMethodNameWithProps = {
+    [K in keyof RequestPropsMap]: keyof RequestPropsMap[K] extends never ? never : K;
+}[keyof RequestPropsMap];
+/**
+ * Name of a method which doesn't contain properties
+ */
+export declare type AnyRequestMethodNameWithoutProps = Exclude<AnyRequestMethodName, AnyRequestMethodNameWithProps>;
+/**
+ * Type of any method name.
+ */
+export declare type AnyMethodName = AnyRequestMethodName | AnyReceiveMethodName;
+/**
+ * The name of the method that can be both sent and received.
+ */
+export declare type AnyIOMethodName = AnyRequestMethodName & AnyReceiveMethodName;
+/**
+ * Any failed event method name.
+ */
+export declare type AnyFailedResponseEventName = FailedResponseEventName<AnyRequestMethodName>;
+/**
+ * Any result response event method name.
+ */
+export declare type AnyResultResponseEventName = ResultResponseEventName<AnyRequestMethodName>;
+/**
+ * Getter of failed event name of a method.
+ */
+export declare type FailedResponseEventName<M extends AnyRequestMethodName> = M extends keyof ReceiveEventMap ? ReceiveEventMap[M]['failed'] : never;
+/**
+ * Getter of result event name of a method.
+ */
+export declare type ResultResponseEventName<M extends AnyRequestMethodName> = M extends keyof ReceiveEventMap ? ReceiveEventMap[M]['result'] : never;
+/**
+ * Getter of request properties of a method.
+ */
+export declare type RequestProps<M extends AnyRequestMethodName = AnyRequestMethodName> = RequestPropsMap[M];
+/**
+ * Getter of response data of a method.
+ */
+export declare type ReceiveData<M extends AnyReceiveMethodName> = ReceiveDataMap[M];
+/**
+ * Property for matching sent request and received message.
+ */
+export declare type RequestIdProp = {
+    request_id?: number | string;
+};
+/**
+ * Client error data.
+ */
+export declare type ErrorDataClientError = {
+    error_code: number;
+    error_reason: string;
+    error_description?: string;
+};
+/**
+ * API error data.
+ */
+export declare type ErrorDataAPIError = {
+    error_code: number;
+    error_msg: string;
+    request_params: string[];
+};
+/**
+ * Auth error data.
+ */
+export declare type ErrorDataAuthError = {
+    error_code: number;
+    error_reason: string;
+    error_description?: string[];
+};
+/**
+ * Type of error data
+ */
+export declare type ErrorData = {
+    error_type: 'client_error';
+    error_data: ErrorDataClientError;
+    request_id?: number | string;
+} | {
+    error_type: 'api_error';
+    error_data: ErrorDataAPIError;
+    request_id?: number | string;
+} | {
+    error_type: 'auth_error';
+    error_data: ErrorDataAuthError;
+    request_id?: number | string;
+};
+/**
+ * Generic event type for creating event types.
+ */
+export declare type VKBridgeEventBase<Type extends string, Data> = {
+    detail: {
+        type: Type;
+        data: Data;
+    };
+};
+/**
+ * Type of error event data
+ */
+export declare type VKBridgeErrorEvent<M extends AnyReceiveMethodName> = VKBridgeEventBase<M extends AnyRequestMethodName ? FailedResponseEventName<M> : never, ErrorData>;
+/**
+ * Type of event that is a response to a request
+ */
+export declare type VKBridgeIOEvent<M extends AnyIOMethodName> = {
+    [K in M]: VKBridgeEventBase<ResultResponseEventName<K>, ReceiveData<K> & RequestIdProp>;
+}[M];
+/**
+ * Type of event that is not a response to a request
+ */
+export declare type VKBridgeReceiveOnlyEvent<M extends AnyReceiveOnlyMethodName> = {
+    [K in M]: VKBridgeEventBase<K, ReceiveData<K>>;
+}[M];
+/**
+ * Type of result event data
+ */
+export declare type VKBridgeResultEvent<M extends AnyReceiveMethodName> = M extends AnyReceiveOnlyMethodName ? VKBridgeReceiveOnlyEvent<M> : M extends AnyIOMethodName ? VKBridgeIOEvent<M> : never;
+/**
+ * VK Bridge event.
+ */
+export declare type VKBridgeEvent<M extends AnyReceiveMethodName> = VKBridgeErrorEvent<M> | VKBridgeResultEvent<M>;
+/**
+ * Type of function that will be subscribed to VK Bridge events.
+ */
+export declare type VKBridgeSubscribeHandler = (event: VKBridgeEvent<AnyReceiveMethodName>) => void;
+/**
+ * Type of send function for methods that have props.
+ *
+ * @param method The method (event) name to send.
+ * @param props Method properties.
+ * @returns The Promise object with response data.
+ */
+export declare type VKBridgeSend = <K extends AnyRequestMethodName>(method: K, props?: RequestProps<K> & RequestIdProp) => Promise<K extends AnyReceiveMethodName ? ReceiveData<K> : void>;
+/**
+ * VK Bridge interface.
+ */
+export interface VKBridge {
+    /**
+     * Sends an event to the runtime env and returns the Promise object with
+     * response data. In the case of Android/iOS application env is the
+     * application itself. In the case of the browser, the parent frame in which
+     * the event handlers is located.
+     *
+     * @param method The method (event) name to send.
+     * @param [props] Method properties.
+     * @returns The Promise object with response data.
+     */
+    send: VKBridgeSend;
+    /**
+     * @alias send
+     * @deprecated
+     */
+    sendPromise: VKBridgeSend;
+    /**
+     * Adds an event listener. It will be called any time a data is received.
+     *
+     * @param listener A callback to be invoked on every event receive.
+     */
+    subscribe: (listener: VKBridgeSubscribeHandler) => void;
+    /**
+     * Removes an event listener which has been subscribed for event listening.
+     *
+     * @param listener A callback to unsubscribe.
+     */
+    unsubscribe: (listener: VKBridgeSubscribeHandler) => void;
+    /**
+     * Checks if a method is supported on runtime platform.
+     *
+     * @param method Method (event) name to check.
+     * @returns Result of checking.
+     * @deprecated This method is deprecated. Use supportsAsync instead.
+     */
+    supports: <K extends AnyRequestMethodName>(method: K) => boolean;
+    /**
+     * Checks if a method is supported on runtime platform.
+     *
+     * @param method Method (event) name to check.
+     * @returns The Promise object with result of checking.
+     */
+    supportsAsync: <K extends AnyRequestMethodName>(method: K) => Promise<boolean>;
+    /**
+     * Checks whether the runtime is a WebView.
+     *
+     * @returns Result of checking.
+     */
+    isWebView: () => boolean;
+    isIframe: () => boolean;
+    isEmbedded: () => boolean;
+    isStandalone: () => boolean;
+}

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/types/deprecated.d.ts

@@ -0,0 +1,56 @@
+import { AnyRequestMethodName, AnyReceiveMethodName, AnyRequestMethodNameWithProps, AnyRequestMethodNameWithoutProps, AnyMethodName, AnyIOMethodName, AnyRequestOnlyMethodName, AnyReceiveOnlyMethodName } from './bridge';
+import { CommunityWidgetType } from './data';
+/**
+ * Name of a method that can be sent.
+ * @alias AnyRequestMethodName
+ * @deprecated
+ */
+export declare type RequestMethodName = AnyRequestMethodName;
+/**
+ * Name of a method that can be received.
+ * @alias AnyReceiveMethodName
+ * @deprecated
+ */
+export declare type ReceiveMethodName = AnyReceiveMethodName;
+/**
+ * Name of a method that can be only sent.
+ * @alias AnyRequestOnlyMethodName
+ * @deprecated
+ */
+export declare type RequestOnlyMethodName = AnyRequestOnlyMethodName;
+/**
+ * Name of a method that can be only received.
+ * @alias AnyReceiveOnlyMethodName
+ * @deprecated
+ */
+export declare type ReceiveOnlyMethodName = AnyReceiveOnlyMethodName;
+/**
+ * Name of a method which contains properties
+ * @alias AnyRequestMethodNameWithProps
+ * @deprecated
+ */
+export declare type RequestMethodNameWithProps = AnyRequestMethodNameWithProps;
+/**
+ * Name of a method which doesn't contain properties
+ * @alias AnyRequestMethodNameWithoutProps
+ * @deprecated
+ */
+export declare type RequestMethodNameWithoutProps = AnyRequestMethodNameWithoutProps;
+/**
+ * Type of any method name.
+ * @alias AnyMethodName
+ * @deprecated
+ */
+export declare type MethodName = AnyMethodName;
+/**
+ * The name of the method that can be both sent and received.
+ * @alias AnyIOMethodName
+ * @deprecated
+ */
+export declare type IOMethodName = AnyIOMethodName;
+/**
+ * Community widget type
+ * @alias CommunityWidgetType
+ * @deprecated
+ */
+export declare type WidgetType = CommunityWidgetType;

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/types/middleware.d.ts

@@ -0,0 +1,13 @@
+import { VKBridgeSend, VKBridgeSubscribeHandler } from './bridge';
+/**
+ * API that can use middleware.
+ */
+export interface MiddlewareAPI<S extends VKBridgeSend = VKBridgeSend, L extends VKBridgeSubscribeHandler = VKBridgeSubscribeHandler> {
+    send: S;
+    subscribe(listener: L): void;
+}
+/**
+ * A middleware is a higher-order function that composes a dispatch function
+ * to return a new `send` function.
+ */
+export declare type Middleware<S extends VKBridgeSend = VKBridgeSend> = (api: MiddlewareAPI<S>) => (next: S) => S;

node_modules/@vkontakte/vk-bridge/dist/types3.8.3/src/utils.d.ts

@@ -0,0 +1 @@
+export declare function createInstanceId(): string;

node_modules/@vkontakte/vk-bridge/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@vkontakte/vk-bridge",
+  "version": "2.15.11",
+  "description": "Connects a Mini App with VK client",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "browser": "dist/index.umd.js",
+  "module": "dist/index.es.js",
+  "umdName": "vkBridge",
+  "types": "dist/types/src/index.d.ts",
+  "typesVersions": {
+    "<4.0": {
+      "*": [
+        "dist/types3.8.3/src/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "watch": "yarn run --top-level rollup -c -w",
+    "build": "NODE_ENV=production yarn run --top-level rollup -c && yarn run build:legacy-types",
+    "build:legacy-types": "yarn run --top-level rollup -c rollup.config-legacy-types.mjs >/dev/null",
+    "prepack": "yarn run build",
+    "test": "yarn run --top-level jest --config ../../jest.config.js"
+  },
+  "author": {
+    "name": "VK",
+    "url": "https://vk.ru"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VKCOM/vk-bridge",
+    "directory": "packages/core"
+  }
+}