@vkid/captcha 1.0.6-JETiT.0

package/dist/esm/core/widget/widget.js

@@ -0,0 +1,406 @@
+import { CAPTCHA_TYPE_2, VIEW_MODE_POPUP, LANGUAGE_ID_BY_CODE } from '../../constants.js';
+import { Bridge } from '../bridge/bridge.js';
+import { BridgeEvents } from '../bridge/types.js';
+import { Config } from '../config/config.js';
+import { Dispatcher } from '../dispatcher/dispatcher.js';
+import { WebBridgeSensor } from '../../types.js';
+import { uuid } from '../../utils/uuid.js';
+import { WIDGET_ERROR_TEXT } from './constants.js';
+import { WidgetEvents, CaptchaEvents } from './events.js';
+import { getWidgetTemplate } from './template.js';
+import { WidgetState, SensorsDataEventTypes, WidgetErrorCode } from './types.js';
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+// const MODULE_LOAD_TIMEOUT = 5000;
+var MODULE_CHANGE_STATE_TIMEOUT = 300;
+var Widget = /*#__PURE__*/ function(Dispatcher) {
+    _inherits(Widget, Dispatcher);
+    function Widget() {
+        var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        _class_call_check(this, Widget);
+        var _this;
+        _this = _call_super(this, Widget), /**
+   * @ignore
+   */ _define_property(_this, "id", uuid()), _define_property(_this, "scheme", void 0), _define_property(_this, "langId", void 0), _define_property(_this, "config", void 0), _define_property(_this, "timeoutTimer", void 0), _define_property(_this, "bridge", void 0), _define_property(_this, "container", void 0), _define_property(_this, "iframeSrc", void 0), _define_property(_this, "captchaType", void 0), _define_property(_this, "autofocus", void 0), _define_property(_this, "view", void 0), _define_property(_this, "onClose", void 0), _define_property(_this, "templateRenderer", getWidgetTemplate), _define_property(_this, "promise", void 0), _define_property(_this, "promiseResolve", void 0), _define_property(_this, "promiseReject", void 0), _define_property(_this, "elements", void 0), /**
+   * Получение координат айфрейма
+   */ _define_property(_this, "getIframeCoords", function() {
+            var _this_elements_iframe_getBoundingClientRect = _this.elements.iframe.getBoundingClientRect(), left = _this_elements_iframe_getBoundingClientRect.left, top = _this_elements_iframe_getBoundingClientRect.top;
+            var scrollX = window.scrollX, scrollY = window.scrollY;
+            return {
+                left: left + scrollX,
+                top: top + scrollY
+            };
+        }), /**
+   * Метод отправки данных движения мыши/событий касания через бридж
+   */ _define_property(_this, "sendSensorsData", function(param) {
+            var eventType = param.eventType, data = param.data;
+            _this.bridge.sendMessage({
+                handler: CaptchaEvents.SEND_WEB_SENSORS,
+                params: {
+                    eventType: eventType,
+                    data: data,
+                    coords: _this.getIframeCoords()
+                }
+            });
+        }), /**
+   * Обработчик движения мыши
+   */ _define_property(_this, "handleMouseMove", function(event) {
+            var pageX = event.pageX, pageY = event.pageY;
+            _this.sendSensorsData({
+                eventType: SensorsDataEventTypes.MOUSE_CHANGE,
+                data: {
+                    pageX: pageX,
+                    pageY: pageY
+                }
+            });
+        }), /**
+   * Обработчик событий касания
+   */ _define_property(_this, "handleTouchMove", function(event) {
+            var touch = event.touches[0];
+            if (touch) {
+                var pageX = touch.pageX, pageY = touch.pageY;
+                _this.sendSensorsData({
+                    eventType: SensorsDataEventTypes.TOUCH_CHANGE,
+                    data: {
+                        pageX: pageX,
+                        pageY: pageY
+                    }
+                });
+            }
+        });
+        _this.config = new Config().init(config);
+        return _this;
+    }
+    _create_class(Widget, [
+        {
+            key: "update",
+            value: function update(config) {
+                return this.config.update(config);
+            }
+        },
+        {
+            key: "show",
+            value: function show(params) {
+                var _this = this;
+                var container = params.container, iframeSrc = params.iframeSrc, captchaType = params.captchaType, view = params.view, autofocus = params.autofocus, scheme = params.scheme, lang = params.lang, onClose = params.onClose;
+                this.promise = new Promise(function(res, rej) {
+                    _this.promiseResolve = res;
+                    _this.promiseReject = rej;
+                });
+                this.container = container;
+                this.iframeSrc = iframeSrc;
+                this.view = captchaType === CAPTCHA_TYPE_2 ? VIEW_MODE_POPUP : view;
+                this.iframeSrc = iframeSrc;
+                this.captchaType = captchaType;
+                this.autofocus = autofocus !== null && autofocus !== void 0 ? autofocus : true;
+                this.scheme = scheme;
+                this.langId = lang ? LANGUAGE_ID_BY_CODE[lang] : undefined;
+                this.onClose = onClose;
+                this.renderTemplate();
+                this.registerElements();
+                this.loadWidgetFrame();
+                return this.promise;
+            }
+        },
+        {
+            key: "close",
+            value: function close() {
+                var _this_elements_root, _this_elements, _this_bridge, _this_promiseReject, _this, _this_onClose, _this1;
+                clearTimeout(this.timeoutTimer);
+                this.removeAnalyticsMouseListeners();
+                this.removeAnalyticsTouchListeners();
+                (_this_elements = this.elements) === null || _this_elements === void 0 ? void 0 : (_this_elements_root = _this_elements.root) === null || _this_elements_root === void 0 ? void 0 : _this_elements_root.remove();
+                (_this_bridge = this.bridge) === null || _this_bridge === void 0 ? void 0 : _this_bridge.destroy();
+                this.events.emit(WidgetEvents.CLOSE);
+                (_this_promiseReject = (_this = this).promiseReject) === null || _this_promiseReject === void 0 ? void 0 : _this_promiseReject.call(_this, 'close');
+                (_this_onClose = (_this1 = this).onClose) === null || _this_onClose === void 0 ? void 0 : _this_onClose.call(_this1);
+            }
+        },
+        {
+            key: "addAnalyticsMouseListeners",
+            value: /**
+   * Метод вызывается для регистрации обработчиков движения мыши
+   */ function addAnalyticsMouseListeners() {
+                document.addEventListener('mouseenter', this.handleMouseMove);
+                document.addEventListener('mouseleave', this.handleMouseMove);
+                document.addEventListener('mousemove', this.handleMouseMove);
+            }
+        },
+        {
+            key: "removeAnalyticsMouseListeners",
+            value: /**
+   * Метод вызывается для удаления обработчиков движения мыши
+   */ function removeAnalyticsMouseListeners() {
+                document.removeEventListener('mouseenter', this.handleMouseMove);
+                document.removeEventListener('mouseleave', this.handleMouseMove);
+                document.removeEventListener('mousemove', this.handleMouseMove);
+            }
+        },
+        {
+            key: "addAnalyticsTouchListeners",
+            value: /**
+   * Метод вызывается для регистрации обработчиков событий касания
+   */ function addAnalyticsTouchListeners() {
+                document.addEventListener('touchstart', this.handleTouchMove);
+                document.addEventListener('touchend', this.handleTouchMove);
+                document.addEventListener('touchmove', this.handleTouchMove);
+            }
+        },
+        {
+            key: "removeAnalyticsTouchListeners",
+            value: /**
+   * Метод вызывается для удаления обработчиков событий касания
+   */ function removeAnalyticsTouchListeners() {
+                document.removeEventListener('touchstart', this.handleTouchMove);
+                document.removeEventListener('touchend', this.handleTouchMove);
+                document.removeEventListener('touchmove', this.handleTouchMove);
+            }
+        },
+        {
+            key: "onLoadHandler",
+            value: /**
+   * Метод вызывается перед началом загрузки iframe с VK ID приложением
+   */ // protected onStartLoadHandler() {
+            //   this.setState(WidgetState.LOADING);
+            //   this.timeoutTimer = setTimeout(() => {
+            //     this.onErrorHandler({
+            //       code: WidgetErrorCode.TimeoutExceeded,
+            //       text: WIDGET_ERROR_TEXT[WidgetErrorCode.TimeoutExceeded],
+            //     });
+            //   }, MODULE_LOAD_TIMEOUT);
+            //   this.events.emit(WidgetEvents.START_LOAD);
+            // }
+            /**
+   * Метод вызывается после того, как полностью загружен iframe с VK ID приложением
+   */ function onLoadHandler() {
+                var _this = this;
+                clearTimeout(this.timeoutTimer);
+                setTimeout(function() {
+                    // Задержка избавляет от моргания замены шаблона на iframe
+                    _this.setState(WidgetState.LOADED);
+                }, MODULE_CHANGE_STATE_TIMEOUT);
+                this.events.emit(WidgetEvents.LOAD);
+            }
+        },
+        {
+            key: "onErrorHandler",
+            value: /**
+   * Метод вызывается, когда во время работы/загрузки VK ID приложения произошла ошибка
+   */ function onErrorHandler(error) {
+                var _this_elements_iframe, _this_elements, _this_promiseReject, _this;
+                clearTimeout(this.timeoutTimer);
+                this.setState(WidgetState.NOT_LOADED);
+                this.events.emit(WidgetEvents.ERROR, error);
+                (_this_elements = this.elements) === null || _this_elements === void 0 ? void 0 : (_this_elements_iframe = _this_elements.iframe) === null || _this_elements_iframe === void 0 ? void 0 : _this_elements_iframe.remove();
+                (_this_promiseReject = (_this = this).promiseReject) === null || _this_promiseReject === void 0 ? void 0 : _this_promiseReject.call(_this, error.text);
+            }
+        },
+        {
+            key: "onBridgeMessageHandler",
+            value: /**
+   * Метод вызывается при сообщениях от VK ID приложения
+   */ function onBridgeMessageHandler(event) {
+                switch(event.handler){
+                    case WidgetEvents.LOAD:
+                        {
+                            this.onLoadHandler();
+                            break;
+                        }
+                    case CaptchaEvents.CLOSE:
+                    case WidgetEvents.CLOSE:
+                        {
+                            this.close();
+                            break;
+                        }
+                    case WidgetEvents.ERROR:
+                        {
+                            this.onErrorHandler({
+                                code: WidgetErrorCode.InternalError,
+                                text: WIDGET_ERROR_TEXT[WidgetErrorCode.InternalError],
+                                details: event.params
+                            });
+                            break;
+                        }
+                    case WidgetEvents.RESIZE:
+                        {
+                            this.elements.root.style.height = "".concat(event.params.height, "px");
+                            break;
+                        }
+                    case CaptchaEvents.GET_RESULT:
+                        {
+                            var successToken = event.params.token;
+                            this.promiseResolve(successToken);
+                            break;
+                        }
+                    case CaptchaEvents.SENSORS_START:
+                        {
+                            var _event_params = event.params, sensorsList = _event_params.bridge_sensors_list;
+                            var isCursorSensorRequired = sensorsList.includes(WebBridgeSensor.CURSOR);
+                            var isTapsSensorRequired = sensorsList.includes(WebBridgeSensor.TAPS);
+                            if (isCursorSensorRequired || isTapsSensorRequired) {
+                                this.sendSensorsData({
+                                    eventType: SensorsDataEventTypes.INIT
+                                });
+                            }
+                            if (isCursorSensorRequired) {
+                                this.addAnalyticsMouseListeners();
+                            }
+                            if (isTapsSensorRequired) {
+                                this.addAnalyticsTouchListeners();
+                            }
+                            break;
+                        }
+                    case CaptchaEvents.SENSORS_STOP:
+                        {
+                            this.removeAnalyticsMouseListeners();
+                            this.removeAnalyticsTouchListeners();
+                            break;
+                        }
+                }
+            }
+        },
+        {
+            key: "renderTemplate",
+            value: // <Дополнительные хелперы>
+            function renderTemplate() {
+                this.container.insertAdjacentHTML('beforeend', this.templateRenderer(this.id, this.view));
+            }
+        },
+        {
+            key: "loadWidgetFrame",
+            value: function loadWidgetFrame() {
+                var _this = this;
+                // this.onStartLoadHandler();
+                var iframeSrc = new URL(this.iframeSrc);
+                this.bridge = new Bridge({
+                    iframe: this.elements.iframe,
+                    origin: iframeSrc.origin
+                });
+                this.bridge.on(BridgeEvents.MESSAGE, function(event) {
+                    return _this.onBridgeMessageHandler(event);
+                });
+                var iframeSearchParams = new URLSearchParams(iframeSrc.search);
+                switch(true){
+                    case !!this.scheme:
+                        iframeSearchParams.set('scheme', this.scheme);
+                    case !!this.langId:
+                        iframeSearchParams.set('lang_id', this.langId);
+                    default:
+                        iframeSearchParams.set('autofocus', this.autofocus ? '1' : '0');
+                        var origin = location.protocol + '//' + location.hostname;
+                        iframeSearchParams.set('origin', origin);
+                        if (this.captchaType !== CAPTCHA_TYPE_2) {
+                            iframeSearchParams.set('variant', this.view);
+                        }
+                        break;
+                }
+                iframeSrc = new URL("".concat(iframeSrc.origin).concat(iframeSrc.pathname, "?").concat(iframeSearchParams));
+                this.elements.iframe.src = iframeSrc.href;
+            }
+        },
+        {
+            key: "setState",
+            value: function setState(state) {
+                this.elements.root.setAttribute('data-state', state);
+            }
+        },
+        {
+            key: "registerElements",
+            value: function registerElements() {
+                var root = document.getElementById(this.id);
+                this.elements = {
+                    root: root,
+                    iframe: root.querySelector('iframe')
+                };
+            }
+        }
+    ]);
+    return Widget;
+}(Dispatcher);
+
+export { Widget };

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+import { Widget } from './core/widget/widget.js';
+import { checkCaptchaError } from './utils/checkCaptchaError/checkCaptchaError.js';
+export { CheckCaptchaType } from './utils/checkCaptchaError/types.js';
+
+if (typeof window !== 'undefined') {
+    window._vkidCaptchaWidget = Widget;
+    window._vkidCaptchaCheckError = checkCaptchaError;
+}
+
+export { Widget as CaptchaWidget, checkCaptchaError };

package/dist/esm/lib/.pnpm/mitt@1.2.0/lib/mitt/dist/mitt.es.js

@@ -0,0 +1,63 @@
+//      
+// An event handler can take an optional event argument
+// and should not return a value
+                                          
+                                                               
+
+// An array of all currently registered event handlers for a type
+                                            
+                                                            
+// A map of event types and their corresponding event handlers.
+                        
+                                 
+                                   
+  
+
+/** Mitt: Tiny (~200b) functional event emitter / pubsub.
+ *  @name mitt
+ *  @returns {Mitt}
+ */
+function mitt(all                 ) {
+	all = all || Object.create(null);
+
+	return {
+		/**
+		 * Register an event handler for the given type.
+		 *
+		 * @param  {String} type	Type of event to listen for, or `"*"` for all events
+		 * @param  {Function} handler Function to call in response to given event
+		 * @memberOf mitt
+		 */
+		on: function on(type        , handler              ) {
+			(all[type] || (all[type] = [])).push(handler);
+		},
+
+		/**
+		 * Remove an event handler for the given type.
+		 *
+		 * @param  {String} type	Type of event to unregister `handler` from, or `"*"`
+		 * @param  {Function} handler Handler function to remove
+		 * @memberOf mitt
+		 */
+		off: function off(type        , handler              ) {
+			if (all[type]) {
+				all[type].splice(all[type].indexOf(handler) >>> 0, 1);
+			}
+		},
+
+		/**
+		 * Invoke all handlers for the given type.
+		 * If present, `"*"` handlers are invoked after type-matched handlers.
+		 *
+		 * @param {String} type  The event type to invoke
+		 * @param {Any} [evt]  Any value (object is recommended and powerful), passed to each handler
+		 * @memberOf mitt
+		 */
+		emit: function emit(type        , evt     ) {
+			(all[type] || []).slice().map(function (handler) { handler(evt); });
+			(all['*'] || []).slice().map(function (handler) { handler(type, evt); });
+		}
+	};
+}
+
+export { mitt as default };

package/dist/esm/lib/.pnpm/nanoid@3.3.11/lib/nanoid/non-secure/index.js

@@ -0,0 +1,12 @@
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = '';
+    let i = size | 0;
+    while (i--) {
+      id += alphabet[(Math.random() * alphabet.length) | 0];
+    }
+    return id
+  }
+};
+
+export { customAlphabet };

package/dist/esm/types.js

@@ -0,0 +1,7 @@
+var WebBridgeSensor = /*#__PURE__*/ function(WebBridgeSensor) {
+    WebBridgeSensor["CURSOR"] = "cursor";
+    WebBridgeSensor["TAPS"] = "taps";
+    return WebBridgeSensor;
+}({});
+
+export { WebBridgeSensor };

package/dist/esm/utils/checkCaptchaError/checkCaptchaError.js

@@ -0,0 +1,134 @@
+import { Widget } from '../../core/widget/widget.js';
+import { CheckCaptchaType } from './types.js';
+import { getChallengeUrlDomain } from './utils.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+var ERROR_CODE_CAPTCHA = 14;
+var ERROR_TYPE_CAPTCHA = 'captcha';
+var checkCaptchaError = function(param) {
+    var responseHeaders = param.responseHeaders, url = param.url, responseError = param.responseError, withWidget = param.withWidget, widgetConfig = param.widgetConfig;
+    var isChallengeRequired = responseHeaders.get('X-Challenge') === 'required';
+    var challengeUrl = responseHeaders.get('X-Challenge-Url');
+    var isCaptchaType2 = isChallengeRequired && !!challengeUrl;
+    var isApiCaptchaError = responseError && 'error_code' in responseError && responseError.error_code === ERROR_CODE_CAPTCHA;
+    var isLoginCaptchaError = responseError && 'type' in responseError && responseError.type === ERROR_TYPE_CAPTCHA;
+    var isCaptchaType1 = (isApiCaptchaError || isLoginCaptchaError) && !!responseError.redirect_uri;
+    var isUnknownCaptcha = (isApiCaptchaError || isLoginCaptchaError) && !responseError.redirect_uri;
+    if (isCaptchaType2) {
+        var iframeSrc = "https://".concat(getChallengeUrlDomain(url)).concat(challengeUrl);
+        if (!withWidget) {
+            return {
+                captchaType: CheckCaptchaType.TYPE_2,
+                captchaUrl: iframeSrc
+            };
+        }
+        var widget = new Widget(widgetConfig);
+        return {
+            captchaType: CheckCaptchaType.TYPE_2,
+            captchaUrl: iframeSrc,
+            captchaWidget: {
+                show: function(params) {
+                    return widget.show(_object_spread_props(_object_spread({}, params), {
+                        iframeSrc: iframeSrc,
+                        captchaType: CheckCaptchaType.TYPE_2
+                    }));
+                },
+                close: function() {
+                    return widget.close();
+                },
+                update: function(config) {
+                    return widget.update(config);
+                }
+            }
+        };
+    }
+    if (isCaptchaType1) {
+        var iframeSrc1 = responseError.redirect_uri || '';
+        if (!withWidget) {
+            return {
+                captchaType: CheckCaptchaType.TYPE_1,
+                captchaUrl: iframeSrc1
+            };
+        }
+        var widget1 = new Widget(widgetConfig);
+        return {
+            captchaType: CheckCaptchaType.TYPE_1,
+            captchaUrl: iframeSrc1,
+            captchaWidget: {
+                show: function(params) {
+                    return widget1.show(_object_spread_props(_object_spread({}, params), {
+                        iframeSrc: iframeSrc1,
+                        captchaType: CheckCaptchaType.TYPE_1
+                    }));
+                },
+                close: function() {
+                    return widget1.close();
+                },
+                update: function(config) {
+                    return widget1.update(config);
+                }
+            }
+        };
+    }
+    if (isUnknownCaptcha) {
+        return {
+            captchaType: CheckCaptchaType.UNKNOWN
+        };
+    }
+    return {
+        captchaType: null
+    };
+};
+
+export { checkCaptchaError };

package/dist/esm/utils/checkCaptchaError/types.js

@@ -0,0 +1,10 @@
+import { CAPTCHA_TYPE_1, CAPTCHA_TYPE_2 } from '../../constants.js';
+
+var CheckCaptchaType = /*#__PURE__*/ function(CheckCaptchaType) {
+    CheckCaptchaType[CheckCaptchaType["TYPE_1"] = CAPTCHA_TYPE_1] = "TYPE_1";
+    CheckCaptchaType[CheckCaptchaType["TYPE_2"] = CAPTCHA_TYPE_2] = "TYPE_2";
+    CheckCaptchaType["UNKNOWN"] = "unknown";
+    return CheckCaptchaType;
+}({});
+
+export { CheckCaptchaType };

package/dist/esm/utils/checkCaptchaError/utils.js

@@ -0,0 +1,11 @@
+var getChallengeUrlDomain = function(url) {
+    var hostname = new URL(url).hostname;
+    var hostnameSplitted = hostname.split('.');
+    if (hostnameSplitted.length > 2) {
+        hostnameSplitted.shift();
+        return hostnameSplitted.join('.');
+    }
+    return hostname;
+};
+
+export { getChallengeUrlDomain };

package/dist/esm/utils/uuid.js

@@ -0,0 +1,5 @@
+import { customAlphabet } from './../lib/.pnpm/nanoid@3.3.11/lib/nanoid/non-secure/index.js';
+
+var uuid = customAlphabet('qazwsxedcrfvtgbyhnujmikol', 6);
+
+export { uuid };